שגיאות נפוצות ב-C: טעויות של מתחילים ואיך לתקן אותן

כל מתכנת C פוגש את אותה רשימה קצרה של טעויות, בדרך כלל בשבוע הראשון ולפעמים עשור אחר כך. מה שהופך אותן לראויות לקטלוג הוא שרובן מייצרות הודעות שגיאה שלא מתארות אותן, או, גרוע מזה, שום הודעה בכלל.

כל ערך בהמשך הוא תסמין, הסיבה שמאחוריו, והתיקון.

נקודה ופסיק חסרה ושרשרת השגיאות

תסמין: חומה של שגיאות, כולן מדווחות על שורות שנראות תקינות.

program.c:6:5: error: expected ';' before 'printf'
program.c:7:5: error: expected declaration specifiers before 'return'

סיבה: C מסיימת פקודות ב-;. השמיטו אחת, והקומפיילר מדביק את השורה הבאה לשורה הנוכחית, ואז מדווח על בלבול בנקודה שבה הטקסט המשולב מפסיק להיות הגיוני, בדרך כלל בשורה הבאה.

int main(void) {
    int x = 5      /* missing semicolon */
    printf("%d\n", x);
    return 0;
}

תיקון: כשמופיעה ערימה של שגיאות, תקנו רק את הראשונה וקמפלו מחדש. כל מה שאחריה עשוי להיות תוצאת לוואי. ותמיד בדקו את השורה שלפני זו שהקומפיילר מציין.

אותה שרשרת נוצרת מסוגר מסולסל שלא נסגר או מהערת /* שלא הסתיימה, ואז השגיאות יכולות לנחות עשרות שורות משם.

#include <stdio.h>

int main(void) {
    int x = 5;
    printf("%d\n", x);
    return 0;
}

הערה נוספת: אין נקודה ופסיק אחרי כותרת של if, for או while, או אחרי הסוגר המסולסל הסוגר של הגדרת פונקציה. if (x > 0); מתקמפל בלי בעיה ולא עושה כלום: ה-; הוא כל הגוף.

השמה במקום השוואה

תסמין: תנאי שתמיד אמת, או משתנה שמשתנה באופן מסתורי.

int x = 5;
if (x = 10) {              /* assigns 10, then tests 10 -> true */
    printf("x is ten\n");  /* always prints; x is now 10 */
}

סיבה: = משים, == משווה. הערך של ההשמה הוא הערך שהושם, כך ש-if (x = 10) בודק את 10, שהוא שונה מאפס, ולכן אמת. הקומפיילר מקבל את זה כי לפעמים זה באמת מה שאנשים מתכוונים אליו.

תיקון: השתמשו ב-== בכל תנאי, והפעילו את -Wall כדי שהקומפיילר יזהיר:

warning: suggest parentheses around assignment used as truth value

#include <stdio.h>

int main(void) {
    int x = 5;

    if (x == 10) {
        printf("x is ten\n");
    } else {
        printf("x is %d, not ten\n", x);
    }
    return 0;
}

אם אתם באמת מתכוונים להשמה בתוך תנאי, מה שנפוץ עם while ((c = getchar()) != EOF), הסוגריים הנוספים אומרים את זה ומשתיקים את האזהרה.

הצהרה מרומזת על פונקציה

תסמין:

warning: implicit declaration of function 'printf'
warning: implicit declaration of function 'malloc'

...ולפעמים אחריו תוצאות מוזרות בזמן ריצה או שגיאת קישור.

סיבה: הקומפיילר נתקל בקריאה לפונקציה שאין לו הצהרה עליה. בדיאלקטים שלפני C99 הוא הניח שהפונקציה מחזירה int והמשיך הלאה; במערכות 64 ביט ההנחה הזו חותכת מצביע מוחזר ל-32 ביט, וכך <stdlib.h> חסר הופך את malloc לקריסה.

תיקון: כללו את קובץ הכותרת הנכון.

עבור הפונקציות שלכם, אותה אזהרה פירושה שקראתם לאחת לפני שהגדרתם אותה. שימו אב-טיפוס מעל main:

#include <stdio.h>

int triple(int n);      /* prototype: declared before use */

int main(void) {
    printf("%d\n", triple(7));
    return 0;
}

int triple(int n) {     /* definition, after main */
    return n * 3;
}

scanf בלי &

תסמין: התוכנית קורסת בקלט, או לא קוראת כלום ומשאירה את המשתנה ללא שינוי.

int age;
scanf("%d", age);     /* missing & : passes the value, not the address */

סיבה: scanf כותבת לתוך המשתנה שלכם, ולכן היא צריכה את הכתובת שלו. העברת age מוסרת את הזבל שהיה בו, ו-scanf מתייחסת לזה כמקום לכתוב אליו, וזה בדרך כלל segfault.

תיקון: & לפני המשתנה, לכל טיפוס חוץ ממערך, שהוא כבר כתובת:

