פונקציות מחרוזות ב-C: strlen, strcpy, strcat, strcmp ועוד

כל פונקציה ב-<string.h> היא לולאה קטנה על מערך של char שעוצרת בתו ה-null המסיים. ברגע שזה ברור, הספרייה מפסיקה להיראות כמו רשימה של שמות קריפטיים ומתחילה להיראות כמו קומץ הלולאות שהייתם כותבים בעצמכם. העמוד הזה עוסק באלה שנושאות כמעט את כל העבודה האמיתית, ובכללי הגודל שמונעים מהן לכתוב מעבר לסוף ה-buffers שלכם.

כל מה שכאן דורש include אחד:

#include <string.h>

strlen: כמה תווים

strlen סופרת בתים עד התו המסיים, לא כולל אותו. היא מחזירה size_t, לכן הדפיסו אותה עם %zu.

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

int main(void) {
    char word[32] = "banana";

    printf("strlen = %zu\n", strlen(word));
    printf("sizeof = %zu\n", sizeof word);
    return 0;
}

strlen היא 6, ו-sizeof הוא 32. הראשון הוא הטקסט, השני הוא האחסון. בעמוד המחרוזות מוסבר למה ההבחנה הזו חשובה כל כך.

strlen עוברת על כל המחרוזת בכל קריאה, לכן אל תשימו אותה בתנאי של לולאה על אותה מחרוזת שלא משתנה:

/* סופרת מחדש את כל המחרוזת בכל איטרציה */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* סופרים פעם אחת */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy ו-strncpy: העתקה

strcpy(dst, src) מעתיקה את התווים ואת התו המסיים. אין לה מושג מה גודל dst, ולכן הקורא חייב להבטיח ש-dst מחזיק לפחות strlen(src) + 1 בתים.

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

