מחרוזות ב-C: מערכי char, התו המסיים ודוגמאות

רוב השפות נותנות לכם טיפוס string שיודע מה האורך שלו. C לא. ב-C מחרוזת היא פשוט מערך של char עם כלל אחד מוצמד: אחרי הטקסט בא בית עם הערך אפס, שנכתב '\0' ונקרא התו המסיים (null terminator). כל השאר לגבי מחרוזות ב-C נובע מהמוסכמה האחת הזו.

מחרוזת היא מערך char ועוד '\0'

מצהירים על מחרוזת על ידי אתחול מערך של char מליטרל:

#include <stdio.h>

int main(void) {
    char name[] = "Ada";

    printf("%s\n", name);
    printf("%c %c %c\n", name[0], name[1], name[2]);
    printf("last byte is %d\n", name[3]);
    return 0;
}

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

name:  +-----+-----+-----+------+
       | 'A' | 'd' | 'a' | '\0' |
       +-----+-----+-----+------+
index:    0     1     2     3

sizeof(name) הוא 4. הקומפיילר ספר את התווים, הוסיף אחד בשביל התו המסיים, וקבע את גודל המערך בשבילכם. הבית הנוסף הזה הוא הסיבה ש-char name[3] = "Ada"; הוא באג שמחכה לקרות: הטקסט נכנס, אבל התו המסיים לא, כך ששום דבר בהמשך לא יכול לדעת איפה המחרוזת נגמרת.

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

char name[32] = "Ada";   /* 3 תווים, תו מסיים, ו-28 בתים פנויים */

הבתים שלא בשימוש מתמלאים באפסים על ידי המאתחל, וזה לא מזיק.

למה התו המסיים חשוב

אף פונקציה ב-C לא מקבלת אורך. printf("%s", s) מקבלת כתובת אחת והולכת קדימה ומדפיסה בתים עד שהיא פוגשת '\0'. לכן מערך של char בלי תו מסיים אינו מחרוזת, והתייחסות אליו כמחרוזת קוראת את כל הזיכרון שבמקרה בא אחריו.

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

int main(void) {
    char good[4] = {'A', 'd', 'a', '\0'};
    char letters[3] = {'A', 'd', 'a'};   /* אין תו מסיים: זו לא מחרוזת */

    printf("good:   %s (length %zu)\n", good, strlen(good));
    printf("sizeof letters = %zu\n", sizeof letters);
    /* printf("%s", letters) הייתה קוראת מעבר לסוף, אל תעשו את זה. */
    return 0;
}

הכלל לשנן: sizeof נותן לכם את האחסון, strlen נותן לכם את הטקסט. עבור char buf[32] = "Ada", sizeof buf הוא 32 ו-strlen(buf) הוא 3. הם עונים על שאלות שונות, והבלבול ביניהם הוא אחד הבאגים הנפוצים ביותר ב-C.

ליטרלים של מחרוזות מול מערכי char

שתי השורות האלה נראות דומות ומתנהגות אחרת לגמרי:

char  a[] = "hello";   /* מערך ששייך לכם, מאותחל מהליטרל */
char *p   = "hello";   /* מצביע שמכוון לליטרל עצמו */

a הוא מערך של 6 בתים שמחזיק עותק פרטי של הטקסט. אפשר לשנות אותו. p מצביע לתוך נתוני המחרוזות לקריאה בלבד של התוכנית: הליטרל משותף, וכתיבה דרך p היא undefined behavior שבדרך כלל קורסת בזמן ריצה ולא בזמן קומפילציה.

#include <stdio.h>

int main(void) {
    char a[] = "hello";
    const char *p = "hello";

    a[0] = 'H';          /* תקין: a הוא המערך שלכם */
    printf("%s\n", a);

    /* p[0] = 'H'; היה undefined behavior */
    printf("%s\n", p);
    return 0;
}

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

עוד הבדל אחד שכדאי להכיר: sizeof a הוא 6, אבל sizeof p הוא הגודל של מצביע (8 ברוב המערכות), לא משנה כמה ארוך הטקסט.

הדפסה וקריאה של מחרוזות

%s מדפיס מחרוזת, ו-%c מדפיס תו בודד.

#include <stdio.h>

int main(void) {
    char city[] = "Lisbon";

    printf("City: %s\n", city);
    printf("Initial: %c\n", city[0]);
    printf("Padded: [%10s]\n", city);
    printf("Cut to 3: [%.3s]\n", city);
    return 0;
}

