C'de Metin Fonksiyonları: strlen, strcpy, strcat, strcmp ve Dahası

<string.h> içindeki her fonksiyon, boş sonlandırıcıda duran, bir char dizisi üzerindeki küçük bir döngüdür. Bu anlaşıldığında kütüphane gizemli isimlerden oluşan bir liste gibi görünmeyi bırakır ve kendiniz yazacağınız bir avuç döngü gibi görünmeye başlar. Bu sayfa gerçek işin neredeyse tamamını taşıyanları - ve onların tamponlarınızın sonunun ötesine yazmasını engelleyen boyutlandırma kurallarını - ele alıyor.

Buradaki her şey tek bir include ister:

#include <string.h>

strlen: Kaç Karakter

strlen, sonlandırıcıya kadar (onu dahil etmeden) baytları sayar. size_t döndürür, dolayısıyla onu %zu ile yazdırın.

#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'dır; sizeof 32'dir. Birincisi metin, ikincisi depolamadır - o ayrımın neden bu kadar önemli olduğu için bkz. metinler.

strlen her çağrıda tüm metni dolaşır, dolayısıyla onu değişmeyen aynı metin üzerindeki bir döngü koşuluna koymayın:

/* her yinelemede tüm metni yeniden sayar */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* bir kez say */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy ve strncpy: Kopyalamak

strcpy(dst, src), karakterleri artı sonlandırıcıyı kopyalar. dst'nin ne kadar büyük olduğu hakkında hiçbir fikre sahip değildir, dolayısıyla çağıran dst'nin en az strlen(src) + 1 bayt tuttuğunu garanti etmelidir.

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

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

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

    /* boyutlandirma kurali, acikca denetlenmis */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("%zu bayt bos yerle sigdi\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

strncpy en fazla bir sayı alır, ama meşhur bir tuzağı vardır: kaynak en az n bayt uzunluğundayken tam olarak n karakter kopyalar ve hiç sonlandırıcı koymaz. Her zaman kendiniz sonlandırın:

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

int main(void) {
    char src[] = "cok uzun bir proje adi";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* zorunlu, istege bagli degil */

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

sizeof dst - 1 artı açık sonlandırıcı, ezberlenmesi gereken kalıptır. (strncpy ayrıca kısa kaynakları n bayta kadar sıfırla doldurur ki bu büyük tamponlar için boşa yapılan iştir - güvenlik için değil sabit genişlikli kayıtlar için tasarlanmıştı.)

strcat ve strncat: Birleştirmek

strcat(dst, src), src'yi dst'de zaten ne varsa onun sonuna ekler. Hedef, her iki metni artı bir sonlandırıcıyı tutmalıdır ve zaten geçerli bir metin içeriyor olmalıdır - ilk değersiz belleğe eklemek tanımsız davranıştır.

#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("%zu bayttan %zu tanesi kullanildi\n", sizeof path, strlen(path) + 1);
    return 0;
}

char path[64]; yerine char path[64] = "/home/ada"; olduğuna dikkat edin - ilk değer, onu ilk strcat için geçerli bir metin yapan şeydir.

strncat(dst, src, n), en fazla n karakter ekler ve her zaman bir sonlandırıcı koyar, dolayısıyla n, toplam tampon boyutu değil kalan alandır:

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

Tekrarlanan strcat çağrıları, sonunu bulmak için hedefi her seferinde yeniden tarar. Bir döngüde uzun bir metni böyle kurmak karesel maliyetlidir; büyükçe bir şey için kendi yazma konumunuzu takip edin ya da metin dönüşümü sayfasında ele alınan snprintf'i kullanın.

strcmp: Karşılaştırmak

== adresleri karşılaştırır, dolayısıyla aynı metni tutan iki ayrı dizi için yanlıştır. strcmp karakterleri karşılaştırır ve farkın işaretini döndürür.

#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 (adresler)? %s\n", pa == pb ? "evet" : "hayir");
    printf("strcmp(a, b) == 0?  %s\n", strcmp(a, b) == 0 ? "evet" : "hayir");

    printf("strcmp(a, c) isareti: %s\n", strcmp(a, c) < 0 ? "a, c'den once" : "a, c'den sonra");
    return 0;
}

