כל תוכנית C מתחילה בmain. #include <stdio.h> כולל קובץ ראש כדי שתוכל להשתמש ב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 לאחר כלולת קבצי ראש
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 רץ בלוק כאשר תנאי הוא נכון. תנאי נבדק כמספר: 0 הוא שקר וכל ערך שאינו אפס הוא נכון. (C99's <stdbool.h> מוסיף סוג בוליאני, bool עם true וfalse, אך אלו עדיין הן 1 ו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 על ידי ערך שלם. השתמש בbreak לקפוץ החוצה כאשר מקרה צריך להסתיים. ללא העברת שליטה, הביצוע ייפול למקרה הבא; זה יכול להיות מכוון. 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 קורא מלמעלה למטה, ולכן פונקציה חייבת להיות מוגדרת לפני השימוש בה. פרוטוטיפ — שורת הכותרת plus ; — מכריז עליה מוקדם כדי שתוכל לשמור על 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.
ארגומנטים עוברים בערך — שינויים בתוך פונקציה אינם משפיעים על הקורא אלא אם כן עוברת נקודת היפנית (pointer).
מעריך מחזיק מספר ערכים מאותו סוג. אינדקס מתחיל ב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 כדי למצוא מקסימום, סכום או ספירה. תמיד לולאה מהערך 0 ועד הערך 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
מערך בעל ממד 2 הוא טבלה של שורות ועמודות: 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 היא התנהגות לא מוגדרת (undefined behaviour).
אינדקסים תקפים רצים מהערך 0 עד הערך n - 1.
ברוב הביטויים ממשק (array) הופך למצביע לאלמנט הראשון שלו, אך הממשק עצמו אינו מצביע. sizeof(a) מחזיר את גודל הבייטים כולו עבור ממשק בפועל; פרמטר ממשק מותאם למצביע, ולכן הפונקציה זקוקה לאורך מסופק בנפרד.
נקודת היפנית אחסנת כתובת של משתנה. &x נותן את הכתובת של x; *p מבצע פירוק (dereference) לנקודת ההיפנית — הוא קורא או כותב את הערך האחסן שם. העברת נקודת היפנית מאפשרת לפונקציה לשנות את המשתנה של הקורא (pass-by-pointer).
מצביע מאחסן כתובת; גישה דרכו עוקבת אחרי החץ לערך
#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 — זה יגרם לקריסה או להפרעת זיכרון.
כדי לשנות משתנה של קורא, העבר את הכתובת שלו וכתוב דרך המצביע.
מחרוזת C היא מערך של char. כל מחרוזת מסתיימת במסוף נול נסתר '\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 היא מערך char הנסתיים במסוף נול נסתר
ניתן לעבור על מחרוזת באמצעות לולאה עד שתגיע ל-'\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 נותן למבנה שם קצר כך שתוכל לכתוב Dog במקום struct Dog. השתמש ב. על ערך מבנה, אך ב-> על מצביע למבנה.
#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 מקצה זיכרון על הגוש בזמן הרצה וחוזר עליו עם מצביע. realloc משנה את גודל חסימה זו; free מחזירה אותו בחזרה. כל malloc זקוק ל-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) גורמת לדליפת זיכרון.
שימוש בזיכרון לאחר free ("שימוש-אחרי-שחרור") הוא באג קשה.
בדוק שהmalloc לא החזיר NULL לפני שימוש בזיכרון.
עבור גדלים חיוביים, כישלון realloc מחזיר NULL ומשאיר את ההקצאה הישנה intact: בדוק תוצאה זמנית לפני החלפת המצביע היחיד שלך. הצלחה שומרת על הקטן מבין גודלי הבייטים הישנים/חדשים; תאים נוספים הם לא מוקדמים. דוגמה זו נמנעת מבקשות בגודל אפס ומעבר גודל. מקומיות רגילות לא-סטטיות הן בעלות אופק אחסון אוטומטי ומוגדרות בדרך כלל על גבי סטק; C אינה דורשת סידור זה.
רשימה מקשרת היא שרשרת של צמתים. כל צומח מכיל ערך ומצביע לצומח הnext; האחרון מצביע לNULL. בניגוד למערכת, היא גדלה בצומח אחד בכל פעם עם malloc. תמיד 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, אלא כל הרשימה תהייה לא נגישה.
שחרר כל נקודה כשסיימת, תוך כדי העברה על הרשימה לפני ניתוק הקישורים.
בדוק רשימה ריקה (ראש NULL) לפני ביצוע הפעלת הוצאה.
חיפוש ליניארי בודק כל אלמנט בתורו — זה עובד בכל מערך. חיפוש בנארי מהיר משמעותית אך דורש מערך ממוין: הוא בודק את האמצע ומפסל חצי בכל צעד. שניהם מחזירים את האינדקס, או -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
}
חיפוש ליניארי סורק הכל; בנארי חוצה טווח ממוין
11.2
מיון
מיון בועות מבצע השוואות חוזרות בין שכנים ומחליף כל זוג שאינו במצב מסודר. לאחר כל מעבר, הערך הגדול ביותר "עולה" לקצה.
#include <stdio.h>
int main(void) {
int a[] = {5, 2, 9, 1, 7};
int n = sizeof(a) / sizeof(a[0]);
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
}
}
}
for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n"); // 1 2 5 7 9
return 0;
}
11.3
רקורסיה
רקורסיה היא פונקציה הקוראת לעצמה. היא דורשת מקרה בסיסי להפסקה, וקריאה רקורסיבית שמקרב אותה אליו. ללא מקרה בסיסי, היא לעולם לא תסתיים.
#include <stdio.h>
int factorial(int n) {
if (n <= 1) return 1; // base case
return n * factorial(n - 1); // recursive call
}
int main(void) {
printf("%d\n", factorial(5)); // 120
return 0;
}
שגיאות נפוצות
חיפוש בנארי דורש מערך ממוין; רקורסיה דורשת מקרה בסיסי.
לכל קריאה רקורסיבית יש להתקרב יותר למקרה הבסיסי, אלא תתרחש התפרצות ערימה.
מיון בועות ומיון הכנסה הם O(n²) — טוב ללמידה, איטי בקנה מידה גדול.
fopen מחזירה מצביע לקובץ; מחרוזת המצב אומרת מה לעשות — "w" כתיבה, "r" קריאה, "a" הצרפה. כתוב עם fprintf, קרא עם fscanf, ובכל פעם סיים עם 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 אין חריגות מובנות. פונקציה יכולה לדווח על תוצאותיה דרך קוד השבה; בדוק את כללי הפונקציה לפני השימוש בתוצאה. הדוגמה למטה משתמשת ב-0 להצלחה וב--1 לכישלון. במקום זאת, fopen מחזיר מצביע לשטף (stream pointer), או NULL כאשר כושל.
#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 לפני הקריאה או הכתיבה.
ביט הוא 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) כותבת בינארי בצורה דחוסה: דיgit אחד במצומצת הוא בדיוק ארבעה ביטים. כתוב ליטרלים מצומצמים עם 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 לוגי — אל תבלבנו ביניהם.
הזזה שמאלה << 1 מכפילה בערך; הזזה ימינה >> 1 מחלקת בערך למחצה.
ביט n יש לו ערך 1 << n (C אין לה תפעול ** חזקה); בדוק ביט עם (x >> n) & 1.
ה-preprocessor פועל לפני ההרכבה. #define יוצר מקרו — החלפת טקסט פשוטה בכל מקום. const יוצר קבועה שלא ניתן לשנות. static בתוך פונקציה שומר על ערך משתנה בין קריאות. ערך enum (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;
}
תוכניות גדולות מחולקות בין קבצים: הכרזות הולכות בקובץ כותרת (mine.h), שנכלל עם #include "mine.h" — סימני ציטוט מתכוונים לקובץ שלך, < > מתכוון לספריית הסטנדרט. מגן כליל (#ifndef MINE_H / #define MINE_H / #endif) מונע כתיבת כותרת פעמיים.
שגיאות נפוצות
#define מבצע החלפת טקסט פשוטה ללא בדיקת סוגים; עטוף גופי מקרו וארגומנטים בסוגריים.
ערך const לא ניתן לשינוי לאחר שהוגדר.
משתנה מקומי static שומר על ערכו בין קריאות לפונקציה.