{"id":7396,"date":"2011-08-03T12:27:15","date_gmt":"2011-08-03T10:27:15","guid":{"rendered":"http:\/\/www.devapp.it\/wordpress\/?p=7396"},"modified":"2011-10-05T12:27:23","modified_gmt":"2011-10-05T10:27:23","slug":"16-stringhe-o-array-di-caratteri","status":"publish","type":"post","link":"https:\/\/www.devapp.it\/wordpress\/16-stringhe-o-array-di-caratteri\/","title":{"rendered":"16. Stringhe o array di caratteri?"},"content":{"rendered":"

\"corso-completo-c-stringhe-o-array-di-caratteri-00\"<\/a> Ed eccoci nuovamente qui per parlare di programmazione C. Purtroppo gli impegni lavorativi mi hanno costretto a prendere una (lunga) pausa ed il corso \u00e8 stato fermo per un p\u00f2 ma appena sono riuscito a ritagliarmi un p\u00f2 di tempo libero eccomi qui, pronto a chiacchierare insieme a voi del pi\u00f9 bel linguaggio di programmazione del mondo, quindi… prendete pure una sedia che stiamo per iniziare \ud83d\ude42<\/p>\n

L’argomento della lezione di oggi \u00e8 la gestione delle stringhe di testo.<\/p>\n

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

Ma come mai una cosa tanto semplice richiede un’intera lezione di un corso C? E per di pi\u00f9 la lezione numero 16 dopo aver parlato di argomenti pi\u00f9 complessi come strutture, array e allocazione dinamica della memoria? La risposta \u00e8 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<\/strong>.<\/p>\n

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\u00f9 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.<\/p>\n

\r\nstring a = \"Ciao \"\r\nstring b = \"mondo\"\r\nstring c = a + b; \r\n<\/pre>\n
Ed in C? In C visto che non esiste un tipo predefinito “stringa” bisogna arrangiarci con quello che abbiamo: le variabili di tipo char<\/em> e gli array<\/em>… infatti si dice che in C le stringhe sono definite come array di caratteri. Questa frase va scolpita indelebilmente nelle nostre menti:<\/p>\n
“le stringhe non esistono, esistono gli array di caratteri”<\/p>\n
perch\u00e9 la consapevolezza di questo limite ci far\u00e0 risparmiare errori grossolani nella stesura dei nostri programmi.<\/p>\n
A questo punto la lezione potrebbe concludersi qui perch\u00e9 gli array li abbiamo gi\u00e0 visti, le variabili di tipo “char” anche… quindi cos’altro aggiungere? Come vedremo ci sono alcune particolarit\u00e0 che meritano di essere approfondite; inoltre non si pu\u00f2 prescidere da un’analisi della libreria  che fa parte della libreria standard del C e permette di effettuare le pi\u00f9 comuni operazioni su questi array di char<\/em>.<\/p>\n
La dichiarazione<\/h4>\n
Dichiarare un array di caratteri \u00e8 semplice e segue la stessa sintassi che abbiamo gi\u00e0 visto:<\/p>\n
\r\nchar *nomeVariabile; \/\/allocazione dinamica della memoria\r\nchar nomeVariabile[100]; \/\/allocazione statica.\r\n<\/pre>\n
Nella prima riga abbiamo dichiarato un singolo puntatore a char, quindi sar\u00e0 necessario passare dalle funzioni malloc\/calloc per utilizzarlo, mentre nel secondo caso abbiamo dichiarato un array statico di dimensione 100.<\/p>\n
L’inizializzazione<\/h4>\n
Se avete letto gi\u00e0 quache pagina sul linguaggio C avrete sicuramente letto che “le stringhe vanno terminate con il carattere ” ” ma in pochi forse spiegano il perch\u00e9… quindi partiamo dall’inizio…<\/p>\n
Abbiamo detto che una stringa \u00e8 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’\u00e8 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 \u00e8 finito… ad esempio potremmo inserire in un array di interi positivi il valore -1 in ultima posizione cos\u00ec che la funzione che si trovi ad analizzare questo array possa riconoscere autonomamente e senza ulteriori parametri quando l’array \u00e8 terminato.<\/p>\n
Questo secondo approccio \u00e8 quello che si \u00e8 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.<\/p>\n
Allora come si inizializzano le stringhe?<\/p>\n
Si pu\u00f2 usare la stessa sintassi usata per inizializzare gli array (solo in fase di dichiarazione) che \u00e8 questa:<\/p>\n
\r\nchar variabile[5] = {'c','i','a','0',''};\r\n<\/pre>\n
Notare che abbiamo dichiarato un’array di dimensione 5 anche se la stringa da memorizzare \u00e8 composta da soli 4 caratteri, giusto per fare spazio al terminatore di stringa.<\/p>\n
Per questa sintassi esiste una versione  ridotta che \u00e8 la seguente:<\/p>\n
\r\nchar variabile[5] = \"ciao\"; \/\/oppure\r\nchar variabile[] = \"ciao\";\r\n<\/pre>\n
notare che in questo caso non abbiamo inserito il carattere ‘  ‘ perch\u00e9 lo fa automaticamente il linguaggio per noi.<\/p>\n
NOTA:<\/strong> Le stringhe racchiuse tra doppi apici sono dette “string literals” e possono essere utilizzate laddove dal codice viene richiesto un array di caratteri.<\/p>\n
“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\u00e0 inizializzata?”<\/p>\n
Ottima domanda, grazie per averla fatta \ud83d\ude09 la risposta \u00e8 “dobbiamo ricorrere alle funzioni della libreria string.h”<\/p>\n
String.h<\/h4>\n
Prima di vedere qualche esempio dell’uso della libreria “string.h” una breve nota, \u00e8 possibile stampare a schermo una stringa utilizzando il carattere ” %s” come in questo esempio:<\/p>\n
\r\nchar prova[] = \"Ciao mondo\";\r\nprintf(\" La stringa \u00e8: %s\", prova);\r\n<\/pre>\n
strlen<\/h5>\n
size_t strlen(const char *s);<\/strong><\/p>\n
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.<\/p>\n
Esempio:<\/p>\n
\r\nchar string1[] = \"abc\";\r\nint len = strlen(string1);\r\nprintf(\"La lunghezza \u00e8: %d\\n\", len);\r\n<\/pre>\n
strcpy<\/h5>\n
char *strcpy(char *s1, const char *s2);<\/strong><\/p>\n
Copia la stringa s2 nella stringa s1, incluso il carattere di terminazione .<\/p>\n
Pu\u00f2 essere utilizzato per modificare il valore di una stringa dopo la sua dichiarazione, come in questo esempio:<\/p>\n
Esempio:<\/p>\n
\r\nchar string1[] = \"Hello, world!\";\r\nchar string2[20];\r\nstrcpy(string2, string1);\r\n<\/pre>\n
strcmp<\/h5>\n
int strcmp(const char *s1, const char *s2);<\/strong><\/p>\n
Confronta la stringa s1 con s2.<\/p>\n
Viene utilizzata per effettuare il confronto lessicografico tra le stringhe, restituisce un valore 1 viceversa. Restituisce 0 se le due stringhe sono uguali.<\/p>\n
Esempio:<\/p>\n
\r\nchar string3[] = \"Ciao\";\r\nchar string4[] = \"DevAPP\";\r\n\r\nif(strcmp(string3, string4) == 0)\r\n   printf(\"strings are equal\\n\");\r\nelse\r\n   printf(\"strings are different\\n\");\r\n<\/pre>\n
strcat<\/h5>\n
char *strcat(char *dest, const char *src);<\/strong><\/p>\n
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.<\/p>\n
Attenzione:<\/strong> la stringa deve quindi avere spazio vuoto a sufficienza per contenere la seconda stringa.<\/p>\n
Esempio:<\/p>\n
\r\nchar string1[20] = \"Hello, \";\r\nchar string2[] = \"world!\";\r\n\r\nprintf(\"%s\\n\", string1);\r\nstrcat(string1, string2);\r\nprintf(\"%s\\n\", string1);\r\n<\/pre>\n
Errori comuni<\/h4>\n
Ci sono alcuni errori che \u00e8 facile commettere lavorando con le stringhe in C e che risultano essere piuttosto insidiosi poich\u00e9 non vengono rilevati dal compilatore… senza nessuna pretesa di completezza eccone alcuni:<\/p>\n
Errore 1<\/strong><\/p>\n
\r\nchar variabile[4] = \"ciao\";\r\n<\/pre>\n
Questo codice \u00e8 errato perch\u00e9 non alloca lo spazio necessario per il terminatore di stringa, con un risultato imprevedibile.<\/p>\n
Soluzione:<\/strong><\/p>\n
\r\nchar variabile[5] = \"ciao\";\r\n<\/pre>\n
Errore 2<\/strong><\/p>\n
\r\nchar variabile1[5] = \"ciao\";\r\nchar *variabile2;\r\n\r\nvariabile2 = variabile1;\r\n\r\nprintf(\"indirizzo: %x \",variabile1);\r\nprintf(\"indirizzo: %x \",variabile2);\r\n<\/pre>\n
Questo non \u00e8 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\u00e9 questo codice assegna (come si vede dal printf) lo stesso indirizzo di memoria alle due variabili, quindi praticamente sono la stessa variabile<\/p>\n
Soluzione:<\/strong><\/p>\n
\r\nchar variabile1[5] = \"ciao\";\r\nchar *variabile2;\r\n\r\nvariabile2 = malloc(5 * sizeof(char));\r\nstrcpy(variabile2, variabile1);\r\n<\/pre>\n
Errore 3<\/strong><\/p>\n
\r\nchar *variabile2;\r\nvariabile2 = \"Ciao mondo\";\r\n\r\n\/\/oppure\r\n\r\nvariabile2 = malloc(11 * sizeof(char));\r\nvariabile2 = \"Ciao mondo\";\r\n<\/pre>\n
Questo errore \u00e8 piuttosto comune e particolarmente insidioso, se provate a compilarlo non vi dar\u00e0 errori e probabilmente sembrer\u00e0 anche funzionare, ma \u00e8 profondamente errato perch\u00e9 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\u00e9 temporaneo non possiamo fare affidamento a questo indirizzo, ma dobbiamo necessariamente copiare il contenuto della stringa in un array di cui siamo proprietari.<\/p>\n
Soluzione:<\/strong><\/p>\n
\r\nvariabile2 = malloc(11 * sizeof(char));\r\nstrcpy(variabile2, \"Ciao mondo\");\r\n<\/pre>\n
Errore 4<\/strong><\/p>\n
\r\nchar variabile1[5] = \"ciao\";\r\nchar variabile2[6] = \"mondo\";\r\n\r\nprintf(\" %s\", variabile1 + variabile2);\r\n<\/pre>\n
Questo errore viene commesso dai programmatori java e python \ud83d\ude42 la concatenazione di due stringhe non si fa con il ” + ” ma con l’operatore strcat<\/em> e bisogna sempre verificare che sulla destinazione ci sia spazio a sufficienza.<\/p>\n
Soluzione:<\/strong><\/p>\n
\r\nchar string1[20] = \"Hello, \";\r\nchar string2[] = \"world!\";\r\n\r\nprintf(\"%s\\n\", string1);\r\nstrcat(string1, string2);\r\nprintf(\"%s\\n\", string1);\r\n<\/pre>\n
Errore 5<\/strong><\/p>\n
\r\nchar variabile1[6] = \"abaco\";\r\nchar variabile2[4] = \"zoo\";\r\n\r\nif (variabile1 < variabile2 ){\r\n    printf("La prima parola \u00e8 minore della seconda");\r\n}\r\n<\/pre>\n
L’operatore ” < " non effettua il confronto tra stringhe, ma sul valore dei puntatori quindi non vi dar\u00e0 errore e sembrer\u00e0 funzionare in modo arbitrario<\/p>\n
Soluzione:<\/strong><\/p>\n
\r\nchar string1[] = \"abaco\";\r\nchar string2[] = \"zoo\";\r\n\r\nif(strcmp(string1, string2) < 0)\r\n   printf("La prima parola \u00e8 minore della seconda");\r\n<\/pre>\n
E con questo \u00e8 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!<\/p>\n
bye^2
\nIgnazioC<\/p>\n
Letture consigliate:<\/h4>\n
\"C-Corso-Completo-di-Programmazione-kernighan-ritchie-devAPP\"<\/a> Il linguaggio C. Principi di programmazione e manuale di riferimento (Accademica) <\/strong><\/a>
\nBrian W. Kernighan – Dennis M. Ritchie<\/em>
\nEditore:<\/strong> Pearson | Lingua:<\/strong> Italiano | Brossura:<\/strong> 313 pagine
\nPrezzo Listino:<\/strong> EUR 27,00<\/del>
\nPrezzo Promozione:<\/strong> EUR 22,95 con Spedizione gratuita<\/p>\n
\"C-Corso-Completo-di-Programmazione-Deitel-Deitel-devAPP\"<\/a> C. Corso completo di programmazione<\/strong><\/a>
\nPaul J. Deitel – Harvey M. Deitel<\/em>
\nEditore:<\/strong> Apogeo | Lingua:<\/strong> Italiano | Brossura:<\/strong> 640 pagine
\nPrezzo Listino:<\/strong> EUR 39,00<\/del>
\nPrezzo Promozione:<\/strong> EUR 33,15 con Spedizione gratuita<\/p>\n
\"\"<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Ed eccoci nuovamente qui per parlare di programmazione C. Purtroppo gli impegni lavorativi mi hanno costretto a…<\/p>\n","protected":false},"author":53,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[569],"tags":[859,593,588,865,724,723,241,864,863,862,860,858,861],"class_list":["post-7396","post","type-post","status-publish","format-standard","hentry","category-corso-completo-di-c","tag-array-caratteri-c","tag-corso-completo-di-c-2","tag-corso-di-c","tag-errori-comuni-stringhe-c","tag-esempi-codice-programmazione-c","tag-esercizi-programmazione-c","tag-ignazio-calo","tag-strcat-c","tag-strcmp-c","tag-strcpy-c","tag-string-h-c","tag-stringhe-in-c","tag-strlen-c"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/7396","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/users\/53"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/comments?post=7396"}],"version-history":[{"count":9,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/7396\/revisions"}],"predecessor-version":[{"id":7820,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/7396\/revisions\/7820"}],"wp:attachment":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/media?parent=7396"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/categories?post=7396"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/tags?post=7396"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}