ไฟล์ส่วนหัวและไฟล์ต้นฉบับ
แยกการประกาศออกจากโค้ด
ไฟล์ส่วนหัวและไฟล์ต้นฉบับ เป็นบทเรียน C Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C Academy มีบทเรียนทั้งหมด 4 บทเรียน
เหตุใดจึงควรแบ่งโค้ดเป็นไฟล์
เมื่อโปรแกรม C มีขนาดใหญ่ขึ้น การเก็บทุกอย่างไว้ในไฟล์ .c เดียวจะทำให้อ่านยากและคอมไพล์ได้ช้าลง
C ช่วยให้คุณแบ่งโครงการออกเป็นหลายไฟล์ได้ โดยแต่ละไฟล์รับผิดชอบเรื่องใดเรื่องหนึ่ง วิธีนี้ช่วยจัดระเบียบ ทำให้ใช้โค้ดซ้ำได้ และทำให้การเปลี่ยนแปลงส่วนหนึ่งไม่บังคับให้คุณต้องคอมไพล์ทุกอย่างใหม่
ไฟล์สองประเภท
โครงการ C แบบแยกส่วนใช้ไฟล์อยู่สองประเภท
ไฟล์ต้นฉบับ (.c) มีการนำไปใช้งานจริง ได้แก่ เนื้อหาฟังก์ชันและการนิยามต่าง ๆ
ไฟล์ส่วนหัว (.h) มีการประกาศ ได้แก่ โพรโทไทป์ของฟังก์ชัน การนิยามชนิดข้อมูล และมาโครที่ไฟล์อื่นจำเป็นต้องทราบ
ไฟล์ส่วนหัว
ไฟล์ส่วนหัวประกาศว่าอะไรมีอยู่ โดยไม่บอกว่าทำงานอย่างไร
ในที่นี้ math_utils.h ประกาศฟังก์ชัน add ไฟล์ใดก็ตามที่รวมไฟล์ส่วนหัวนี้จะทราบรูปแบบการประกาศของฟังก์ชันและสามารถเรียกใช้ได้
/* math_utils.h */
int add(int a, int b);ไฟล์ต้นฉบับที่สอดคล้องกัน
ไฟล์ต้นฉบับจัดเตรียมการนำไปใช้งานจริง โดยรวมไฟล์ส่วนหัวของตัวเองเพื่อให้คอมไพเลอร์ตรวจสอบว่าการนิยามตรงกับการประกาศ
สังเกตว่าไฟล์ส่วนหัวถูกระบุด้วยเครื่องหมายอัญประกาศ ซึ่งใช้สำหรับไฟล์ของโครงการคุณเอง
/* math_utils.c */
#include "math_utils.h"
int add(int a, int b) {
return a + b;
}การใช้มอดูล
ตอนนี้ main.c รวมไฟล์ส่วนหัวและเรียกใช้ add โดยไม่เคยเห็นเนื้อหาฟังก์ชัน แต่เห็นเพียงโพรโทไทป์เท่านั้น
คอมไพเลอร์เชื่อถือการประกาศ ส่วนตัวเชื่อมโยงจะเชื่อมการเรียกใช้เข้ากับการนำไปใช้งานจริงใน math_utils.c ในภายหลัง
/* main.c */
#include <stdio.h>
#include "math_utils.h"
int main(void) {
printf("%d\n", add(2, 3));
return 0;
}เครื่องหมายอัญประกาศเทียบกับวงเล็บแหลม
คำสั่ง #include มีอยู่สองรูปแบบ
#include <stdio.h> ใช้วงเล็บแหลมสำหรับไฟล์ส่วนหัวของระบบและไลบรารีมาตรฐาน คอมไพเลอร์จะค้นหาในเส้นทางรวมมาตรฐาน
#include "math_utils.h" ใช้เครื่องหมายอัญประกาศสำหรับไฟล์ส่วนหัวของคุณเอง โดยจะค้นหาในไดเรกทอรีปัจจุบันก่อน
#include <stdio.h> /* standard library */
#include "math_utils.h" /* your project */สิ่งที่ควรอยู่ในไฟล์ส่วนหัว
ใส่ การประกาศ ไว้ในไฟล์ส่วนหัว ไม่ใช่การนิยาม
เนื้อหาที่เหมาะสมสำหรับไฟล์ส่วนหัว ได้แก่ โพรโทไทป์ของฟังก์ชัน การประกาศ struct และ typedef มาโคร #define และการประกาศตัวแปร extern
หลีกเลี่ยงการใส่เนื้อหาฟังก์ชันหรือการนิยามตัวแปรไว้ที่นั่น เพราะอาจทำให้เกิดข้อผิดพลาดจากสัญลักษณ์ซ้ำ
/* shapes.h */
typedef struct {
double width;
double height;
} Rect;
double rect_area(Rect r);สิ่งที่ควรอยู่ในไฟล์ต้นฉบับ
ไฟล์ต้นฉบับเก็บการทำงานจริง ได้แก่ การนิยามฟังก์ชันและฟังก์ชันช่วยเหลือเฉพาะภายในไฟล์
ไฟล์นี้รวมไฟล์ส่วนหัวที่สอดคล้องกัน เพื่อให้คอมไพเลอร์ตรวจสอบว่ารูปแบบการประกาศตรงกัน วิธีนี้ช่วยตรวจจับความไม่ตรงกันได้ตั้งแต่เนิ่น ๆ แทนที่จะรอถึงเวลาเชื่อมโยง
/* shapes.c */
#include "shapes.h"
double rect_area(Rect r) {
return r.width * r.height;
}การประกาศเทียบกับการนิยาม
ความแตกต่างนี้เป็นแนวคิดสำคัญของ C แบบแยกส่วน
การประกาศ แจ้งชนิดข้อมูลและรูปแบบการประกาศของชื่อให้คอมไพเลอร์ทราบ เพื่อให้สามารถนำไปใช้ได้: int add(int, int);
การนิยาม สร้างองค์ประกอบจริง โดยจัดสรรพื้นที่จัดเก็บหรือจัดเตรียมเนื้อหาฟังก์ชัน ไฟล์ส่วนหัวใช้ประกาศ ส่วนไฟล์ต้นฉบับใช้นิยาม
int add(int a, int b); /* declaration */
int add(int a, int b) { /* definition */
return a + b;
}หลักการตั้งชื่อ
รูปแบบที่พบได้บ่อยคือจับคู่แต่ละมอดูลตามชื่อ เช่น logger.h กับ logger.c และ parser.h กับ parser.c
วิธีนี้ทำให้เห็นได้ชัดว่าการนำไปใช้งานจริงอยู่ที่ใด จัดกลุ่มฟังก์ชันที่เกี่ยวข้องไว้ในมอดูลเดียว เพื่อให้แต่ละไฟล์มีหน้าที่หลักที่ชัดเจนเพียงอย่างเดียว
/* logger.h */
void log_info(const char *msg);
void log_error(const char *msg);ภาพรวมการสร้างโปรแกรม
ไฟล์ .c แต่ละไฟล์จะถูกคอมไพล์แยกกันเป็นไฟล์อ็อบเจ็กต์ จากนั้นไฟล์อ็อบเจ็กต์ทั้งหมดจะถูกเชื่อมโยงเป็นโปรแกรมเดียว
ไฟล์ส่วนหัวจะไม่ถูกคอมไพล์โดยลำพัง แต่จะถูกแทรกเป็นข้อความลงในไฟล์ต้นฉบับที่รวมไฟล์เหล่านั้นไว้ เราจะสำรวจกระบวนการสร้างโปรแกรมทั้งหมดในบทเรียนภายหลัง
gcc -c main.c /* -> main.o */
gcc -c math_utils.c /* -> math_utils.o */
gcc main.o math_utils.o -o appตรวจสอบอย่างรวดเร็ว
ทดสอบความเข้าใจเกี่ยวกับบทบาทของไฟล์ส่วนหัวและไฟล์ต้นฉบับ
สรุปทบทวน
คุณได้เรียนรู้การแบ่งโครงการ C ออกเป็นไฟล์ส่วนหัว .h และไฟล์ต้นฉบับ .c
ไฟล์ส่วนหัวประกาศว่าสิ่งใดมีอยู่ ส่วนไฟล์ต้นฉบับนิยามว่าสิ่งนั้นทำงานอย่างไร ใช้เครื่องหมายอัญประกาศสำหรับไฟล์ส่วนหัวของคุณเอง และใช้วงเล็บแหลมสำหรับไฟล์ส่วนหัวมาตรฐาน
บทถัดไปเราจะป้องกันปัญหาที่เกิดจากการรวมไฟล์ส่วนหัวมากกว่าหนึ่งครั้ง
เรียนรู้ C ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 39
- บทเรียน
- 144
คำถามที่พบบ่อย
บทเรียน “ไฟล์ส่วนหัวและไฟล์ต้นฉบับ” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ไฟล์ส่วนหัวและไฟล์ต้นฉบับ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ไฟล์ส่วนหัวและไฟล์ต้นฉบับ”
แยกการประกาศออกจากโค้ด คุณปฏิบัติ C Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน C Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน
บทเรียน “ไฟล์ส่วนหัวและไฟล์ต้นฉบับ” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน C Academy นี้ได้ไหม
ได้ บทเรียน C Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ไฟล์ส่วนหัวและไฟล์ต้นฉบับ
- ตัวป้องกันการรวมไฟล์
- extern และการเชื่อมโยง
- คอมไพล์หลายไฟล์