يبدأ كل برنامج C في main. #include <stdio.h> يستدعي ملف header لتتمكن من استخدام printf للطباعة. الدالة هي كتلة ذات اسم يمكنك استدعاؤها؛ \n يبدأ سطرًا جديدًا. main تُرجع 0 تعني "النجاح".
#include <stdio.h>
void greet(void) {
printf("Hello, world!\n");
}
int main(void) {
greet();
printf("I am learning C.\n");
return 0;
}
كل برنامج C يعمل من main بعد تضمين ملفات header
1.2
المتغيرات، الأنواع والحسابات
C يحتاج نوعًا لكل متغير: int (عدد صحيح)، double (نقطة عائمة)، char (حرف واحد). printf يستخدم محدد تنسيق — %d، %f، %c — لكل قيمة. / بين عددين صحيحين هو قسمة صحيحة؛ % هو الباقي.
#include <stdio.h>
int main(void) {
int n = 17;
double pi = 3.14;
char grade = 'A';
printf("%d %.2f %c\n", n, pi, grade); // 17 3.14 A
printf("%d %d\n", 7 / 2, 7 % 2); // 3 1
return 0;
}
سلسلة التنسيق توجه الطباعة والقراءة أيضًا:
المحدد
النوع
مثال الإخراج
%d
int
17
%f
double (%.2f = 2 منازل عشرية)
3.14
%c
char
A
%s
نص
Mei
%zu
حجم (من sizeof / strlen)
3
%x
unsigned int، مطبوعة بالأساس 16
ff
scanf("%d", &n) يقرأ int عبر عنوانه (لاحظ &). صيغ الإدخال والإخراج ليست متطابقة: printf("%f", x) يطبع double، بينما scanf("%lf", &x) يقرأ double؛ يحتاج الإدخال %f إلى float *. تحقق من عدد العناصر التي تم تعيينها بنجاح. الشقيق sscanf يقوم بتفسير القيم من نص:
#include <stdio.h>
int main(void) {
char line[] = "Mei 88";
char name[20];
int score;
if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
printf("%s scored %d\n", name, score); // Mei scored 88
return 0;
}
1.3
التعليقات والأسلوب
التعليق هو ملاحظة للبشر؛ المترجم يتجاهله. استخدم // لسطر واحد و/* ... */ لكتلة. المسافات البادئة الجيدة والأسماء الواضحة تجعل الكود سهل القراءة.
#include <stdio.h>
int main(void) {
// a single-line comment
/* a block
comment */
int total = 3 + 4; // clear names help
printf("%d\n", total); // 7
return 0;
}
أخطاء شائعة
التصريحات والتعبيرات تنتهي بـ ;؛ الكتلة المركبة { ... } لا تحتاج فاصلة منقوطة إضافية. main يجب أن يُرجع int (return 0;).
printf تحتاج سلسلة تنسيق: %d لـ int، %f لـ double، و\n لسطر جديد.
تنسيق خاطئ مثل %d لـ double يسبب سلوكاً غير محدد؛ ليس مضموناً أن يطبع مجرد عشوائية فقط. طابق نوع الحجة.
تنفذ if كتلة عندما تكون الشرط صحيحًا. C ليس لديها نوع منطقي حقيقي افتراضيًا: 0 خطأ وأي قيمة غير صفرية صحيحة. اربط الخيارات مع else if وelse. قارن بـ ==، !=، <، >، <=، >=.
#include <stdio.h>
int main(void) {
int score = 72;
if (score >= 90) {
printf("A\n");
} else if (score >= 60) {
printf("Pass\n");
} else {
printf("Fail\n");
}
return 0;
}
if تختفر الفرع الصحيح؛ else الفرع الخطأ
2.2
مفتاح
الأمر switch يختار case بقيمة عدد صحيحة. كل case يحتاج إلى أمر break للقفز خارج — بدون هذا الأمر، "يسقط" C في الحالة التالية. يعمل default عندما لا يتطابق شيء.
#include <stdio.h>
int main(void) {
int day = 3;
switch (day) {
case 1: printf("Mon\n"); break;
case 2: printf("Tue\n"); break;
case 3: printf("Wed\n"); break;
default: printf("Other\n");
}
return 0;
}
أخطاء شائعة
if (x = 5) تُعين وتكون دائمًا صحيحة؛ استخدم == للمقارنة.
كل حالة switch تحتاج إلى break;، وإلا ستنتقل إلى الحالة التالية.
الحلقة تكرر كتلة من الكود. حلقة while تعمل طالما أن الشرط صحيح. حلقة for تجمع البداية، والاختبار، والزيادة (i++) في سطر واحد — الأفضل عندما تعرف عدد المرات التي تريد تكرارها.
#include <stdio.h>
int main(void) {
int i = 1;
while (i <= 3) {
printf("%d ", i);
i++;
}
printf("\n"); // 1 2 3
for (int j = 0; j < 5; j++) {
printf("%d ", j);
}
printf("\n"); // 0 1 2 3 4
return 0;
}
while يتحقق من شرط؛ for يعد بخطوة
3.2
التراكم
نمط شائع: ابدأ بمجمع عند 0، ثم أضف إليه داخل الحلقة. نفس الفكرة يُستخدم لعدّ العناصر أو إيجاد المجموع المتراكم.
#include <stdio.h>
int main(void) {
int total = 0;
for (int i = 1; i <= 5; i++) {
total += i; // 1 + 2 + 3 + 4 + 5
}
printf("%d\n", total); // 15
return 0;
}
3.3
الحلقات المتداخلة والأنماط
حلقة داخل حلقة أخرى هي حلقة متداخلة. تنتهي الحلقة الداخلية بالكامل لكل خطوة من الحلقة الخارجية — مثالية للصفائح والأنماط.
#include <stdio.h>
int main(void) {
for (int row = 0; row < 3; row++) {
for (int col = 0; col < 3; col++) {
printf("*");
}
printf("\n");
}
return 0;
}
أخطاء شائعة
for (i = 0; i < n; i++) يعمل n مرة؛ فاصلة منقوطة مباشرة بعد for (...) تُكوّن حلقة فارغة.
حلقة while إذا لم يصبح شرطها خاطئاً أبداً ستعمل إلى ما لا نهاية.
الدالة تأخذ معاملات (مدخلات) وتُرجع قيمة إرجاع. نوع الإرجاع يأتي أولاً (int، double، ...)؛ void يعني أنها لا تُرجع شيئاً.
#include <stdio.h>
int square(int x) { // x is a parameter
return x * x; // hand back a value
}
int main(void) {
int r = square(5);
printf("%d\n", r); // 25
return 0;
}
المعاملات دخول؛ قيمة الإرجاع خروج
4.2
النماذج الأولية والنطاق
C يقرأ من الأعلى إلى الأسفل، لذا يجب معرفة الدالة قبل استدعاءها. النموذج الأولي — سطر الرأس بالإضافة إلى ; — يعلن عنها مبكراً حتى تتمكن من وضع main في البداية. نطاق المتغير هو الكتلة التي يعيش فيها: هو محلي ويختفي عند انتهاء الكتلة.
#include <stdio.h>
int add(int a, int b); // prototype: declared before use
int main(void) {
printf("%d\n", add(3, 4)); // 7
return 0;
}
int add(int a, int b) { // definition comes later
int sum = a + b; // sum is local to add
return sum;
}
أخطاء شائعة
الدالة المستخدمة قبل تعريفها تحتاج إلى نموذج أعلى main.
يتم تمرير الحجج بالقيمة — التغييرات داخل الدالة لا تؤثر على المُدعي إلا إذا مررت مؤشراً.
المصفوفة تحتفظ بعدة قيم من نوع واحد. الفهرسة تبدأ من 0. C لا يخزن طول المصفوفة، لذا خدعة شائعة تحسب عدد العناصر: sizeof(a) / sizeof(a[0]).
#include <stdio.h>
int main(void) {
int scores[3] = {88, 71, 95};
printf("%d\n", scores[0]); // 88
scores[1] = 100;
printf("%d\n", scores[1]); // 100
int n = sizeof(scores) / sizeof(scores[0]);
printf("%d\n", n); // 3
return 0;
}
أماكن المصفوفة مُفهرسة من 0
5.2
خوارزميات المصفوفات
تتبع المصفوفة باستخدام حلقة for لإيجاد الحد الأقصى، أو المجموع، أو العدد. always loop from 0 up to n - 1.
#include <stdio.h>
int main(void) {
int a[] = {3, 9, 2, 7};
int n = sizeof(a) / sizeof(a[0]);
int max = a[0], total = 0;
for (int i = 0; i < n; i++) {
if (a[i] > max) max = a[i];
total += a[i];
}
printf("%d %d\n", max, total); // 9 21
return 0;
}
5.3
مصفوفات 2-A
مصفوفة 2-A هي شبكة من الصفوف والأعمدة: grid[row][col]. استخدم حلقتين متداخلتين لزيارة كل خلية.
#include <stdio.h>
int main(void) {
int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
printf("%d\n", grid[1][2]); // 6
for (int r = 0; r < 2; r++) {
for (int c = 0; c < 3; c++) {
printf("%d ", grid[r][c]);
}
}
printf("\n"); // 1 2 3 4 5 6
return 0;
}
أخطاء شائعة
C لا يتحقق من حدود المصفوفة: كتابة a[n] في مصفوفة بحجم n سلوك غير محدد.
الفهارس الصالحة تمتد من 0 إلى n - 1.
في معظم التعبيرات، يتحول مصفوفة إلى مؤشر على عنصرها الأول، لكن المصفوفة نفسها ليست مؤشراً. sizeof(a) يعطي الحجم الكلي بالبايت لمصفوفة فعلية؛ معامل المصفوفة يتم ضبطه كمؤشر، لذلك تحتاج الدالة إلى طول مزود بشكل منفصل.
المؤشر يحفظ عنوان متغير. &x يعطي عنوان x؛ *p يفك تشفير المؤشر — يقرأ أو يكتب القيمة المخزنة هناك. تمرير المؤشر يسمح للدالة بتغيير متغير المُدعي (التمرير بالمؤشر).
المؤشر يحفظ عنواناً؛ فك تشفيره يتبع السهم إلى القيمة
#include <stdio.h>
void addOne(int *p) { // p holds an address
*p = *p + 1; // change the value at that address
}
int main(void) {
int x = 10;
int *ptr = &x; // & takes the address of x
printf("%d\n", *ptr); // * reads the value: 10
addOne(&x);
printf("%d\n", x); // 11 — changed through the pointer
return 0;
}
الاستخدام الكلاسيكي هو دالة التبادل. تمرير القيم ينسخها فقط — يُفقد التبادل. تمرير المؤشرات يسمح للدالة بالوصول إلى متغيرات المُدعي:
#include <stdio.h>
void swap_values(int a, int b) { // copies: the caller sees nothing
int t = a; a = b; b = t;
}
void swap_pointers(int *a, int *b) { // addresses: the swap is real
int t = *a; *a = *b; *b = t;
}
int main(void) {
int x = 1, y = 2;
swap_values(x, y);
printf("%d %d\n", x, y); // 1 2 (unchanged!)
swap_pointers(&x, &y);
printf("%d %d\n", x, y); // 2 1 (swapped)
return 0;
}
اسم المصفوفة يعمل كمؤشر إلى عنصرها الأول، وحساب المؤشرات يقفز بعناصر كاملة:
#include <stdio.h>
int main(void) {
int a[] = {10, 20, 30};
int *p = a; // same as &a[0]
printf("%d\n", *p); // 10
printf("%d\n", *(p + 2)); // 30 — same as a[2]
return 0;
}
NULL هو المؤشر الذي لا يشير إلى شيء — تحقق منه قبل فك تشفيره.
أخطاء شائعة
&x هو عنوان x؛ *p هي القيمة المخزنة في p.
لا تستخدم *p على مؤشر غير مبدء أو NULL — causing crash or memory corruption.
لتغيير متغير المُدعي، مرر عنوانه واكتب عبر المؤشر.
سلسلة C هي مصفوفة من char. كل سلسلة تنتهي بمختتم null مخفي '\0'، والذي يحدد أين تتوقف. strlen (من <string.h>) يعدّ الأحرف حتى ذلك '\0'. اطبع السلسلة كاملة باستخدام %s وحرفاً واحداً باستخدام %c.
#include <stdio.h>
#include <string.h>
int main(void) {
char name[] = "Mei"; // 'M', 'e', 'i', '\0'
printf("%s\n", name); // Mei
printf("%zu\n", strlen(name)); // 3 (stops at '\0')
printf("%c\n", name[0]); // M
return 0;
}
سلسلة C هي مصفوفة أحرف تنتهي بمختتم null مخفي
يمكنك تتبع السلسلة عن طريق الدوران حتى تصل إلى '\0'.
#include <stdio.h>
int main(void) {
char word[] = "banana";
int count = 0;
for (int i = 0; word[i] != '\0'; i++) {
if (word[i] == 'a') count++;
}
printf("%d\n", count); // 3
return 0;
}
7.2
مكتبة string.h
#include <string.h> يوفر لك أدوات السطور اليومية:
الدالة
تقوم بـ
strlen(s)
الطول، دون احتساب المختتم
strcpy(dst, src)
نسخ — dst يجب أن تكون كبيرة بما يكفي
strcat(dst, src)
إضافة src في نهاية dst
strcmp(a, b)
مقارنة: 0 عند التساوي، وإلا سالب / موجب
#include <stdio.h>
#include <string.h>
int main(void) {
char full[40];
strcpy(full, "Mei"); // full is now "Mei"
strcat(full, " Chen"); // append -> "Mei Chen"
printf("%s (%zu)\n", full, strlen(full)); // Mei Chen (8)
printf("%d\n", strcmp("apple", "apple") == 0); // 1 (equal)
return 0;
}
strcmp تُرجع 0 للتساوي، لذا الاختبار هو strcmp(a, b) == 0 — لا تستخدم أبداً a == b.
مصفوفة الوجه يجب أن تحتوي على مساحة للنتيجة بالإضافة إلى المختتم.
أخطاء شائعة
سلسلة C تحتاج بايت إضافي واحد للمختتم \0: كلمة مكونة من 5 أحرف تحتاج char[6].
انسخ وقارن السلاسل باستخدام strcpy / strcmp، لا = / ==.
نسيان \0 يجعل printf("%s", ...) يتجاوز نهاية النص.
الـ struct يجمع قيمًا ذات صلة في نوع واحد. كل قيمة هي عضو. typedef يمنح الـ struct اسماً مختصراً بحيث يمكنك كتابة Dog بدلاً من struct Dog. استخدم . على قيمة struct، ولكن -> على مؤشر إلى struct.
#include <stdio.h>
typedef struct {
char name[20];
int age;
} Dog;
int main(void) {
Dog d = {"Rex", 3};
printf("%s is %d\n", d.name, d.age); // Rex is 3 (. on a value)
Dog *p = &d;
p->age = 4; // -> on a pointer
printf("%s is %d\n", d.name, d.age); // Rex is 4
return 0;
}
أخطاء شائعة
استخدم . على قيمة مجموعة و -> على مؤشر لمجموعة.
typedef يسمح لك بتجاهل كلمة struct عند الإعلان؛ بدونه تكتب struct Point p;.
malloc تخصص ذاكرة على الهيد (heap) وقت التشغيل وترجع مؤشراً إليها. realloc يعيد حجم تلك الكتلة؛ free يُعيدها. كل malloc يحتاج match with free، أو تحصل على تسرب للذاكرة. هذه توجد في <stdlib.h>.
المتغيرات المحلية تعيش في المكدس؛ ذاكرة malloc تعيش في الكومة حتى تقوم بإفراج عنها
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int n = 3;
int *a = malloc(n * sizeof(int)); // room for 3 ints
if (a == NULL) return EXIT_FAILURE;
for (int i = 0; i < n; i++) a[i] = i * 10;
int *grown = realloc(a, 4 * sizeof *a); // positive size
if (grown == NULL) {
free(a);
return EXIT_FAILURE;
}
a = grown;
a[3] = 30;
for (int i = 0; i < 4; i++) printf("%d ", a[i]);
printf("\n"); // 0 10 20 30
free(a); // hand the memory back
return 0;
}
calloc(n, size) تخصص مصفوفة مثل malloc AND يملؤها بالصفر.
أخطاء شائعة
كل malloc يحتاج إلى free مقابلة؛ نسيان الإفراج يسبب تسرب الذاكرة.
استخدام الذاكرة بعد free ("استخدام-بعد-إفراج") هو خطأ جسيم.
تحقق من أن malloc لم يعِد NULL قبل استخدام الذاكرة.
بالنسبة للأحجام الإيجابية، يعيد الفشل reallocNULL ويترك التخصيص القديم سليماً: تحقق من نتيجة مؤقتة قبل استبدال المؤشر الوحيد. النجاح يحفظ الأصغر بين أعداد البايت القديمة/الجديدة؛ الخلايا المضافة غير مُبدأة. هذا المثال يتجنب طلبات الحجم صفري وفوق حجم الأعداد الصحيحة. المتغيرات المحلية العادية غير الثابتة لها مدة تخزين تلقائية وعادةً ما يتم تنفيذها على كومة؛ C لا يشترط هذا الترتيب.
القائمة المرتبطة هي سلسلة من العقد. كل عقدة تحمل قيمة ومؤشر إلى العقدة next؛ العقدة الأخيرة تشير إلى NULL. على عكس المصفوفة، فإنها تنمو بإضافة عقدة واحدة في كل مرة مع malloc. يجب always free كل عقدة عند الانتهاء.
قائمة مترابطة: كل عقدة تحتفظ بقيمة ومؤشر إلى التالية، وتنتهي بـ NULL
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int value;
struct Node *next;
} Node;
int main(void) {
Node *head = NULL;
for (int v = 10; v <= 30; v += 10) { // prepend 10, 20, 30
Node *n = malloc(sizeof(Node));
n->value = v;
n->next = head;
head = n;
}
for (Node *p = head; p != NULL; p = p->next) {
printf("%d ", p->value); // 30 20 10
}
printf("\n");
while (head != NULL) { // free the whole list
Node *t = head;
head = head->next;
free(t);
}
return 0;
}
10.2
المكدسات والطوابير
المكدس LIFO (آخر دخول، أول خروج): دفع وإخراج من نفس النهاية. الطابور FIFO (أول دخول، أول خروج): إضافة من الخلف، إزالة من الأمام. كلاهما سهل البناء على مصفوفة باستخدام متغيرات الفهرس.
#include <stdio.h>
int main(void) {
int stack[10];
int top = 0; // next free slot
stack[top++] = 1; // push
stack[top++] = 2;
stack[top++] = 3;
while (top > 0) {
printf("%d ", stack[--top]); // pop: 3 2 1
}
printf("\n");
return 0;
}
#include <stdio.h>
int main(void) {
int queue[10];
int front = 0, back = 0;
queue[back++] = 1; // enqueue
queue[back++] = 2;
queue[back++] = 3;
while (front < back) {
printf("%d ", queue[front++]); // dequeue: 1 2 3
}
printf("\n");
return 0;
}
أخطاء شائعة
في القائمة المرتبطة، لا تفقد أبداً المؤشر head، وإلا تصبح القائمة بأكملها غير قابلة للوصول.
قم بإفراج عن كل عقدة عندما تنتهي، مع تجول القائمة قبل فصل الروابط.
البحث الخطي يفحص كل عنصر بالتتابع — يعمل على أي مصفوفة. البحث ثنائي التفرع أسرع بكثير لكنه يتطلب مصفوفة مرتبة: يفحص المنتوى ويستبعد النصف في كل خطوة. كلاهما يعيد الفهرس، أو -1 إذا كان مفقودًا.
#include <stdio.h>
int linear(int a[], int n, int target) {
for (int i = 0; i < n; i++)
if (a[i] == target) return i;
return -1;
}
int binary(int a[], int n, int target) {
int lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (a[mid] == target) return mid;
else if (a[mid] < target) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
int main(void) {
int a[] = {2, 5, 8, 12, 16, 23};
int n = sizeof(a) / sizeof(a[0]);
printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
return 0; // 3 3 -1
}
fopen يعيد مؤشر ملف؛ نص الوضع يقول ما يجب فعله — "w" كتابة، "r" قراءة، "a" إرفاق. اكتب باستخدام fprintf، اقرأ باستخدام fscanf، Always fclose عند الانتهاء.
#include <stdio.h>
int main(void) {
FILE *out = fopen("scores.txt", "w"); // open for writing
if (out == NULL) {
perror("scores.txt");
return 1;
}
fprintf(out, "Alice 80\nBob 95\n");
fclose(out);
FILE *in = fopen("scores.txt", "r"); // open for reading
if (in == NULL) {
perror("scores.txt");
return 1;
}
char name[20];
int score;
while (fscanf(in, "%19s %d", name, &score) == 2) { // %19s leaves room for '\0'
printf("%s -> %d\n", name, score);
}
fclose(in);
return 0;
}
fopen → قراءة/كتابة → fclose
12.2
معالجة الأخطاء مع رموز الإرجاع
C has no built-in exceptions. A function may report its outcome through a return code; check that function’s rules before using the result. The example below uses 0 for success and -1 for failure. fopen instead returns a stream pointer, or NULL when it fails.
#include <stdio.h>
// returns 0 on success, -1 if the divisor is 0
int safe_divide(int a, int b, int *result) {
if (b == 0) return -1; // error code
*result = a / b;
return 0; // success
}
int main(void) {
int r;
if (safe_divide(10, 2, &r) == 0)
printf("10 / 2 = %d\n", r); // 10 / 2 = 5
if (safe_divide(10, 0, &r) != 0)
printf("cannot divide by zero\n"); // error reported
return 0;
}
أخطاء شائعة
تحقق من أن fopen لم يُرجع NULL قبل القراءة أو الكتابة.
Always fclose الملف عندما تنتهي.
أعد رمزًا غير صفري من main للإشارة إلى خطأ للمتصل.
البت هو 0 أو 1 واحد؛ تُخزن الأرقام بصيغة ثنائية. عوامل البت تعمل على البتات مباشرة: & AND، | OR، ^ XOR، << إزاحة لليسار (×2 في كل خطوة)، >> إزاحة لليمين (÷2).
#include <stdio.h>
int main(void) {
int a = 12; // 1100
int b = 10; // 1010
printf("%d\n", a & b); // 8 AND -> 1000
printf("%d\n", a | b); // 14 OR -> 1110
printf("%d\n", a ^ b); // 6 XOR -> 0110
printf("%d\n", a << 1); // 24 left shift
printf("%d\n", a >> 1); // 6 right shift
return 0;
}
السادس عشرية (الأساس 16) تكتب الثنائيات بكثافة: رقم سادس عشري واحد يساوي أربع بتات بالضبط. اكتب الثوابت السادسة عشرية باستخدام 0x؛ اطبع باستخدام %x:
#include <stdio.h>
int main(void) {
printf("%d\n", 0xFF); // 255 (0x marks a hex literal)
printf("%x\n", 255); // ff
printf("%x\n", 12); // c
return 0;
}
عملات البت تعمل على بتات الأعداد الصحيحة
13.2
ترميز طول التسلسل
ترميز طول التسلسل (RLE) هو طريقة ضغط بسيطة: استبدل كل تسلسل من الأحرف المكررة بعدد والحرف. إنه غير قابل للفقدان — يمكن استعادة الأصل بالكامل.
#include <stdio.h>
#include <string.h>
int main(void) {
char *s = "aaabbc";
int n = strlen(s);
for (int i = 0; i < n; ) {
char c = s[i];
int run = 0;
while (i < n && s[i] == c) { run++; i++; }
printf("%d%c", run, c); // 3a2b1c
}
printf("\n");
return 0;
}
أخطاء شائعة
& هو AND للبتات و&& هو AND المنطقي — لا تخلط بينهما.
المعالج المسبق يعمل قبل الترجمة. #define يصنع ماكرو — استبدال نص عادي في كل مكان. const يصنع ثابتًا لا يمكن تغييره. static داخل دالة يحافظ على قيمة متغير بين الاستدعاءات. enum (تعداد) يسمي مجموعة من الأعداد الصحيحة تبدأ من 0.
#include <stdio.h>
#define MAX 100 // macro: text replaced before compiling
enum Color { RED, GREEN, BLUE }; // named integers 0, 1, 2
int next_id(void) {
static int count = 0; // keeps its value between calls
count++;
return count;
}
int main(void) {
const double PI = 3.14; // cannot be changed
printf("%d %.2f\n", MAX, PI); // 100 3.14
printf("%d %d %d\n", RED, GREEN, BLUE); // 0 1 2
int a = next_id();
int b = next_id();
printf("%d %d\n", a, b); // 1 2
return 0;
}
البرامج الأكبر تتوزع على ملفات متعددة: Declarations توضع في ملف رأس (mine.h)، يتم تضمينه باستخدام #include "mine.h" — علامات التنصيص تعني ملفك الخاص، بينما < > تعني المكتبة القياسية. حارس التضمين (#ifndef MINE_H / #define MINE_H / #endif) يمنع تضمين الرأس مرتين.
أخطاء شائعة
#define يقوم باستبدال نص عادي دون فحص أنواع; غلف أجسام الماكرو وحججها بين أقواس.
لا يمكن تغيير قيمة const بعد تعيينها.
متغير محلي static يحتفظ بقيمته بين استدعاءات الدالة.
#define, const, enum, و static يحافظون على وضوح الكود