Guida C interattiva: Funzioni sulle stringhe

Q: Perché non posso confrontare le stringhe con == in C?

a == b confronta i due indirizzi, non i caratteri. Due array distinti che contengono "gatto" stanno a indirizzi diversi, quindi il confronto è falso anche se il testo coincide. Usa strcmp(a, b) == 0 di .

Q: Qual è la differenza tra strcpy e strncpy?

strcpy copia fino al '\0' della sorgente senza sapere quanto è grande la destinazione. strncpy si ferma dopo al massimo n byte, ma se la sorgente è lunga almeno così non copia alcun terminatore, quindi devi scrivere tu dst[n - 1] = '\0';. Nessuna delle due è sicura in automatico; la disciplina sulle dimensioni spetta a te.

Q: Come si cerca una sottostringa in C?

strstr(haystack, needle) restituisce un puntatore alla prima occorrenza, oppure NULL se non ce n'è nessuna. Dato che restituisce un puntatore dentro la stringa originale, found - haystack ti dà l'indice. Usa strchr quando cerchi un singolo carattere.

Ogni funzione di <string.h> è un piccolo ciclo su un array di char che si ferma al terminatore nullo. Una volta chiarito questo, la libreria smette di sembrare un elenco di nomi criptici e diventa la manciata di cicli che avresti scritto tu. Questa pagina copre quelle che fanno quasi tutto il lavoro reale, e le regole sulle dimensioni che impediscono loro di scrivere oltre la fine dei tuoi buffer.

Tutto quello che vedi qui richiede un solo include:

#include <string.h>

strlen: quanti caratteri

strlen conta i byte fino al terminatore, escluso. Restituisce un size_t, quindi stampalo con %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 vale 6; sizeof vale 32. Il primo è il testo, il secondo è lo spazio di memoria: nella pagina sulle stringhe trovi perché questa distinzione conta così tanto.

strlen percorre tutta la stringa a ogni chiamata, quindi non metterla nella condizione di un ciclo sulla stessa stringa che non cambia:

/* riconta l'intera stringa a ogni iterazione */
for (size_t i = 0; i < strlen(s); i++) { ... }

/* conta una volta sola */
size_t n = strlen(s);
for (size_t i = 0; i < n; i++) { ... }

strcpy e strncpy: copiare

strcpy(dst, src) copia i caratteri più il terminatore. Non ha idea di quanto sia grande dst, quindi chi chiama deve garantire che dst contenga almeno strlen(src) + 1 byte.

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

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

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

    /* la regola sulle dimensioni, controllata esplicitamente */
    if (strlen(src) + 1 <= sizeof dst) {
        printf("ci sta con %zu byte di margine\n", sizeof dst - strlen(src) - 1);
    }
    return 0;
}

strncpy riceve un numero massimo, ma ha una trappola famosa: quando la sorgente è lunga almeno n byte copia esattamente n caratteri e nessun terminatore. Termina sempre tu la stringa:

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

int main(void) {
    char src[] = "un nome di progetto molto lungo";
    char dst[10];

    strncpy(dst, src, sizeof dst - 1);
    dst[sizeof dst - 1] = '\0';        /* obbligatorio, non facoltativo */

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

sizeof dst - 1 più il terminatore esplicito è lo schema da memorizzare. (strncpy riempie anche le sorgenti corte con zeri fino a n byte, lavoro sprecato per i buffer grandi: è stata progettata per record a larghezza fissa, non per la sicurezza.)

strcat e strncat: unire

strcat(dst, src) accoda src alla fine di ciò che c'è già in dst. La destinazione deve contenere entrambe le stringhe più un terminatore, e deve già contenere una stringa valida: accodare a memoria non inizializzata è comportamento indefinito.

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

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

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

    printf("%s\n", path);
    printf("usati %zu di %zu byte\n", strlen(path) + 1, sizeof path);
    return 0;
}

Nota char path[64] = "/home/ada"; invece di char path[64];: è l'inizializzatore a renderla una stringa valida per il primo strcat.

strncat(dst, src, n) accoda al massimo n caratteri e aggiunge sempre un terminatore, quindi n è lo spazio rimanente, non la dimensione totale del buffer:

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

Chiamate ripetute a strcat riscansionano ogni volta la destinazione per trovarne la fine. Costruire una stringa lunga in un ciclo in questo modo ha costo quadratico; per qualsiasi cosa di una certa dimensione, tieni traccia tu della posizione di scrittura oppure usa snprintf, trattata nella conversione di stringhe.

strcmp: confrontare

== confronta gli indirizzi, quindi è falso per due array distinti che contengono lo stesso testo. strcmp confronta i caratteri e restituisce il segno della differenza.

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

int main(void) {
    char a[] = "mela";
    char b[] = "mela";
    char c[] = "pera";

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

    printf("segno di strcmp(a, c): %s\n", strcmp(a, c) < 0 ? "a prima di c" : "a dopo c");
    return 0;
}

Tre regole:

