In molti linguaggi ad alto livello (come Python o Java) esiste un tipo primitivo string che si allunga e si accorcia magicamente da solo. Nel linguaggio C, fedele alla sua filosofia di trasparenza hardware, non esiste un tipo primitivo “stringa”!
Come viene rappresentata allora una parola o una frase in C? Semplicemente come un normale vettore (array) di caratteri (char) con una convenzione geniale: alla fine dei caratteri utili della parola viene sempre inserito un carattere speciale “sentinella”, il carattere nullo '\0' (Null Terminator, il cui codice numerico ASCII è 0).
Grazie a quel '\0', qualsiasi funzione (come printf o strlen) che riceve l’indirizzo del primo carattere può scorrere il vettore cella dopo cella sapendo esattamente dove finisce la stringa, senza bisogno che le venga passata la lunghezza a parte!
Rappresentazione in Memoria e il Terminatore Nullo '\0'
La regola del + 1 per il terminatore '\0'
Per memorizzare una parola composta da L caratteri visibili (ad esempio "ciao", che ha lunghezza L=4), il vettore di char deve avere una capienza di almeno L+1 celle (char s[5]), perché l’ultima cella è indispensabile per ospitare il terminatore '\0':
flowchart LR
subgraph StringaRAM["char s[8] = \"ciao\"; in memoria RAM"]
direction LR
C0["s[0]\n'c' (99)"] --- C1["s[1]\n'i' (105)"] --- C2["s[2]\n'a' (97)"] --- C3["s[3]\n'o' (111)"] --- C4["s[4]\n'\\0' (0)\nTERMINATORE!"] --- C5["s[5]\n'\\0'"] --- C6["s[6]\n'\\0'"] --- C7["s[7]\n'\\0'"]
end
style C4 fill:#ffe6cc,stroke:#d79b00,stroke-width:2px
Attenzione alla differenza tra '0' e '\0':
'0' è il carattere stampabile della cifra zero, e nella tabella ASCII vale 48!
'\0' è il carattere di controllo nullo (non stampabile), e vale esattamente 0.
Tre distinzioni fondamentali da non sbagliare mai!
1. Differenza tra apici singoli 'a' e doppi apici "a"
'a': è un singolo carattere di tipo char (occupa 1 byte con il codice ASCII 97).
"a": è una stringa costante (string literal), cioè un array di 2 byte contenente {'a', '\0'}!
Se passate NON_STRINGA a printf("%s", NON_STRINGA), printf stamperà ciao e poi continuerà a leggere e stampare byte casuali della memoria RAM finché non incontrerà per puro caso uno byte zero (o andrà in crash)!
3. Array modificabile char s[] = "ciao" vs Puntatore a costante char *p = "ciao"
Questa è una delle domande più frequenti agli esami di Programmazione I:
char s[] = "ciao";: alloca sullo Stack un array locale di 5 byte e vi copia dentro i caratteri 'c','i','a','o','\0'. È liberamente modificabile: scrivere s[0] = 'C'; trasforma la stringa in "Ciao".
char *p = "ciao"; (meglio scritto come const char *p = "ciao";): la costante "ciao" viene collocata dal compilatore in un segmento di memoria a sola lettura (Read-Only Data, .rodata), e il puntatore p punta a quell’area protetta. Tentare di scrivere p[0] = 'C'; provoca un immediato Segmentation Fault a tempo di esecuzione!
Input e Output Sicuro di Stringhe
Stampare una stringa
Con printf("%s", s) oppure puts(s) (che aggiunge automaticamente un \n finale).
Leggere una stringa da tastiera: perché gets() è bandita e come usare fgets() o scanf()
Perché gets(buf) è stata rimossa dallo standard C11: gets leggeva una riga da tastiera senza sapere quanto fosse grande il vettore buf! Se buf era char buf[10] e l’utente digitava 50 caratteri, gets scriveva 40 byte fuori dall’array (Buffer Overflow). Non usarla mai!
Lettura di una singola parola (senza spazi) con scanf limitata: scanf("%s", buf) si ferma al primo spazio bianco (quindi se l’utente scrive "Mario Rossi", legge solo "Mario"). Inoltre, per evitare overflow, bisogna sempre specificare la lunghezza massima (N−1 caratteri per lasciare spazio a '\0'):
char parola[32];scanf("%31s", parola); /* Legge al massimo 31 caratteri + aggiunge '\0' */
(Nota: davanti a parola NON si mette & perché il nome dell’array parola è già l’indirizzo &parola[0]!)
Lettura sicura di un’intera riga (inclusi gli spazi) con fgets:
La funzione standard raccomandata è fgets(buffer, dimensione_buffer, stdin):
char riga[64];if (fgets(riga, sizeof(riga), stdin) != NULL) { /* ATTENZIONE: fgets conserva anche il carattere '\n' finale se ci sta nel buffer! Ecco il modo pulito per rimuovere il '\n' finale sostituendolo con '\0': */ int i = 0; while (riga[i] != '\0') { if (riga[i] == '\n') { riga[i] = '\0'; } else { i++; } }}
La libreria <string.h> e l’implementazione manuale delle funzioni
Includendo #include <string.h> abbiamo a disposizione le funzioni standard per manipolare le stringhe. All’esame viene spessissimo richiesto sia di saperle usare, sia di saperle reimplementare manualmente con un ciclo!
Funzione <string.h>
Cosa fa
Complessità e Note critiche
strlen(s)
Restituisce il numero di caratteri di sescluso '\0' (tipo size_t).
O(n): scorre tutta la stringa fino a '\0'. Non confondere con sizeof(s) (dimensione totale dell’array)!
strcpy(dest, src)
Copia la stringa src (incluso '\0') dentro dest.
dest deve essere abbastanza capiente! (Versione limitata: strncpy).
strcat(dest, src)
Concatena (appende) src in fondo a dest, sovrascrivendo il vecchio '\0' di dest.
dest deve avere spazio libero sufficiente per strlen(dest) + strlen(src) + 1!
strcmp(s1, s2)
Confronta lessicograficamente s1 e s2: restituisce 0 se sono UGUALI, < 0 se s1 precede s2 in ordine ASCII, > 0 se s1 segue s2.
Attenzione: strcmp(s1, s2) == 0 significa che le stringhe sono uguali!
Implementazioni manuali da conoscere a memoria per l’esame:
/* 1. Calcolo manuale della lunghezza (come strlen) */int lunghezza = 0;while (s[lunghezza] != '\0') { lunghezza++;}/* 2. Copia manuale di src in dest (come strcpy) */int i = 0;while (src[i] != '\0') { dest[i] = src[i]; i++;}dest[i] = '\0'; /* FONDAMENTALE: non dimenticare mai di copiare il terminatore '\0'! *//* 3. Confronto lessicografico manuale (come strcmp) */int k = 0;while (s1[k] != '\0' && s1[k] == s2[k]) { k++;}int diff = (unsigned char)s1[k] - (unsigned char)s2[k]; /* 0 se uguali, <0 o >0 altrimenti */
Capacità del buffer e lettura di righe al limite
Con un buffer char riga[5], fgets può salvare al massimo quattro caratteri più '\0'. Premendo solo Invio si legge "\n". Tolto il fine riga, si ottiene la stringa vuota. Se il buffer non contiene '\n', il testo può essere lungo esattamente quattro caratteri o essere più lungo. Per input testuale senza NUL, leggiamo il carattere successivo con fgetc in un int. Un '\n' o una fine regolare del file completa la riga. Un altro carattere indica una riga troppo lunga. Se vogliamo proseguire, scartiamo il resto fino a '\n' o EOF. Con EOF controlliamo anche ferror.
Funzioni con un limite
strncpy(dest, src, n) scrive fino a n caratteri di sorgente, riempie di zeri se la sorgente è più corta di n e può lasciare il risultato senza terminatore. strncat(dest, src, n) aggiunge fino a n caratteri più il terminatore. Il limite riguarda i caratteri da aggiungere, quindi la capacità richiesta è almeno strlen(dest) + min(n, strlen(src)) + 1 e dest deve già contenere una stringa valida.
Per confrontare due stringhe con strcmp si controlla il segno del risultato. Il valore positivo o negativo esatto può variare.
Esempi guidati
Esempio 1: Verifica se una stringa è Palindroma (es. "radar", "anna")
Usiamo due indici: sx che parte dal primo carattere (0) e dx che parte dall’ultimo carattere valido (len - 1), avvicinandoli verso il centro finché i caratteri coincidono.
#include <stdio.h>#include <string.h>int main(void) { char parola[] = "radar"; int len = (int)strlen(parola); int sx = 0; int dx = len - 1; int palindroma = 1; /* 1 = Vero */ while (sx < dx && palindroma == 1) { if (parola[sx] != parola[dx]) { palindroma = 0; } else { sx++; dx--; } } if (palindroma == 1) { printf("La parola \"%s\" e' PALINDROMA.\n", parola); } else { printf("La parola \"%s\" NON e' palindroma.\n", parola); } return 0;}
Esempio 2: Conteggio delle vocali e delle parole in una frase
Una parola inizia ogni volta che troviamo un carattere diverso dallo spazio che è preceduto da uno spazio (o si trova all’inizio della stringa).
#include <stdio.h>int main(void) { char frase[] = "Il linguaggio C e' potente"; int vocali = 0; int parole = 0; int dentro_parola = 0; /* Flag: 0 = siamo sugli spazi, 1 = siamo dentro una parola */ for (int i = 0; frase[i] != '\0'; i++) { char c = frase[i]; /* Conteggio vocali (minuscole e maiuscole) */ if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U') { vocali++; } /* Conteggio parole (automa a 2 stati!) */ if (c != ' ' && c != '\t' && c != '\n') { if (dentro_parola == 0) { parole++; /* Inizio di una nuova parola! */ dentro_parola = 1; } } else { dentro_parola = 0; /* Usciti dalla parola */ } } printf("Frase: \"%s\"\nVocali: %d | Parole: %d\n", frase, vocali, parole); return 0;}
Errori frequenti
Errori da evitare
Confrontare due stringhe con if (s1 == s2) invece di if (strcmp(s1, s2) == 0)
Scrivere if (s1 == s2)non confronta i caratteri delle due stringhe, ma confronta i due indirizzi di memoria&s1[0] e &s2[0]! Due array distinti char s1[] = "ciao"; char s2[] = "ciao"; hanno indirizzi diversi in RAM, quindi s1 == s2 è SEMPRE FALSO (0)!
Dimenticare di allocare il byte per '\0' (char s[4] = "ciao";)
La parola "ciao" ha 4 lettere ma richiede 5 byte. Dichiarare char s[4] non lascia spazio per il terminatore '\0', rendendo s una non-stringa.
Confondere sizeof(s) con strlen(s)
Se dichiariamo char s[100] = "re";:
sizeof(s) vale 100 (la capienza totale in byte dell’array allocato).
strlen(s) vale 2 (il numero di caratteri prima di '\0').
Dimenticare di copiare dest[i] = '\0'; alla fine di una copia o costruzione manuale di stringa
Quando costruite una stringa carattere per carattere in un ciclo, dovete sempre chiuderla manualmente scrivendo '\0' nella cella immediatamente successiva all’ultimo carattere!
Esercizi di prova
Esercizio 1. strlen vs sizeof e troncamento con '\0' (Base)
Senza eseguire il codice, determina cosa stampa la seguente printf:
Inserendo testo[4] = '\0', abbiamo posizionato un terminatore nullo all’indice 4 (subito dopo 'P', 'r', 'o', 'g').
Tutte le funzioni sulle stringhe si fermano al primo'\0' che incontrano!
Pertanto l’output è: Stringa: Prog | strlen: 4 | sizeof: 20 (Nota che sizeof(testo) resta 20 perché misura la dimensione fissa del vettore allocato in memoria).
Esercizio 2. Concatenazione manuale di due stringhe (senza strcat (Base)
Date due stringhe char s1[50] = "Buon"; e char s2[] = "giorno";, scrivi i cicli C per appendere i caratteri di s2 in fondo a s1 (incluso '\0') senza usare <string.h>.
Soluzione
#include <stdio.h>int main(void) { char s1[50] = "Buon"; char s2[] = "giorno"; /* Passo 1: troviamo l'indice i del terminatore '\0' di s1 */ int i = 0; while (s1[i] != '\0') { i++; } /* Passo 2: copiamo i caratteri di s2 a partire da s1[i] */ int j = 0; while (s2[j] != '\0') { s1[i] = s2[j]; i++; j++; } s1[i] = '\0'; /* Passo 3: chiudiamo la stringa concatenata con '\0'! */ printf("Risultato: %s\n", s1); /* Stampa: Buongiorno */ return 0;}
Esercizio 3. Conversione di una stringa numerica in intero (implementazione di atoi (Intermedio)
Data una stringa contenente solo cifre decimali, ad esempio char str[] = "4096";, scrivi un programma C che calcoli il valore numerico intero corrispondente (int valore = 4096) scorrendo i caratteri della stringa. (Suggerimento: il valore numerico di un carattere cifra c è c - '0').
Soluzione
#include <stdio.h>int main(void) { char str[] = "4096"; int valore = 0; for (int i = 0; str[i] != '\0'; i++) { if (str[i] >= '0' && str[i] <= '9') { int cifra = str[i] - '0'; valore = valore * 10 + cifra; } } printf("Valore intero calcolato: %d (doppio = %d)\n", valore, valore * 2); return 0;}
Esercizio 4. Rimozione di tutti gli spazi da una stringa in-place (Intermedio)
Scrivi un programma C che, data una stringa modificabile char s[] = " C i a o M o n d o ! ";, elimini tutti gli spazi ' ' compattando i caratteri rimanenti direttamente dentro s (senza usare un secondo array) ottenendo "CiaoMondo!".
Soluzione
Usiamo la tecnica dei due indici (lettura che scorre tutta la stringa e scrittura che avanza solo quando copia un carattere non spazio):
#include <stdio.h>int main(void) { char s[] = " C i a o M o n d o ! "; int scrittura = 0; for (int lettura = 0; s[lettura] != '\0'; lettura++) { if (s[lettura] != ' ') { s[scrittura] = s[lettura]; scrittura++; } } s[scrittura] = '\0'; /* Chiude la stringa compattata */ printf("Stringa compattata: \"%s\"\n", s); /* "CiaoMondo!" */ return 0;}
Esercizio 5. Cifrario di Cesare su stringhe (Avanzato)
Il Cifrario di Cesare sostituisce ogni lettera minuscola 'a'..'z' con la lettera che si trova k posizioni più avanti nell’alfabeto di 26 lettere, ricominciando da 'a' dopo la 'z' (aritmetica modulare (mod26)).
Scrivi un programma C che cifri la stringa char msg[] = "attacco all alba"; con chiave k = 3 lasciando inalterati gli spazi.
Soluzione
Per una lettera minuscola c, la sua posizione nell’alfabeto (0..25) è c - 'a'. Aggiungiamo k, calcoliamo il resto % 26 e risommiamo 'a':
#include <stdio.h>int main(void) { char msg[] = "attacco all alba"; int k = 3; for (int i = 0; msg[i] != '\0'; i++) { if (msg[i] >= 'a' && msg[i] <= 'z') { msg[i] = (char)('a' + (msg[i] - 'a' + k) % 26); } } printf("Messaggio cifrato: \"%s\"\n", msg); /* "dwwdffr doo doed" */ return 0;}
Esercizio 6. Ricerca di una sottostringa dentro una stringa (implementazione di strstr (Avanzato)
Date due stringhe testo e pattern, scrivi un algoritmo C strutturato (senza usare strstr di <string.h> e senza usare break) che trovi il primo indice pos in cui pattern compare per intero dentro testo (oppure pos = -1 se non compare).
Soluzione
#include <stdio.h>int main(void) { char testo[] = "programmazione in linguaggio C"; char pattern[] = "guaggio"; int pos = -1; int i = 0; while (testo[i] != '\0' && pos == -1) { int j = 0; /* Confronta carattere per carattere a partire da testo[i + j] */ while (pattern[j] != '\0' && testo[i + j] == pattern[j]) { j++; } /* Se abbiamo raggiunto la fine di pattern, tutti i caratteri coincidevano! */ if (pattern[j] == '\0') { pos = i; } else { i++; } } printf("Posizione trovata: %d\n", pos); /* Stampa 18 */ return 0;}
Provenienza del materiale
Slide e dispensa ufficiale del corso: C1PROG1U2L6_Stringhe.pdf (Unità 2, Lezione 6 — Rappresentazione e manipolazione delle stringhe in linguaggio C).
Marco Anisetti, Introduzione alla Programmazione in Linguaggio C, Appunti_di_fine_Unità_2.pdf, cap. 4.