ฉันมีการบ้านและฉันต้องประเมินว่าแนวทางใดดีกว่าตาม GRASP "รูปแบบที่ได้รับการป้องกัน" ผมพบว่าคำถามในกองมากเกินเกี่ยวกับการแยกส่วนหัวและรหัสไฟล์ใน C ++

อย่างไรก็ตามสิ่งที่ฉันต้องการรู้ว่าทำไม Java ไม่ปฏิบัติตาม C ++ ในการส่งเสริมการแยกระหว่างคำจำกัดความของชั้นเรียนและการใช้งานระดับ มีข้อได้เปรียบกับวิธีการของจาวามากกว่าวิธี C ++ หรือไม่?

มีโค้ดกี่บรรทัดในโปรแกรมต่อไปนี้?

#include <iostream>

int main()
{
   std::cout << "Hello, world!\n";
   return 0;
}

คุณอาจตอบ 7 (หรือ 6 ถ้าคุณไม่นับบรรทัดว่างหรือ 4 ถ้าคุณไม่นับวงเล็บ)

คอมไพเลอร์ของคุณอย่างไรก็ตามเห็นสิ่งที่แตกต่างกันมาก:

~$ cpp hello.cpp | wc
  18736   40822  437015

ใช่นั่นคือ 18.7 KLOC เพียงเพื่อ "สวัสดีโลก!" โปรแกรม. คอมไพเลอร์ C ++ ต้องแยกวิเคราะห์ทั้งหมด นี่คือเหตุผลสำคัญว่าทำไมการรวบรวม C ++ ใช้เวลานานมากเมื่อเทียบกับภาษาอื่นและทำไมภาษาสมัยใหม่จึงหลีกเลี่ยงไฟล์ส่วนหัว

คำถามที่ดีกว่าก็คือ

ทำไมไม่ C ++ มีไฟล์ส่วนหัว?

C ++ ได้รับการออกแบบให้เป็นชุดของ C ดังนั้นจึงต้องเก็บไฟล์ส่วนหัวไว้เพื่อใช้งานร่วมกันได้ย้อนหลัง

ตกลงเหตุใด C จึงมีไฟล์ส่วนหัว

เพราะรูปแบบการรวบรวมแยกดั้งเดิมของมัน ไฟล์อ็อบเจ็กต์ที่สร้างโดยคอมไพเลอร์ C จะไม่รวมข้อมูลประเภทใด ๆ ดังนั้นเพื่อป้องกันข้อผิดพลาดประเภทคุณจำเป็นต้องรวมข้อมูลนี้ในซอร์สโค้ดของคุณ

~$ cat sqrtdemo.c 
int main(void)
{
    /* implicit declaration int sqrt(int) */
    double sqrt2 = sqrt(2);
    printf("%f\n", sqrt2);
    return 0;
}

~$ gcc -Wall -ansi -lm -Dsqrt= sqrtdemo.c
sqrtdemo.c: In function ‘main’:
sqrtdemo.c:5:5: warning: implicit declaration of function ‘printf’ [-Wimplicit-function-declaration]
sqrtdemo.c:5:5: warning: incompatible implicit declaration of built-in function ‘printf’ [enabled by default]
~$ ./a.out 
2.000000

การเพิ่มการประกาศประเภทที่เหมาะสมแก้ไขข้อบกพร่อง:

~$ cat sqrtdemo.c 
#undef printf
#undef sqrt

int printf(const char*, ...);
double sqrt(double);

int main(void)
{
    double sqrt2 = sqrt(2);
    printf("%f\n", sqrt2);
    return 0;
}

~$ gcc -Wall -ansi -lm sqrtdemo.c
~$ ./a.out 
1.414214

แจ้งให้ทราบว่าไม่มี#includes แต่เมื่อคุณใช้ฟังก์ชั่นภายนอกจำนวนมาก (ซึ่งโปรแกรมส่วนใหญ่จะใช้) การประกาศด้วยตนเองจะทำให้เกิดความเบื่อหน่ายและเกิดข้อผิดพลาดได้ง่าย มันง่ายกว่าที่จะใช้ไฟล์ส่วนหัว

ภาษาสมัยใหม่สามารถหลีกเลี่ยงไฟล์ส่วนหัวได้อย่างไร?

โดยใช้รูปแบบไฟล์วัตถุอื่นที่มีข้อมูลประเภท ตัวอย่างเช่นรูปแบบไฟล์ Java * .classมี "descriptors" ซึ่งระบุประเภทของฟิลด์และพารามิเตอร์เมธอด