#include <stdio.h>

int main(void) {
    int    age = 0;
    double height = 0.0;
    char   name[50] = "";

    /* Reading from a string here so the example runs without input */
    sscanf("30 1.82 Alex", "%d %lf %49s", &age, &height, name);
    /*                                    ^    ^        ^
       & for int, & for double, no & for the array                */

    printf("%s is %d and %.2f m tall\n", name, age, height);
    return 0;
}

שתי מלכודות סמוכות מאותה משפחה: השתמשו ב-%lf עבור double ב-scanf (%f שם פירושו float, וכתיבה של בתים בגודל float לתוך double משאירה אותו שגוי), ותמיד הגבילו %s ברוחב, %49s עבור חוצץ של 50 בתים, אחרת מילה ארוכה גולשת ממנו.

עוד יותר טוב: קראו שורה שלמה עם fgets ונתחו אותה, מה שלא יכול לגלוש ולא משאיר קלט תועה בחוצץ. עוד על שניהם ב-scanf.

השוואת מחרוזות עם ==

תסמין: שתי מחרוזות שברור שהן זהות משוות כשונות.

char a[] = "hello";
char b[] = "hello";

if (a == b) {              /* comparing two addresses: false */
    printf("same\n");
}

סיבה: מחרוזת C אינה ערך, היא מצביע לתו הראשון. == משווה את המצביעים. שני מערכים שמחזיקים טקסט זהה נמצאים בכתובות שונות, ולכן הבדיקה נותנת שקר. (באופן מבלבל, השוואה של שתי מחרוזות מילוליות זהות נותנת לפעמים אמת, כי הקומפיילר עשוי לאחסן עותק אחד, וזה הופך את הבאג לסירוגי.)

תיקון: strcmp, וזכרו שהיא מחזירה 0 כשהן שוות:

#include <stdio.h>
#include <string.h>

int main(void) {
    char a[] = "hello";
    char b[] = "hello";
    char c[] = "world";

    printf("a == b (pointers): %s\n", (a == b) ? "true" : "false");
    printf("strcmp(a, b) == 0: %s\n", (strcmp(a, b) == 0) ? "true" : "false");
    printf("strcmp(a, c) == 0: %s\n", (strcmp(a, c) == 0) ? "true" : "false");

    if (strcmp(a, b) == 0) {
        printf("The strings match\n");
    }
    return 0;
}

הקריאה ההפוכה מפילה אנשים גם כן: if (strcmp(a, b)) הוא אמת כשהמחרוזות שונות, כי תוצאה שונה מאפס פירושה "לא שוות". תמיד כתבו את ה-== 0 במפורש.

חילוק שלמים

תסמין: ממוצע של 0, אחוז שתמיד 0 או 100, יחס שאיבד את השבר שלו.

int correct = 7, total = 10;
double score = correct / total;      /* 0.0, not 0.7 */

סיבה: שני האופרנדים הם int, ולכן C מבצעת חילוק שלמים וחותכת לפני שהתוצאה מושמת ל-double. 7 / 10 הוא 0; המרת 0 ל-double היא 0.0.

תיקון: הפכו אופרנד אחד לנקודה צפה לפני החילוק:

#include <stdio.h>

int main(void) {
    int correct = 7, total = 10;

    printf("correct / total            = %.4f\n", (double)(correct / total));
    printf("(double)correct / total    = %.4f\n", (double)correct / total);
    printf("correct / (double)total    = %.4f\n", correct / (double)total);
    printf("correct * 100.0 / total    = %.1f%%\n", correct * 100.0 / total);
    return 0;
}

המרת אופרנד אחד מקדמת את השני אוטומטית. המרת התוצאה מאוחרת מדי: החיתוך כבר קרה. ראו המרת טיפוסים.

אותה מלכודת מסתתרת בביטויים כמו (a + b) / 2 לחישוב נקודת אמצע וב-1 / 2 * x, שהוא תמיד 0 בלי קשר ל-x.

return חסר או שגוי

תסמין: פונקציה מחזירה מספר שגוי שנראה סביר, שונה בכל הרצה או בכל בנייה.

int add(int a, int b) {
    int sum = a + b;
    /* no return statement */
}

סיבה: הגעה לסוף של פונקציה שאינה void בלי להחזיר ערך נותנת ערך לא מוגדר, בפועל מה שבמקרה היה ברגיסטר ההחזרה. זו התנהגות לא מוגדרת אם מי שקרא לפונקציה משתמש בו.

הצורה הערמומית יותר מחזירה ערך בחלק מהמסלולים ולא באחרים:

int classify(int n) {
    if (n > 0) return 1;
    if (n < 0) return -1;
    /* n == 0 falls off the end */
}

תיקון: החזירו ערך בכל מסלול, וקמפלו עם -Wall: ההודעה "control reaches end of non-void function" של GCC תופסת את שתי הגרסאות.

