บ้าน แฟชั่นและสไตล์ สิ่งที่ควรอยู่ใน c-file และสิ่งที่ควรอยู่ใน h-file? ออนไลน์รวมไฟล์ต้นฉบับ C หนึ่งไฟล์ไว้ในอีกไฟล์หนึ่งหรือไม่? สิ่งที่สามารถอยู่ในไฟล์ส่วนหัว

สิ่งที่ควรอยู่ใน c-file และสิ่งที่ควรอยู่ใน h-file? ออนไลน์รวมไฟล์ต้นฉบับ C หนึ่งไฟล์ไว้ในอีกไฟล์หนึ่งหรือไม่? สิ่งที่สามารถอยู่ในไฟล์ส่วนหัว

ใช้อย่างถูกต้องนี่อาจเป็นวิธีที่มีประโยชน์

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

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

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

หากคุณรวมทุกอย่างไว้ในโมดูลซอร์ส C เดียวคุณจะได้รับ -

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

ข้อมูลระดับช่องและฟังก์ชั่นถูกซ่อนอยู่

หลีกเลี่ยงมลภาวะเนมสเปซและผลที่ตามมา - คุณสามารถใช้ชื่อที่ยุ่งยากน้อยลงได้

การรวบรวมและการสื่อสารที่รวดเร็วยิ่งขึ้น

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

อย่างไรก็ตาม คุณต้องกำหนดแบบแผนบางประการเพื่อจัดการกับเรื่องนี้ สิ่งนี้จะขึ้นอยู่กับ toolchain ของคุณในระดับหนึ่ง แต่มีคำแนะนำทั่วไปบางประการ

วางส่วนต่อประสานสาธารณะไว้ในไฟล์ส่วนหัวแยกต่างหาก - คุณยังควรทำสิ่งนี้อยู่

มีไฟล์ .c หลักหนึ่งไฟล์ที่รวมไฟล์ .c ลูกทั้งหมด ซึ่งอาจรวมถึงโค้ดสำหรับอินเทอร์เฟซแบบเปิดด้วย

ใช้ตัวป้องกันคอมไพเลอร์เพื่อป้องกันไม่ให้ส่วนหัวส่วนตัวและโมดูลต้นทางถูกรวมไว้ในโมดูลการคอมไพล์ภายนอก

ข้อมูลส่วนบุคคลและฟังก์ชันทั้งหมดจะต้องประกาศให้เป็นแบบคงที่

รักษาความแตกต่างทางแนวคิดระหว่างไฟล์ .c และ .h สิ่งนี้ใช้แบบแผนที่มีอยู่ ความแตกต่างก็คือ คุณจะมีโฆษณาคงที่จำนวนมากในส่วนหัวของคุณ

หาก toolchain ของคุณไม่ได้กำหนดสิ่งใด คุณไม่ควรระบุไฟล์การใช้งานส่วนตัว เช่น .c และ .h หากคุณใช้ยามที่เปิดใช้งาน พวกเขาจะไม่สร้างโค้ดและจะไม่แนะนำชื่อใหม่ใด ๆ (คุณอาจจบลงด้วยส่วนที่ว่างเปล่าบางส่วน) ข้อดีอย่างมากคือเครื่องมืออื่นๆ (เช่น IDE) จะจัดการไฟล์เหล่านี้ตามนั้น

นามสกุลไฟล์ไม่สำคัญสำหรับคอมไพเลอร์ภาษา C ส่วนใหญ่ ดังนั้นจึงใช้ได้

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

ภาษา C ไม่ได้ห้าม #include ประเภทนี้ แต่หน่วยการแปลผลลัพธ์จะต้องยังคงเป็น C ที่ถูกต้อง

ฉันไม่รู้ว่าคุณใช้โปรแกรมอะไรกับไฟล์ .prj หากคุณใช้บางอย่างเช่น "make" หรือ Visual Studio หรืออะไรก็ตาม เพียงตรวจสอบให้แน่ใจว่าคุณได้ตั้งค่าเป็นรายการไฟล์ที่ต้องคอมไพล์ โดยไม่มีไฟล์ที่ไม่สามารถคอมไพล์แยกกันได้