Per l'uguaglianza controlla strcmp(a, b) == 0. Scrivere if (strcmp(a, b)) significa "se sono diverse", e quasi tutti lo leggono al contrario.
È definito solo il segno. Non confrontare il risultato con 1 o -1.
L'ordinamento segue il valore dei byte, quindi in ASCII "Zebra" viene prima di "apple". Per un confronto che ignori maiuscole e minuscole, porta prima entrambe le copie in minuscolo: la diffusissima strcasecmp è un'estensione POSIX, non C standard.

strncmp(a, b, n) confronta solo i primi n caratteri, ed è il modo pulito per controllare un prefisso:

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

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

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

strchr e strstr: cercare

strchr(s, ch) trova la prima occorrenza di un carattere; strrchr trova l'ultima. strstr(haystack, needle) trova una sottostringa. Tutte e tre restituiscono un puntatore dentro la stringa originale, oppure NULL quando non c'è corrispondenza.

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

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

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

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

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

Sottraendo l'inizio della stringa dal puntatore restituito ottieni l'indice; il suo tipo è ptrdiff_t e si stampa con %td. Dato che il risultato punta dentro l'array originale, at + 1 è il resto della stringa senza alcuna copia: un idioma C molto comune.

Controlla sempre NULL prima di dereferenziare. strchr(email, '@') + 1 su una stringa senza @ calcola un indirizzo a partire da NULL, e il programma smette di essere definito.

Dividere una stringa

Non esiste una funzione split, ma strchr più un terminatore fanno il lavoro sul posto. Questo esempio divide un indirizzo email in utente e dominio:

#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("non e un indirizzo email\n");
        return 1;
    }

    size_t user_len = (size_t)(at - input);
    if (user_len >= sizeof user) {
        printf("parte utente troppo lunga\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("utente:  %s\n", user);
    printf("dominio: %s\n", domain);
    return 0;
}

memcpy copia un numero esatto di byte senza badare ai terminatori, ed è quello che vuoi quando conosci già la lunghezza. Il terminatore viene poi scritto a mano.

Un esempio completo: normalizzare un nome

Mettendo insieme tutto il giro: rifilare, confrontare, copiare e unire.

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

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

    /* salta gli spazi iniziali */
    char *start = first;
    while (*start == ' ') {
        start++;
    }

    /* taglia gli spazi finali */
    size_t len = strlen(start);
    while (len > 0 && start[len - 1] == ' ') {
        start[--len] = '\0';
    }

    /* maiuscola la prima lettera di ogni parte */
    start[0] = (char)toupper((unsigned char)start[0]);
    last[0]  = (char)toupper((unsigned char)last[0]);

    /* unisci con una copia limitata */
    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("e Ada Lovelace? %s\n",
           strcmp(full, "Ada Lovelace") == 0 ? "si" : "no");
    return 0;
}

Ogni scrittura è limitata dal sizeof della destinazione stessa, e ogni strncpy è seguita da un terminatore esplicito. Questa disciplina, applicata con coerenza, è ciò che rende sicuro il codice C sulle stringhe.

Regole sulle dimensioni da ricordare

strcpy richiede strlen(src) + 1 byte liberi nella destinazione.
strcat richiede strlen(dst) + strlen(src) + 1.
Dopo strncpy, scrivi tu dst[n - 1] = '\0'.
Per strncat, il conteggio è lo spazio rimasto: sizeof dst - strlen(dst) - 1.
Controlla che strchr e strstr non abbiano restituito NULL prima di usarne il risultato.
Usa sizeof dst solo quando dst è un vero array. Dentro una funzione che riceve char *dst, sizeof dà la dimensione del puntatore: passa la lunghezza del buffer come parametro separato.

Domande frequenti

Cosa restituisce strcmp in C?

Zero quando le due stringhe sono identiche, un valore negativo quando la prima viene prima della seconda in ordine e un valore positivo quando viene dopo. Conta solo il segno: non dare mai per scontato che restituisca -1 o 1. Il controllo che ti serve è quasi sempre if (strcmp(a, b) == 0).

Perché non posso confrontare le stringhe con == in C?

a == b confronta i due indirizzi, non i caratteri. Due array distinti che contengono "gatto" stanno a indirizzi diversi, quindi il confronto è falso anche se il testo coincide. Usa strcmp(a, b) == 0 di <string.h>.

Qual è la differenza tra strcpy e strncpy?

strcpy copia fino al '\0' della sorgente senza sapere quanto è grande la destinazione. strncpy si ferma dopo al massimo n byte, ma se la sorgente è lunga almeno così non copia alcun terminatore, quindi devi scrivere tu dst[n - 1] = '\0';. Nessuna delle due è sicura in automatico; la disciplina sulle dimensioni spetta a te.

Come si cerca una sottostringa in C?

strstr(haystack, needle) restituisce un puntatore alla prima occorrenza, oppure NULL se non ce n'è nessuna. Dato che restituisce un puntatore dentro la stringa originale, found - haystack ti dà l'indice. Usa strchr quando cerchi un singolo carattere.

Concetti correlati