לקלט, הימנעו לגמרי מ-gets: היא הוסרה מהשפה כי אי אפשר להשתמש בה בבטחה. השתמשו ב-fgets, שמקבלת את גודל ה-buffer ולא תגלוש:

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

int main(void) {
    char line[64];

    printf("Type your name: ");
    if (fgets(line, sizeof line, stdin) != NULL) {
        line[strcspn(line, "\n")] = '\0';   /* הסרת ירידת השורה בסוף */
        printf("Hello, %s!\n", line);
    }
    return 0;
}

fgets שומרת את ירידת השורה שלחצתם, וכמעט אף פעם לא רוצים אותה במחרוזת. שורת ה-strcspn מוצאת את ה-'\n' הראשון ודורסת אותו בתו מסיים, דרך סטנדרטית וקומפקטית לחתוך אותו.

מעבר על מחרוזת תו אחר תו

מכיוון שהסוף מסומן ולא נספר, הלולאה האידיומטית בודקת את התו עצמו:

#include <stdio.h>

int main(void) {
    char text[] = "banana";
    int count = 0;

    for (int i = 0; text[i] != '\0'; i++) {
        if (text[i] == 'a') {
            count++;
        }
    }

    printf("'a' appears %d times\n", count);
    return 0;
}

התנאי text[i] != '\0' מקוצר לעיתים קרובות ל-text[i] בלבד, כי '\0' הוא אפס ולכן false. שתי הצורות נכונות, והצורה המפורשת קלה יותר לקריאה בזמן הלמידה.

אפשר לעבור עם מצביע במקום עם אינדקס, וזה C אידיומטי באותה מידה:

#include <stdio.h>
#include <ctype.h>

int main(void) {
    char text[] = "Make It Loud";

    for (char *p = text; *p != '\0'; p++) {
        *p = (char)toupper((unsigned char)*p);
    }

    printf("%s\n", text);
    return 0;
}

ה-cast ל-unsigned char לפני הקריאה ל-toupper הוא לא קישוט: הפונקציות של <ctype.h> לא מוגדרות לערכים שליליים, ו-char רגיל יכול להיות שלילי עבור בתים מעל 127.

אי אפשר להעתיק מחרוזת עם =

זה הקיר שכל מתחיל נתקל בו:

char a[10];
a = "hello";        /* שגיאה: assignment to expression with array type */

char b[10] = "hi";
char c[10];
c = b;              /* שגיאה: מאותה סיבה */

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

כדי להעתיק בזמן ריצה, העתיקו את הבתים עם strcpy מתוך <string.h>:

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

int main(void) {
    char source[] = "hello";
    char dest[16];

    strcpy(dest, source);
    strcat(dest, " there");

    printf("%s (%zu chars)\n", dest, strlen(dest));
    return 0;
}

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

מערכים של מחרוזות

רשימה של מחרוזות היא או מערך של מצביעים (לטקסט קבוע שרק קוראים), או מערך char דו־ממדי (כשכל רשומה צריכה להיות ניתנת לשינוי):

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

int main(void) {
    const char *fruits[] = {"apple", "kiwi", "banana"};
    int n = (int)(sizeof fruits / sizeof fruits[0]);

    for (int i = 0; i < n; i++) {
        printf("%-8s %zu\n", fruits[i], strlen(fruits[i]));
    }

    char editable[3][16] = {"apple", "kiwi", "banana"};
    strcpy(editable[1], "pear");
    printf("changed: %s\n", editable[1]);
    return 0;
}

מערך המצביעים שומר שלוש כתובות לתוך ליטרלים לקריאה בלבד: קומפקטי, אבל לא ניתן לשינוי. הצורה char[3][16] שומרת 48 בתים מהזיכרון שלכם, כך שכל שורה אפשר לכתוב מחדש.

טעויות נפוצות

• לשכוח את הבית של התו המסיים. ב-char s[5] = "hello" אין מקום ל-'\0'. קבעו גודל של strlen + 1.
• שימוש ב-sizeof במקום שבו התכוונתם ל-strlen. sizeof על מצביע נותן את גודל המצביע, לא את אורך הטקסט.
• כתיבה דרך char * לליטרל. הצהירו על מצביעים כאלה כ-const char *.
• השוואה עם ==. זה משווה כתובות. השתמשו ב-strcmp.
• קריאה עם scanf("%s", buf). אין לה מגבלת גודל והיא גולשת בשמחה, העדיפו את fgets.