คุณสามารถรวมไฟล์ .C หรือ .CPP ในไฟล์ต้นฉบับอื่นๆ ได้อย่างถูกต้อง ขึ้นอยู่กับ IDE ของคุณ โดยปกติคุณสามารถป้องกันการลิงก์ซ้ำได้โดยการดูคุณสมบัติของไฟล์ต้นฉบับที่คุณต้องการรวม โดยทั่วไปโดยการคลิกขวาที่ไฟล์เหล่านั้นและคลิกที่คุณสมบัติ และยกเลิกการเลือก /ตรวจสอบการคอมไพล์/ลิงก์/ยกเว้นจากบิลด์หรืออื่น ๆ ตัวเลือก . อาจจะ. หรือคุณไม่สามารถรวมไฟล์ไว้ในโปรเจ็กต์ได้ ดังนั้น IDE จึงไม่รู้ด้วยซ้ำว่ามีไฟล์อยู่และจะไม่พยายามคอมไพล์มัน และด้วย makefiles คุณเพียงแค่ไม่ต้องใส่ไฟล์ลงไปเพื่อคอมไพล์และลิงก์

แก้ไข: ขออภัย ฉันให้คำตอบแทนที่จะตอบคำตอบอื่น :(

การรวมไฟล์ C ไว้ในไฟล์อื่นนั้นถูกกฎหมาย แต่ไม่แนะนำ เว้นแต่คุณจะทราบแน่ชัดว่าทำไมคุณถึงทำมันและสิ่งที่คุณพยายามทำให้สำเร็จ
ฉันค่อนข้างแน่ใจว่าหากคุณโพสต์เหตุผลที่คำถามของคุณจะถูกสื่อสารไปยังชุมชนที่นี่ คุณจะพบวิธีอื่นที่เหมาะสมในการบรรลุเป้าหมายของคุณ (หมายเหตุว่า "เกือบ" เนื่องจากเป็นไปได้ว่านี่เป็นวิธีแก้ปัญหาตามบริบท) .

ยังไงซะ ฉันพลาดส่วนที่สองของคำถามไป หากไฟล์ C รวมอยู่ในไฟล์อื่นและในเวลาเดียวกันก็รวมอยู่ในโปรเจ็กต์ คุณอาจประสบปัญหาเกี่ยวกับสัญลักษณ์ที่ซ้ำกัน สาเหตุที่ลิงก์อ็อบเจ็กต์ เช่น ฟังก์ชันเดียวกันจะถูกกำหนดสองครั้ง (เว้นแต่ว่าไฟล์เหล่านั้นจะเป็นแบบคงที่)

ขึ้นอยู่กับสภาพแวดล้อมการสร้างของคุณ (คุณจะไม่ระบุ) คุณอาจพบว่ามันทำงานตามที่คุณต้องการ

อย่างไรก็ตาม มีสภาพแวดล้อมมากมาย (ทั้ง IDE และ Makefile ที่ทำด้วยมือจำนวนมาก) ที่คาดหวังว่า *.c จะต้องถูกคอมไพล์ - หากสิ่งนี้เกิดขึ้น คุณจะพบข้อผิดพลาดของตัวเชื่อมโยงเนื่องจากสัญลักษณ์ที่ซ้ำกัน

โดยทั่วไปควรหลีกเลี่ยงการปฏิบัตินี้

หากคุณต้อง # รวมแหล่งที่มาอย่างแน่นอน (และโดยทั่วไปควรหลีกเลี่ยง) ให้ใช้ไฟล์อื่นสำหรับไฟล์นั้น

นี่สบายดีใช่ไหม? ใช่ มันจะรวบรวม

นี่แนะนำเหรอ? ไฟล์ no - .c จะถูกคอมไพล์เป็นไฟล์ .obj ซึ่งเชื่อมโยงหลังจากการคอมไพล์ (โดยตัวเชื่อมโยง) ไปยังไฟล์ปฏิบัติการ (หรือไลบรารี) ดังนั้นจึงไม่จำเป็นต้องรวมไฟล์ .c หนึ่งไฟล์ไว้ในอีกไฟล์หนึ่ง คุณมักจะต้องการสร้างไฟล์ .h ที่แสดงรายการฟังก์ชัน/ตัวแปรที่มีอยู่ในไฟล์ .c อื่น และรวมไฟล์ .h ไว้ด้วย

คุณสามารถใช้คอมไพเลอร์ gcc บน linux เพื่อลิงก์สองไฟล์กับเอาต์พุตเดียว สมมติว่าคุณมีไฟล์ c สองไฟล์ ไฟล์หนึ่งคือ "main.c" และอีกไฟล์คือ "support.c" ดังนั้นคำสั่งให้เชื่อมต่อสองตัวนี้ก็คือ

Gcc main.c support.c -o main.out

สองไฟล์นี้จะเชื่อมโยงกับ main.out หนึ่งไฟล์ ในการรันเอาต์พุตคำสั่งจะเป็น

./main.out

หากคุณใช้ฟังก์ชัน main.c ซึ่งได้รับการประกาศในไฟล์ support.c คุณควรประกาศฟังก์ชันดังกล่าวใน main และใช้คลาสพื้นที่เก็บข้อมูลภายนอกด้วย

แก้ไข: ขออภัย ฉันให้คำตอบแทนที่จะตอบคำตอบอื่น :(

โดยทั่วไปควรหลีกเลี่ยงการปฏิบัตินี้

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

การรวมไฟล์ .c ทำให้เรามีโอกาสเข้าถึงฟันเฟืองในเครื่อง ซึ่งน่าสนใจสำหรับเราในการทดสอบ

คุณควรเพิ่มส่วนหัวเช่นนี้

#รวม

หมายเหตุ: ต้องวางทั้งสองไฟล์ไว้ในที่เดียวกัน

Gcc main.c support.c -o main.out

สองไฟล์นี้จะเชื่อมโยงกับ main.out หนึ่งไฟล์ ในการรันเอาต์พุตคำสั่งจะเป็น

./main.out

นามสกุลไฟล์ไม่สำคัญสำหรับคอมไพเลอร์ภาษา C ส่วนใหญ่ ดังนั้นจึงใช้ได้

ไฟล์ต้นฉบับ

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

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

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

คำแนะนำสำหรับคอมไพลเลอร์มักจะใช้กับส่วนเฉพาะของไฟล์ต้นฉบับเท่านั้น การดำเนินการของคอมไพเลอร์เฉพาะที่ระบุโดยคำแนะนำนั้นถูกกำหนดโดยการใช้งานเฉพาะของคอมไพเลอร์ C

ในตัวอย่างต่อไปนี้ โปรแกรมต้นฉบับประกอบด้วยไฟล์ต้นฉบับสองไฟล์ ฟังก์ชั่น หลักและ สูงสุดนำเสนอเป็นไฟล์แยกกัน การทำงาน หลักใช้ฟังก์ชัน สูงสุดในกระบวนการดำเนินการ

/* ไฟล์ต้นฉบับ 1 - ฟังก์ชั่นหลัก */

ภายนอก int max(int, int); /* ประกาศฟังก์ชัน */

main() /* นิยามฟังก์ชัน */

int w = หนึ่ง, x = สอง, y = สาม;

/* ไฟล์ต้นฉบับ 2 - ฟังก์ชั่นสูงสุด */

int max (a, b) /* นิยามฟังก์ชัน */

ในไฟล์ต้นฉบับแรกฟังก์ชัน สูงสุดประกาศแต่ไม่ได้กำหนดไว้ การประกาศฟังก์ชันนี้เรียกว่าการประกาศล่วงหน้า อนุญาตให้คอมไพเลอร์ควบคุมการเรียกฟังก์ชันก่อนที่จะถูกกำหนด ความหมายของฟังก์ชัน หลักมีการเรียกใช้ฟังก์ชัน สูงสุด.

บรรทัดที่ขึ้นต้นด้วยสัญลักษณ์ # คือคำสั่งของตัวประมวลผลล่วงหน้า คำสั่งระบุให้ผู้ประมวลผลล่วงหน้าทราบถึงความจำเป็นในการแทนที่ตัวระบุ ONE, TWO, THREE ด้วยค่าที่สอดคล้องกันในไฟล์ต้นฉบับแรก ขอบเขตของคำสั่งไม่ขยายไปยังไฟล์ต้นฉบับที่สอง

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

ส่วนหนึ่งมันเป็นเรื่องของรสนิยม ดังนั้นหากใครสนใจว่าฉันจะทำยังไงก็ยินดีต้อนรับเจ้าแมว

แม้ว่า "ความจริงทั้งหมด" เกี่ยวกับไฟล์ h จะอยู่ในส่วนที่เกี่ยวข้องของคำอธิบายของตัวประมวลผลล่วงหน้า gcc แต่ฉันจะให้คำอธิบายและภาพประกอบบางอย่างกับตัวเอง

ดังนั้น แท้จริงแล้ว ไฟล์ส่วนหัว (h-file) จึงเป็นไฟล์ที่มีการประกาศ C และคำจำกัดความของแมโครที่มีไว้สำหรับใช้ในไฟล์ต้นฉบับหลายไฟล์ (c-files) เรามาอธิบายเรื่องนี้กัน

สังเกตได้ง่ายว่ามีการกล่าวถึงฟังก์ชัน 1 และ 2 รวมถึงมาโคร 2 ในทั้งสองไฟล์ และเนื่องจากการรวมไฟล์ส่วนหัวให้ผลลัพธ์เหมือนกับการคัดลอกเนื้อหาลงในไฟล์ C แต่ละไฟล์ เราจึงสามารถทำสิ่งต่อไปนี้ได้:

ดังนั้นเราจึงเพียงแค่แยกส่วนทั่วไปของไฟล์ทั้งสองและวางไว้ในไฟล์ส่วนหัว
แต่ไฟล์ส่วนหัวเป็นส่วนต่อประสานในกรณีนี้หรือไม่

หากเราจำเป็นต้องใช้ฟังก์ชันการทำงานที่ฟังก์ชัน 1 และ 2 นำไปใช้ที่อื่น แสดงว่าใช่
หากมาโคร 2 มีไว้สำหรับใช้ในไฟล์ Unit1.c และ Unit2.c เท่านั้น จะไม่มีตำแหน่งในไฟล์อินเทอร์เฟซ

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

ตัวเลือกการใช้งานนี้นำไปสู่การเชื่อมโยงโค้ดที่สูง ความสามารถในการทดสอบต่ำ และความยากลำบากในการนำโมดูลดังกล่าวกลับมาใช้ใหม่
เพื่อหลีกเลี่ยงปัญหาดังกล่าว ฉันมักจะถือว่าไฟล์ C และไฟล์ส่วนหัวเป็นโมดูลเดียวเสมอ ซึ่งใน,

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

ดังนั้น หากฉันจะติดตั้งโค้ดที่สอดคล้องกับไดอะแกรมด้านบน ฉันจะพยายามทำสิ่งต่อไปนี้ (ส่วนท้าย _с และ _h ในชื่อไฟล์ถูกเพิ่มเข้าไป เนื่องจากไม่สามารถใช้จุดในเครื่องมือที่ฉันใช้สร้างไม่ได้ แผนภาพ):

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

ฉันหวังว่าฉันจะสามารถระบุเอนทิตีเหล่านั้นที่ต้องวางไว้ในไฟล์ส่วนหัวได้ และยังแสดงความแตกต่างระหว่างอินเทอร์เฟซและไฟล์ที่มีการประกาศและมาโครที่จำเป็นสำหรับไฟล์ C หลายไฟล์

ขอขอบคุณที่ให้ความสนใจกับเนื้อหา