#include <stdio.h>

int classify(int n) {
    if (n > 0) {
        return 1;
    }
    if (n < 0) {
        return -1;
    }
    return 0;          /* the path that was missing */
}

int main(void) {
    printf("%d %d %d\n", classify(5), classify(-5), classify(0));
    return 0;
}

משתנים לא מאותחלים

תסמין: פלט זבל, או תוצאות שמשתנות בין הרצות ובין רמות אופטימיזציה.

int total;                       /* contains whatever was on the stack */
for (int i = 1; i <= 5; i++) {
    total += i;                  /* adding to garbage */
}
printf("%d\n", total);           /* some enormous number */

סיבה: משתנים מקומיים לא מאופסים. משתנה גלובלי או static מקבל אפס אוטומטית; משתנה מקומי מתחיל עם הבתים שכבר היו בכתובת הזו במחסנית.

תיקון: אתחלו במקום ההצהרה. זה לא עולה כלום ומעלים את כל סוג הבאגים הזה:

#include <stdio.h>

int main(void) {
    int total = 0;              /* initialized */
    int values[5] = {0};        /* every element zeroed */
    char name[32] = "";         /* empty string, not garbage */

    for (int i = 1; i <= 5; i++) {
        total += i;
        values[i - 1] = i * i;
    }

    printf("total = %d\n", total);
    printf("values[4] = %d\n", values[4]);
    printf("name = '%s' (length %zu)\n", name, sizeof name);
    return 0;
}

-Wall -Wextra מזהיר על רבים מאלה ("may be used uninitialized"), ו--fsanitize=memory או valgrind תופסים את השאר. המקרה הזה מגעיל במיוחד, כי מצביע לא מאותחל מוביל ישר ל-segmentation fault.

טעות של אחד

תסמין: הפריט האחרון מפוספס, או שנוגעים באיבר אחד יותר מדי והתוכנית מתנהגת לא כשורה מאוחר יותר.

int arr[5];
for (int i = 0; i <= 5; i++) {   /* touches arr[5], which does not exist */
    arr[i] = i;
}

סיבה: למערך של n איברים יש אינדקסים 0 עד n - 1. <= מריץ סיבוב נוסף.

תיקון: התבנית i < n, וחשבו את n מהמערך במקום לכתוב את המספר פעמיים:

#include <stdio.h>
#include <string.h>

int main(void) {
    int arr[5];
    size_t n = sizeof arr / sizeof arr[0];

    for (size_t i = 0; i < n; i++) {
        arr[i] = (int)i * 10;
    }
    for (size_t i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    /* Strings need one extra byte for the terminating '\0' */
    char word[6];                  /* 5 letters + terminator */
    strcpy(word, "hello");
    printf("'%s' uses %zu of %zu bytes\n", word, strlen(word) + 1, sizeof word);
    return 0;
}

הגרסה של המחרוזות, לשכוח מקום בשביל '\0', היא אותה שגיאה בתחפושת אחרת, ו-char word[5] שמכיל את "hello" הוא גלישת חוצץ.

שתיים קטנות יותר שכדאי להכיר

נקודה ופסיק אחרי כותרת של לולאה. for (int i = 0; i < 10; i++); ואחריו בלוק בסוגריים מסולסלים מריץ את הלולאה עשר פעמים בלי לעשות כלום, ואז מריץ את הבלוק פעם אחת. זה מתקמפל בלי שום הערה.

sizeof על מצביע. בתוך פונקציה, פרמטר מסוג מערך הוא מצביע, כך ש-sizeof(arr) הוא הגודל של המצביע (8 בתים), לא של המערך. העבירו את האורך כארגומנט נפרד:

#include <stdio.h>

void report(int arr[], size_t n) {
    printf("sizeof(arr) inside the function: %zu\n", sizeof arr);
    printf("actual element count passed in:  %zu\n", n);
}

int main(void) {
    int data[10] = {0};
    printf("sizeof(data) in main: %zu bytes\n", sizeof data);
    report(data, sizeof data / sizeof data[0]);
    return 0;
}

ההרגל שמונע את רוב זה

קמפלו עם אזהרות מופעלות, כבר מהתוכנית הראשונה:

gcc -Wall -Wextra -g program.c -o program

-Wall -Wextra תופס את ההשמה בתוך תנאי, את ה-return החסר, את הקריאה של ערך לא מאותחל, את המשתנה שלא בשימוש, ואת מציין ה-printf שלא מתאים לארגומנט שלו. הוספת -fsanitize=address,undefined בזמן הפיתוח תופסת כמעט את כל השאר ברגע שהם קורים.

התייחסו לכל אזהרה כאל שגיאה שעוד לא נתקלתם בה. תוכנית C שמתקמפלת בלי אזהרות אינה בהכרח נכונה, אבל כמעט כל תוכנית C שקורסת הזהירה על משהו קודם.