دوال السلاسل النصية في لغة C: strlen وstrcpy وstrcat وstrcmp وغيرها

كل دالة في <string.h> حلقة صغيرة على مصفوفة char تتوقّف عند المنهي الصفري. وبمجرّد وضوح ذلك، تكفّ المكتبة عن أن تبدو قائمة أسماء مبهمة وتبدأ في أن تبدو حفنة الحلقات التي كنت ستكتبها بنفسك. تغطّي هذه الصفحة ما يحمل كل العمل الحقيقي تقريبًا - وقواعد تحديد الأحجام التي تمنعها من الكتابة بعد نهاية مخازنك.

وكل ما هنا يحتاج تضمينًا واحدًا:

#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 على السلسلة كاملة في كل استدعاء، فلا تضعها في شرط حلقة على السلسلة الثابتة نفسها:

/* re-counts the whole string on every iteration */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* count once */
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 بايتًا، وهذا عمل مهدور للمخازن الكبيرة - فقد صُمّمت لسجلّات ثابتة العرض لا للأمان.)

strcat وstrncat: الدمج

تُلحِق strcat(dst, src) القيمة src بنهاية ما في dst سلفًا. ويجب أن تحمل الوجهة السلسلتين زائد منهٍ واحد، وأن تحتوي سلفًا على سلسلة صالحة - فالإلحاق بذاكرة غير مهيّأة سلوك غير معرَّف.

#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 هي المساحة المتبقّية لا حجم المخزن كاملًا:

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

وتعيد استدعاءات strcat المتكرّرة مسحَ الوجهة لإيجاد نهايتها في كل مرة. وبناء سلسلة طويلة في حلقة بتلك الطريقة تربيعي؛ ولأي شيء ذي حجم، تتبّع موضع الكتابة بنفسك أو استخدم snprintf، المغطّاة في تحويل السلاسل النصية.

strcmp: المقارنة

تقارن == العناوين، فهي خاطئة لمصفوفتين متمايزتين تحملان النص نفسه. أما 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 ولم يعد البرنامج معرَّفًا.

تقسيم سلسلة نصية

لا توجد دالة تقسيم، لكن 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 حجم المؤشّر - مرّر طول المخزن كوسيط منفصل.