Funkcje napisowe w C: strlen, strcpy, strcat, strcmp i inne

Każda funkcja z <string.h> to mała pętla po tablicy char, która zatrzymuje się na znaku końca napisu. Gdy to jest jasne, biblioteka przestaje wyglądać jak lista tajemniczych nazw, a zaczyna jak garść pętli, które można by napisać samodzielnie. Ta strona omawia te, które wykonują niemal całą prawdziwą pracę, oraz zasady rozmiarów, które chronią przed zapisem za końcem buforów.

Wszystko tutaj wymaga jednego dołączenia:

#include <string.h>

strlen: ile jest znaków

strlen liczy bajty aż do terminatora, bez niego. Zwraca size_t, więc wypisuj wynik przez %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 wynosi 6, a sizeof wynosi 32. Pierwsze to tekst, drugie to pamięć. Dlaczego to rozróżnienie jest tak ważne, wyjaśnia strona o napisach.

strlen przy każdym wywołaniu przechodzi cały napis, więc nie wstawiaj go do warunku pętli po tym samym, niezmiennym napisie:

/* liczy caly napis od nowa w kazdej iteracji */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* policz raz */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy i strncpy: kopiowanie

strcpy(dst, src) kopiuje znaki razem z terminatorem. Nie ma pojęcia, jak duże jest dst, więc wywołujący musi zagwarantować, że dst mieści co najmniej strlen(src) + 1 bajtów.

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

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

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

    /* zasada rozmiaru, sprawdzona jawnie */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("miesci sie, wolne bajty: %zu\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

strncpy przyjmuje maksymalną liczbę znaków, ale ma słynną pułapkę: gdy źródło ma co najmniej n bajtów, kopiuje dokładnie n znaków i żadnego terminatora. Zawsze dopisuj go sam:

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

int main(void) {
    char src[] = "bardzo dluga nazwa projektu";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* wymagane, nie opcjonalne */

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

sizeof dst - 1 razem z jawnym terminatorem to wzorzec do zapamiętania. (strncpy dopełnia też krótkie źródła zerami aż do n bajtów, co przy dużych buforach jest zmarnowaną pracą: funkcję zaprojektowano do rekordów o stałej szerokości, a nie z myślą o bezpieczeństwie.)

strcat i strncat: łączenie

strcat(dst, src) dopisuje src na końcu tego, co już jest w dst. Miejsce docelowe musi zmieścić oba napisy plus jeden terminator i musi już zawierać poprawny napis: dopisywanie do niezainicjalizowanej pamięci to niezdefiniowane zachowanie.

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

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

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

    printf("%s\n", path);
    printf("zajete bajty: %zu z %zu\n", strlen(path) + 1, sizeof path);
    return 0;
}

Zwróć uwagę na char path[64] = "/home/ada"; zamiast char path[64];: to inicjalizator sprawia, że przed pierwszym strcat jest to poprawny napis.

strncat(dst, src, n) dopisuje co najwyżej n znaków i zawsze dodaje terminator, więc n to pozostałe wolne miejsce, a nie całkowity rozmiar bufora:

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

Każde kolejne wywołanie strcat od nowa przeszukuje miejsce docelowe w poszukiwaniu jego końca. Budowanie w ten sposób długiego napisu w pętli ma złożoność kwadratową. Przy czymkolwiek większym śledź własną pozycję zapisu albo użyj snprintf, opisanego na stronie o konwersji napisów.

strcmp: porównywanie

== porównuje adresy, więc dla dwóch różnych tablic z tym samym tekstem daje fałsz. strcmp porównuje znaki i zwraca znak różnicy.

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

int main(void) {
    char a[] = "banan";
    char b[] = "banan";
    char c[] = "jablko";

    const char *pa = a;
    const char *pb = b;
    printf("pa == pb (adresy)? %s\n", pa == pb ? "tak" : "nie");
    printf("strcmp(a, b) == 0? %s\n", strcmp(a, b) == 0 ? "tak" : "nie");

    printf("znak strcmp(a, c): %s\n", strcmp(a, c) < 0 ? "a przed c" : "a po c");
    return 0;
}

Trzy zasady:

• Równość sprawdzaj przez strcmp(a, b) == 0. Zapis if (strcmp(a, b)) znaczy „jeśli się różnią”, co prawie każdy czyta na odwrót.
• Zdefiniowany jest tylko znak wyniku. Nie porównuj go z 1 ani -1.
• Kolejność wynika z wartości bajtów, więc w ASCII "Zebra" jest przed "apple". Aby porównać bez rozróżniania wielkości liter, najpierw zamień obie kopie na małe litery: popularne strcasecmp to rozszerzenie POSIX, a nie standardowe C.

strncmp(a, b, n) porównuje tylko pierwsze n znaków i jest to czysty sposób na sprawdzenie prefiksu:

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

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

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

strchr i strstr: wyszukiwanie

strchr(s, ch) znajduje pierwsze wystąpienie znaku, a strrchr ostatnie. strstr(haystack, needle) znajduje podnapis. Wszystkie trzy zwracają wskaźnik do oryginalnego napisu albo NULL, gdy nic nie pasuje.

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

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

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

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

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

Odjęcie początku od zwróconego wskaźnika daje indeks. Jego typ to ptrdiff_t, wypisywany przez %td. Ponieważ wynik wskazuje do wnętrza oryginalnej tablicy, at + 1 to reszta napisu bez żadnego kopiowania, bardzo częsty idiom w C.

Zawsze sprawdzaj NULL przed dereferencją. strchr(email, '@') + 1 na napisie bez @ wylicza adres z NULL i od tej chwili program nie ma już zdefiniowanego zachowania.

Dzielenie napisu

Nie ma funkcji split, ale strchr plus terminator załatwia sprawę w miejscu. Ten przykład dzieli adres e-mail na użytkownika i domenę:

#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("to nie jest adres e-mail\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("nazwa uzytkownika jest za dluga\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("uzytkownik: %s\n", user);
    printf("domena:     %s\n", domain);
    return 0;
}

memcpy kopiuje dokładną liczbę bajtów, nie przejmując się terminatorami, a tego właśnie chcesz, gdy długość jest już znana. Terminator dopisuje się potem ręcznie.

Przykład w praktyce: porządkowanie imienia i nazwiska

Wszystko razem: przycinanie, porównywanie, kopiowanie i łączenie:

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

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

    /* pomin spacje na poczatku */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* utnij spacje na koncu */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* wielka pierwsza litera w kazdej czesci */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* polacz ograniczonym kopiowaniem */
    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("czy to Ada Lovelace? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "tak" : "nie");
    return 0;
}

Każdy zapis jest ograniczony własnym sizeof miejsca docelowego, a po każdym strncpy następuje jawny terminator. Ta dyscyplina, stosowana konsekwentnie, sprawia, że kod napisowy w C jest bezpieczny.

Zasady rozmiarów do zapamiętania

• strcpy potrzebuje strlen(src) + 1 wolnych bajtów w miejscu docelowym.
• strcat potrzebuje strlen(dst) + strlen(src) + 1.
• Po strncpy sam zapisz dst[n - 1] = '\0'.
• W strncat liczba to pozostałe miejsce: sizeof dst - strlen(dst) - 1.
• Sprawdzaj wynik strchr i strstr pod kątem NULL, zanim go użyjesz.
• Używaj sizeof dst tylko wtedy, gdy dst jest prawdziwą tablicą. Wewnątrz funkcji przyjmującej char *dst sizeof daje rozmiar wskaźnika, więc długość bufora przekazuj jako osobny parametr.