Üç kural:

• Eşitlik için strcmp(a, b) == 0 test edin. if (strcmp(a, b)) yazmak "eğer farklıysalar" demektir ki bu neredeyse herkese ters okunur.
• Yalnızca işaret tanımlıdır. Sonucu 1 ya da -1 ile karşılaştırmayın.
• Sıralama bayt değerine göredir, dolayısıyla ASCII'de "Zebra", "apple"'dan önce sıralanır. Büyük-küçük harf duyarsız karşılaştırma için önce iki kopyayı da küçük harfe çevirin - yaygın görülen strcasecmp bir POSIX uzantısıdır, standart C değildir.

strncmp(a, b, n) yalnızca ilk n karakteri karşılaştırır ki bu bir öneki test etmenin temiz yoludur:

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

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

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

strchr ve strstr: Aramak

strchr(s, ch), bir karakterin ilk geçişini bulur; strrchr sonuncusunu bulur. strstr(haystack, needle) bir alt metin bulur. Üçü de özgün metnin içine bir gösterici ya da eşleşme yoksa NULL döndürür.

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

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

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

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

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

Döndürülen göstericiyi başlangıçtan çıkarmak indeksi verir; tipi ptrdiff_t'dir ve %td ile yazdırılır. Sonuç özgün dizinin içini gösterdiği için at + 1, hiç kopyalama olmadan metnin geri kalanıdır - çok yaygın bir C deyimi.

Dereferans etmeden önce her zaman NULL kontrolü yapın. @ içermeyen bir metinde strchr(email, '@') + 1, NULL'dan bir adres hesaplar ve program artık tanımlı değildir.

Bir Metni Bölmek

Bir bölme fonksiyonu yoktur, ama strchr artı bir sonlandırıcı işi yerinde halleder. Bu örnek bir e-postayı kullanıcı ve alan adı olarak keser:

#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("e-posta adresi degil\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("kullanici kismi cok uzun\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("kullanici: %s\n", user);
    printf("alan adi:  %s\n", domain);
    return 0;
}

memcpy, sonlandırıcıları umursamadan kesin bir bayt sayısı kopyalar ki uzunluğu zaten bildiğinizde istediğiniz budur. Sonlandırıcı ardından elle yazılır.

İşlenmiş Bir Örnek: Bir İsmi Normalleştirmek

Turu bir araya getirelim - kırpma, karşılaştırma, kopyalama ve birleştirme:

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

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

    /* bastaki bosluklari atla */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* sondaki bosluklari kes */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* her parcanin ilk harfini buyut */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* sinirli bir kopyayla birlestir */
    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("Ada Lovelace mi? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "evet" : "hayir");
    return 0;
}

Her yazma hedefin kendi sizeof'uyla sınırlıdır ve her strncpy'yi açık bir sonlandırıcı izler. Tutarlı uygulanan o disiplin, C metin kodunu güvenli kılan şeydir.

Akılda Tutulacak Boyutlandırma Kuralları

• strcpy, hedefte strlen(src) + 1 bayt boş yer ister.
• strcat, strlen(dst) + strlen(src) + 1 ister.
• strncpy'den sonra dst[n - 1] = '\0' yazın.
• strncat için sayı, kalan alandır: sizeof dst - strlen(dst) - 1.
• Sonucu kullanmadan önce strchr ve strstr'ı NULL için denetleyin.
• sizeof dst'yi yalnızca dst gerçek bir diziyken kullanın. char *dst alan bir fonksiyonun içinde sizeof göstericinin boyutunu verir - tampon uzunluğunu ayrı bir parametre olarak geçirin.