ความจริงก็คือใน C ++ สิ่งนี้ค่อนข้างซับซ้อนกว่าที่องค์กรส่วนหัว / แหล่งที่มาของ C
คอมไพเลอร์มองเห็นอะไร?
คอมไพเลอร์มองเห็นไฟล์ซอร์สขนาดใหญ่ (.cpp) หนึ่งไฟล์ที่มีส่วนหัวรวมอยู่อย่างถูกต้อง ซอร์สไฟล์คือหน่วยคอมไพล์ที่จะถูกคอมไพล์เป็นอ็อบเจ็กต์ไฟล์
เหตุใดส่วนหัวจึงจำเป็น?
เนื่องจากหน่วยคอมไพล์หนึ่งหน่วยอาจต้องการข้อมูลเกี่ยวกับการนำไปใช้งานในหน่วยคอมไพล์อื่น ดังนั้นเราสามารถเขียนตัวอย่างการนำฟังก์ชันไปใช้ในแหล่งเดียวและเขียนการประกาศฟังก์ชันนี้ในแหล่งอื่นที่จำเป็นต้องใช้
ในกรณีนี้มีสำเนาข้อมูลเดียวกันสองชุด ซึ่งชั่วร้าย ...
วิธีแก้ปัญหาคือการแบ่งปันรายละเอียดบางอย่าง ในขณะที่การนำไปใช้งานควรจะยังคงอยู่ใน Source การประกาศสัญลักษณ์ที่ใช้ร่วมกันเช่นฟังก์ชันหรือคำจำกัดความของโครงสร้างคลาส enums ฯลฯ อาจจำเป็นต้องแชร์
ส่วนหัวใช้เพื่อใส่รายละเอียดที่แชร์เหล่านั้น
ย้ายไปที่ส่วนหัวของการประกาศสิ่งที่ต้องใช้ร่วมกันระหว่างแหล่งที่มาหลายแหล่ง
ไม่มีอะไรมาก?
ใน C ++ มีสิ่งอื่น ๆ ที่สามารถใส่ไว้ในส่วนหัวได้เนื่องจากต้องการแชร์ด้วยเช่นกัน:
- รหัสอินไลน์
- เทมเพลต
- ค่าคงที่ (โดยปกติจะเป็นค่าที่คุณต้องการใช้ภายในสวิตช์ ... )
ย้ายไปที่ส่วนหัวทุกสิ่งที่ต้องแชร์รวมถึงการใช้งานร่วมกัน
หมายความว่าอาจมีแหล่งที่มาภายในส่วนหัวหรือไม่?
ใช่. อันที่จริงมีหลายสิ่งหลายอย่างที่อาจอยู่ใน "ส่วนหัว" (เช่นใช้ร่วมกันระหว่างแหล่งที่มา)
- ประกาศไปข้างหน้า
- การประกาศ / คำจำกัดความของฟังก์ชัน / โครงสร้าง / คลาส / เทมเพลต
- การใช้โค้ดแบบอินไลน์และเทมเพลต
กลายเป็นเรื่องซับซ้อนและในบางกรณี (การอ้างอิงแบบวงกลมระหว่างสัญลักษณ์) ไม่สามารถเก็บไว้ในส่วนหัวเดียวได้
ส่วนหัวสามารถแบ่งออกเป็นสามส่วน
ซึ่งหมายความว่าในกรณีที่รุนแรงคุณสามารถมี:
- ส่วนหัวของการประกาศไปข้างหน้า
- ส่วนหัวคำประกาศ / คำจำกัดความ
- ส่วนหัวการใช้งาน
- แหล่งที่มาของการนำไปใช้งาน
ลองจินตนาการว่าเรามี MyObject ที่เป็นเทมเพลต เราสามารถมี:
template<typename T>
class MyObject ;
.
#include <MyObject_forward.hpp>
template<typename T>
class MyObject
{
public :
MyObject() ;
} ;
void doSomething() ;
.
#include <MyObject_declaration.hpp>
template<typename T>
MyObject<T>::MyObject()
{
doSomething() ;
}
.
#include <MyObject_implementation.hpp>
void doSomething()
{
} ;
ว้าว!
ใน "ชีวิตจริง" มักจะซับซ้อนน้อยกว่า โค้ดส่วนใหญ่จะมีเฉพาะส่วนหัว / แหล่งที่มาที่เรียบง่ายโดยมีโค้ดอินไลน์บางส่วนในซอร์ส
แต่ในกรณีอื่น ๆ (อ็อบเจ็กต์ที่เทมเพลตซึ่งรู้จักกัน) ฉันต้องมีสำหรับแต่ละอ็อบเจ็กต์การประกาศและส่วนหัวการนำไปใช้งานแยกกันโดยมีซอร์สที่ว่างเปล่ารวมถึงส่วนหัวเหล่านั้นเพื่อช่วยให้ฉันเห็นข้อผิดพลาดในการคอมไพล์
อีกเหตุผลหนึ่งในการแบ่งส่วนหัวออกเป็นส่วนหัวที่แยกจากกันอาจเป็นการเร่งความเร็วในการรวบรวม จำกัด ปริมาณของสัญลักษณ์ที่แยกวิเคราะห์ตามความจำเป็นที่เข้มงวดและหลีกเลี่ยงการคอมไพล์ซ้ำโดยไม่จำเป็นของแหล่งที่มาซึ่งใส่ใจเฉพาะการประกาศไปข้างหน้าเมื่อการปรับใช้วิธีการแบบอินไลน์เปลี่ยนไป
สรุป
คุณควรทำให้การจัดระเบียบรหัสของคุณง่ายที่สุดเท่าที่จะเป็นไปได้และแบบแยกส่วนมากที่สุด ใส่ไฟล์ต้นฉบับให้มากที่สุด แสดงเฉพาะในส่วนหัวเท่านั้นสิ่งที่ต้องแชร์
แต่วันที่คุณมีการพึ่งพาแบบวงกลมระหว่างอ็อบเจ็กต์เทมเพลตอย่าแปลกใจถ้าองค์กรโค้ดของคุณค่อนข้าง "น่าสนใจ" มากกว่าที่องค์กรส่วนหัว / แหล่งที่มาธรรมดา
^ _ ^