Ed eccoci nuovamente qui per parlare di programmazione C. Purtroppo gli impegni lavorativi mi hanno costretto a prendere una (lunga) pausa ed il corso è stato fermo per un pò ma appena sono riuscito a ritagliarmi un pò di tempo libero eccomi qui, pronto a chiacchierare insieme a voi del più bel linguaggio di programmazione del mondo, quindi… prendete pure una sedia che stiamo per iniziare 🙂

L’argomento della lezione di oggi è la gestione delle stringhe di testo.

Ma cos’è esattamente una stringa? Senza perderci in definizioni matematiche e formali (per questo c’è wikipedia: link) possiamo dire che una stringa è una sequenza di caratteri alfabetici e non, come ad esempio “Ciao mondo” o anche “(3 + 5)” oppure ” # ± % “.

Ma come mai una cosa tanto semplice richiede un’intera lezione di un corso C? E per di più la lezione numero 16 dopo aver parlato di argomenti più complessi come strutture, array e allocazione dinamica della memoria? La risposta è che nulla di quanto abbiamo trattato fino ad ora poteva essere tralasciato per capire le stringhe; e questo per un semplice dato di fatto: Il C non ha il tipo di dato stringa.

In (credo) qualsiasi altro linguaggio di programmazione, se serve una stringa, basta dichiarare la variabile del tipo corretto ed assegnarle il valore, inoltre sono previsti tutti i metodi più elementari per la gestione delle stesse. Questo potrebbe essere un pezzo di codice sorgente in un linguaggio di alto livello che preveda la gestione delle stringhe.

string a = "Ciao "
string b = "mondo"
string c = a + b; 

Ed in C? In C visto che non esiste un tipo predefinito “stringa” bisogna arrangiarci con quello che abbiamo: le variabili di tipo char e gli array… infatti si dice che in C le stringhe sono definite come array di caratteri. Questa frase va scolpita indelebilmente nelle nostre menti:

“le stringhe non esistono, esistono gli array di caratteri”

perché la consapevolezza di questo limite ci farà risparmiare errori grossolani nella stesura dei nostri programmi.

A questo punto la lezione potrebbe concludersi qui perché gli array li abbiamo già visti, le variabili di tipo “char” anche… quindi cos’altro aggiungere? Come vedremo ci sono alcune particolarità che meritano di essere approfondite; inoltre non si può prescidere da un’analisi della libreria che fa parte della libreria standard del C e permette di effettuare le più comuni operazioni su questi array di char.

La dichiarazione

Dichiarare un array di caratteri è semplice e segue la stessa sintassi che abbiamo già visto:

char *nomeVariabile; //allocazione dinamica della memoria
char nomeVariabile[100]; //allocazione statica.

Nella prima riga abbiamo dichiarato un singolo puntatore a char, quindi sarà necessario passare dalle funzioni malloc/calloc per utilizzarlo, mentre nel secondo caso abbiamo dichiarato un array statico di dimensione 100.

L’inizializzazione

Se avete letto già quache pagina sul linguaggio C avrete sicuramente letto che “le stringhe vanno terminate con il carattere ” ” ma in pochi forse spiegano il perché… quindi partiamo dall’inizio…

Abbiamo detto che una stringa è un array di caratteri e se avete svolto qualche esercizio tra quelli proposti che riguardano gli array vi sarete resi conto che quando una funzione accetta come parametro un array non c’è verso di sapere la lunghezza dell’array che le viene passato… infatti molto spesso si sopperisce a questa mancanza accettando due parametri separati, un array ed un intero che rappresenta la taglia… vi suona familiare? Beh, in effetti ci sarebbe anche un secondo metodo… quello di usare un “marcatore” per indicare che l’array è finito… ad esempio potremmo inserire in un array di interi positivi il valore -1 in ultima posizione così che la funzione che si trovi ad analizzare questo array possa riconoscere autonomamente e senza ulteriori parametri quando l’array è terminato.

Questo secondo approccio è quello che si è scelto di utilizzare per le stringhe, utilizzando come marcatore di fine stringa il carattere ‘Null’ (codice ascii: 0 rappresentazione: ‘ ‘ non ha nulla a che vedere con il NULL POINTER) quindi, anche se non tecnicamente necessario, ricordatevi di inserire questo carattere alla fine della stringa.

Allora come si inizializzano le stringhe?

Si può usare la stessa sintassi usata per inizializzare gli array (solo in fase di dichiarazione) che è questa:

char variabile[5] = {'c','i','a','0',''};

Notare che abbiamo dichiarato un’array di dimensione 5 anche se la stringa da memorizzare è composta da soli 4 caratteri, giusto per fare spazio al terminatore di stringa.

Per questa sintassi esiste una versione ridotta che è la seguente:

char variabile[5] = "ciao"; //oppure
char variabile[] = "ciao";

notare che in questo caso non abbiamo inserito il carattere ‘ ‘ perché lo fa automaticamente il linguaggio per noi.

NOTA: Le stringhe racchiuse tra doppi apici sono dette “string literals” e possono essere utilizzate laddove dal codice viene richiesto un array di caratteri.

“Ok, ma questi due modi di inizializzare le stringhe vanno bene solo per l’allocazione statica e soprattutto come faccio ad assegnare un nuovo valore ad una variabile già inizializzata?”

Ottima domanda, grazie per averla fatta 😉 la risposta è “dobbiamo ricorrere alle funzioni della libreria string.h”

String.h

Prima di vedere qualche esempio dell’uso della libreria “string.h” una breve nota, è possibile stampare a schermo una stringa utilizzando il carattere ” %s” come in questo esempio:

char prova[] = "Ciao mondo";
printf(" La stringa è: %s", prova);