นี่ไม่ใช่สิ่งประดิษฐ์ใหม่ ก่อนหน้านี้ (1987) เมื่อ Borland เพิ่ม "units" ที่คอมไพล์แล้วลงใน Turbo Pascal 4.0 มันเลือกที่จะใช้*.TPUรูปแบบใหม่แทน Turbo C's *.OBJเพื่อลบความต้องการไฟล์ส่วนหัว

Java มีอินเตอร์เฟสเพื่อกำหนดสัญญา สิ่งนี้ให้ระดับที่สูงขึ้นของนามธรรมจากสิ่งที่ผู้โทรต้องการและการใช้งานจริง เช่นผู้โทรไม่จำเป็นต้องรู้ชั้นเรียนการใช้งานเพียงแค่ต้องรู้สัญญาที่รองรับ

สมมติว่าคุณต้องการเขียนวิธีการที่ทำให้คีย์ / ค่าทั้งหมดช้าลงในแผนที่

public static <K,V> void printMap(Map<K,V> map) {
    for(Entry<K,V> entry: map.entrySet())
        System.out.println(entry);
}

วิธีนี้สามารถเรียก entrySet () บนอินเทอร์เฟซแบบนามธรรมซึ่งถูกลบออกจากคลาสที่ใช้งาน คุณสามารถเรียกวิธีนี้ด้วย

printMap(new TreeMap());
printMap(new LinkedHashMap());
printMap(new ConcurrentHashMap());
printMap(new ConcurrentSkipListMap());

ส่วนหัวมีอยู่ค่อนข้างตรงไปตรงมาเป็นอุบัติเหตุทางประวัติศาสตร์ มันเป็นระบบที่แย่อย่างไม่น่าเชื่อไม่มีภาษาอื่นมีอะไรที่แย่มากและทุกคนที่ไม่ต้องจัดการกับพวกเขาควรชื่นชมยินดี

ส่วนหัวอยู่ที่นั่นเพื่อเปิดใช้งานการรวบรวมแยก โดย #including ส่วนหัวคอมไพเลอร์ไม่จำเป็นต้องรู้อะไรเกี่ยวกับโครงสร้างไบนารีของรหัส C ++ ที่คอมไพล์และสามารถปล่อยให้งานนั้นไปยังตัวเชื่อมโยงแยกต่างหาก Java ไม่ได้ใช้ตัวเชื่อมโยงแยกกับคอมไพเลอร์และเนื่องจากไฟล์. class ถูกกำหนดอย่างเคร่งครัดคอมไพเลอร์สามารถอ่านได้เพื่อกำหนดสมาชิกทั้งหมดด้วยประเภททั้งหมดโดยไม่จำเป็นต้องประกาศใหม่ในแต่ละหน่วยการรวบรวม

คุณสามารถรวมการใช้งานทั้งหมดในส่วนหัว C ++ ได้ แต่จะทำให้คอมไพเลอร์คอมไพล์ใหม่ทุกครั้งที่มี #included บังคับให้ตัวเชื่อมโยงเรียงลำดับแล้วละทิ้งสำเนาที่ซ้ำกัน

Java ส่งเสริมการแยกคำจำกัดความของคลาสและการนำไปใช้งานขึ้นอยู่กับว่าคุณกำลังมองหาที่ใด

เมื่อคุณเป็นผู้เขียนคลาส Java คุณจะเห็นนิยามของคลาสรวมถึงการนำไปใช้ในหนึ่งไฟล์ สิ่งนี้ช่วยให้กระบวนการพัฒนาง่ายขึ้นเนื่องจากคุณเพียงแค่ไปที่เดียวเพื่อรักษาคลาสคุณไม่ต้องสลับไปมาระหว่างสองไฟล์ (.h และ. cpp ตามที่คุณต้องการใน C ++) อย่างไรก็ตามเมื่อคุณเป็นผู้บริโภคในชั้นเรียนคุณจะจัดการกับคำจำกัดความเท่านั้นโดยใช้ไฟล์. class ที่บรรจุใน. jar หรือ. class แบบสแตนด์อโลน

C ++ ช่วยให้คุณสามารถแยกคำจำกัดความและการใช้งาน แต่มันเป็นเฉพาะกิจ ตัวอย่างเช่นไม่มีอะไรจะหยุดคุณเขียนวิธีการแบบอินไลน์ภายในไฟล์ส่วนหัวและสำหรับชั้นเรียนแม่แบบนี้เป็นสิ่งจำเป็น ไฟล์ส่วนหัวยังแสดงรายการตัวแปรสมาชิกใด ๆ ซึ่งจะปรากฏแก่ทุกคนที่ดูไฟล์ส่วนหัวแม้ว่าพวกเขาจะมีรายละเอียดการใช้งานของชั้นเรียนและไม่เกี่ยวข้องกับผู้บริโภค