int main(void) {
    char src[] = "portable";
    char dst[16];

    strcpy(dst, src);
    printf("%s\n", dst);

    /* כלל הגודל, בבדיקה מפורשת */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("fits with %zu bytes to spare\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

strncpy מקבלת מספר מקסימלי, אבל יש לה מלכודת מפורסמת: כשהמקור באורך n בתים לפחות, היא מעתיקה בדיוק n תווים ובלי תו מסיים. תמיד סיימו את המחרוזת בעצמכם:

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

int main(void) {
    char src[] = "a very long project name";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* חובה, לא רשות */

    printf("[%s]\n", dst);
    return 0;
}

sizeof dst - 1 ועוד תו מסיים מפורש הוא הדפוס שכדאי לשנן. (strncpy גם מרפדת מקורות קצרים באפסים עד n בתים, וזו עבודה מבוזבזת ב-buffers גדולים: היא תוכננה לרשומות ברוחב קבוע, לא לבטיחות.)

strcat ו-strncat: חיבור

strcat(dst, src) מוסיפה את src לסוף מה שכבר נמצא ב-dst. היעד חייב להכיל את שתי המחרוזות ועוד תו מסיים אחד, והוא חייב כבר להכיל מחרוזת תקינה: הוספה לזיכרון לא מאותחל היא undefined behavior.

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

int main(void) {
    char path[64] = "/home/ada";

    strcat(path, "/");
    strcat(path, "notes.txt");

    printf("%s\n", path);
    printf("used %zu of %zu bytes\n", strlen(path) + 1, sizeof path);
    return 0;
}

שימו לב ל-char path[64] = "/home/ada"; במקום char path[64];: המאתחל הוא מה שהופך אותו למחרוזת תקינה עבור ה-strcat הראשון.

strncat(dst, src, n) מוסיפה לכל היותר n תווים ותמיד מוסיפה תו מסיים, כך ש-n הוא המקום שנשאר, ולא הגודל הכולל של ה-buffer:

strncat(dst, src, sizeof dst - strlen(dst) - 1);

קריאות חוזרות ל-strcat סורקות מחדש את היעד כדי למצוא את הסוף שלו בכל פעם. בנייה של מחרוזת ארוכה בלולאה בדרך הזו היא ריבועית. לכל דבר בגודל משמעותי, עקבו בעצמכם אחרי מיקום הכתיבה או השתמשו ב-snprintf, שמוסברת בעמוד המרת מחרוזות.

strcmp: השוואה

== משווה כתובות, ולכן הוא false עבור שני מערכים נפרדים שמחזיקים את אותו טקסט. strcmp משווה את התווים ומחזירה את הסימן של ההפרש.

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

int main(void) {
    char a[] = "apple";
    char b[] = "apple";
    char c[] = "banana";

    const char *pa = a;
    const char *pb = b;
    printf("pa == pb (addresses)? %s\n", pa == pb ? "yes" : "no");
    printf("strcmp(a, b) == 0?  %s\n", strcmp(a, b) == 0 ? "yes" : "no");

    printf("strcmp(a, c) sign: %s\n", strcmp(a, c) < 0 ? "a before c" : "a after c");
    return 0;
}

שלושה כללים:

• בדקו strcmp(a, b) == 0 לשוויון. כתיבת if (strcmp(a, b)) פירושה "אם הן שונות", וזה נקרא הפוך כמעט לכולם.
• רק הסימן מוגדר. אל תשוו את התוצאה ל-1 או ל--1.
• הסדר הוא לפי ערך הבית, ולכן "Zebra" בא לפני "apple" ב-ASCII. להשוואה שלא מבחינה בין אותיות גדולות לקטנות, המירו קודם את שני העותקים לאותיות קטנות: strcasecmp הנפוצה היא הרחבה של POSIX, ולא C סטנדרטית.

strncmp(a, b, n) משווה רק את n התווים הראשונים, וזו הדרך הנקייה לבדוק קידומת:

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

int main(void) {
    const char *url = "https://coddy.tech";

    if (strncmp(url, "https://", 8) == 0) {
        printf("secure URL\n");
    }
    return 0;
}

strchr ו-strstr: חיפוש

strchr(s, ch) מוצאת את המופע הראשון של תו, ו-strrchr מוצאת את האחרון. strstr(haystack, needle) מוצאת תת־מחרוזת. שלושתן מחזירות מצביע לתוך המחרוזת המקורית, או NULL כשאין התאמה.

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

int main(void) {
    char email[] = "ada@coddy.tech";

    char *at = strchr(email, '@');
    if (at != NULL) {
        printf("'@' at index %td\n", at - email);
        printf("domain: %s\n", at + 1);
    }

    char *dot = strrchr(email, '.');
    printf("extension: %s\n", dot != NULL ? dot + 1 : "(none)");

    if (strstr(email, "coddy") != NULL) {
        printf("contains \"coddy\"\n");
    }
    return 0;
}

חיסור המצביע המוחזר מההתחלה נותן את האינדקס. הטיפוס שלו הוא ptrdiff_t, ומדפיסים אותו עם %td. מכיוון שהתוצאה מצביעה לתוך המערך המקורי, at + 1 הוא שאר המחרוזת בלי שום העתקה, ניב נפוץ מאוד ב-C.

תמיד בדקו NULL לפני הפניה. strchr(email, '@') + 1 על מחרוזת בלי @ מחשב כתובת מתוך NULL, והתוכנית כבר לא מוגדרת.

פיצול מחרוזת

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

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

int main(void) {
    char input[] = "ada@coddy.tech";
    char user[32];
    char domain[64];

    char *at = strchr(input, '@');
    if (at == NULL) {
        printf("not an email address\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("user part too long\n");
        return 1;
    }

    memcpy(user, input, user_len);
    user[user_len] = '\0';

    strncpy(domain, at + 1, sizeof domain - 1);
    domain[sizeof domain - 1] = '\0';

    printf("user:   %s\n", user);
    printf("domain: %s\n", domain);
    return 0;
}

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

דוגמה מלאה: נרמול שם

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

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

int main(void) {
    char first[32] = "  ada  ";
    char last[32]  = "lovelace";
    char full[80];

    /* דילוג על רווחים בהתחלה */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* חיתוך רווחים בסוף */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* אות גדולה בתחילת כל חלק */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* חיבור עם העתקה מוגבלת */
    strncpy(full, start, sizeof full - 1);
    full[sizeof full - 1] = '\0';
    strncat(full, " ", sizeof full - strlen(full) - 1);
    strncat(full, last, sizeof full - strlen(full) - 1);

    printf("[%s]\n", full);
    printf("is it Ada Lovelace? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "yes" : "no");
    return 0;
}

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

כללי גודל שכדאי לשמור

• strcpy צריכה strlen(src) + 1 בתים פנויים ביעד.
• strcat צריכה strlen(dst) + strlen(src) + 1.
• אחרי strncpy, כתבו dst[n - 1] = '\0' בעצמכם.
• ב-strncat, המספר הוא המקום שנשאר: sizeof dst - strlen(dst) - 1.
• בדקו אם strchr ו-strstr החזירו NULL לפני שמשתמשים בתוצאה.
• השתמשו ב-sizeof dst רק כש-dst הוא מערך אמיתי. בתוך פונקציה שמקבלת char *dst, sizeof נותן את גודל המצביע, לכן העבירו את אורך ה-buffer כפרמטר נפרד.