strlen

size_t strlen(const char *s);

Restituisce la lunghezza della stringa s. La lunghezza viene considerata fino al primo carattere ‘ ‘ trovato quindi prima di usare questa funzione assicuratevi di avere correttamente inserito il terminatore di stringa.

Esempio:

char string1[] = "abc";
int len = strlen(string1);
printf("La lunghezza è: %d\n", len);

strcpy

char *strcpy(char *s1, const char *s2);

Copia la stringa s2 nella stringa s1, incluso il carattere di terminazione .

Può essere utilizzato per modificare il valore di una stringa dopo la sua dichiarazione, come in questo esempio:

Esempio:

char string1[] = "Hello, world!";
char string2[20];
strcpy(string2, string1);

strcmp

int strcmp(const char *s1, const char *s2);

Confronta la stringa s1 con s2.

Viene utilizzata per effettuare il confronto lessicografico tra le stringhe, restituisce un valore 1 viceversa. Restituisce 0 se le due stringhe sono uguali.

Esempio:

char string3[] = "Ciao";
char string4[] = "DevAPP";

if(strcmp(string3, string4) == 0)
   printf("strings are equal\n");
else
   printf("strings are different\n");

strcat

char *strcat(char *dest, const char *src);

Concatena src alla stringa dest. A differenza di quanto avviene con altri linguaggi non viene restituita una nuova stringa contenete la concatenazione delle due, ma la destinazione viene effettivamente modificata.

Attenzione: la stringa deve quindi avere spazio vuoto a sufficienza per contenere la seconda stringa.

Esempio:

char string1[20] = "Hello, ";
char string2[] = "world!";

printf("%s\n", string1);
strcat(string1, string2);
printf("%s\n", string1);

Errori comuni

Ci sono alcuni errori che è facile commettere lavorando con le stringhe in C e che risultano essere piuttosto insidiosi poiché non vengono rilevati dal compilatore… senza nessuna pretesa di completezza eccone alcuni:

Errore 1

char variabile[4] = "ciao";

Questo codice è errato perché non alloca lo spazio necessario per il terminatore di stringa, con un risultato imprevedibile.

Soluzione:

char variabile[5] = "ciao";

Errore 2

char variabile1[5] = "ciao";
char *variabile2;

variabile2 = variabile1;

printf("indirizzo: %x ",variabile1);
printf("indirizzo: %x ",variabile2);

Questo non è propriamente un errore, a patto che si sappia veramente quello che si sta facendo. Se crediamo di aver creato una copia di variabile1 memorizzata in variabile2 abbiamo commesso un errore perché questo codice assegna (come si vede dal printf) lo stesso indirizzo di memoria alle due variabili, quindi praticamente sono la stessa variabile

Soluzione:

char variabile1[5] = "ciao";
char *variabile2;

variabile2 = malloc(5 * sizeof(char));
strcpy(variabile2, variabile1);

Errore 3

char *variabile2;
variabile2 = "Ciao mondo";

//oppure

variabile2 = malloc(11 * sizeof(char));
variabile2 = "Ciao mondo";

Questo errore è piuttosto comune e particolarmente insidioso, se provate a compilarlo non vi darà errori e probabilmente sembrerà anche funzionare, ma è profondamente errato perché la riga variabile2 = “Ciao mondo”, che sia preceduta da malloc o meno, sta assegnando al puntatore variabile2 un indirizzo di memoria temporaneo, l’indirizzo creato per noi dal compilatore che contiene la stringa “Ciao mondo”. Proprio perché temporaneo non possiamo fare affidamento a questo indirizzo, ma dobbiamo necessariamente copiare il contenuto della stringa in un array di cui siamo proprietari.

Soluzione:

variabile2 = malloc(11 * sizeof(char));
strcpy(variabile2, "Ciao mondo");

Errore 4

char variabile1[5] = "ciao";
char variabile2[6] = "mondo";

printf(" %s", variabile1 + variabile2);

Questo errore viene commesso dai programmatori java e python 🙂 la concatenazione di due stringhe non si fa con il ” + ” ma con l’operatore strcat e bisogna sempre verificare che sulla destinazione ci sia spazio a sufficienza.

Soluzione:

char string1[20] = "Hello, ";
char string2[] = "world!";

printf("%s\n", string1);
strcat(string1, string2);
printf("%s\n", string1);

Errore 5

char variabile1[6] = "abaco";
char variabile2[4] = "zoo";

if (variabile1 < variabile2 ){
    printf("La prima parola è minore della seconda");
}

L’operatore ” < " non effettua il confronto tra stringhe, ma sul valore dei puntatori quindi non vi darà errore e sembrerà funzionare in modo arbitrario

Soluzione:

char string1[] = "abaco";
char string2[] = "zoo";

if(strcmp(string1, string2) < 0)
   printf("La prima parola è minore della seconda");

E con questo è veramente tutto sull’argomento, non mi resta che consigliarvi una lettura attenta di tutte le pagine di man relative alla libreria string.h e augurarvi buona programmazione!

bye^2
IgnazioC

Letture consigliate:

Il linguaggio C. Principi di programmazione e manuale di riferimento (Accademica)
Brian W. Kernighan – Dennis M. Ritchie
Editore: Pearson | Lingua: Italiano | Brossura: 313 pagine
Prezzo Listino: EUR 27,00
Prezzo Promozione: EUR 22,95 con Spedizione gratuita

C. Corso completo di programmazione
Paul J. Deitel – Harvey M. Deitel
Editore: Apogeo | Lingua: Italiano | Brossura: 640 pagine
Prezzo Listino: EUR 39,00
Prezzo Promozione: EUR 33,15 con Spedizione gratuita