Lezioni di programmazione in c le stringhe By Cristian Randieri - www.intellisystem.it

LEZIONI DI
PROGRAMMAZIONE IN
“Le stringhe”
Ing. Cristian Randieri
Università degli Studi di Catania
Istituto Nazionale di Fisica Nucleare (INFN)

Ing. Cristian Randieri – Lezioni di programmazione in C: ”Le stringhe”
Introduzione
In C non esiste un vero e proprio
tipo di dato “Stringa”.
Le stringhe sono gestite dal
compilatore come sequenze di
caratteri, cioè di dati di tipo char.
Esistono due metodi comunemente
utilizzati per dichiarare e
manipolare stringhe nei programmi
ovvero mediante l’uso:
 degli array;
 dei puntatori.

Le stringhe e gli array
In C uno degli utilizzi degli array ad una
dimensione riguarda la conservazione in
memoria di stringhe di caratteri: queste in C
sono array di tipo carattere la cui fine è
segnalata da un carattere null (carattere
terminatore), indicato come '0'.
Il carattere null è il primo codice ASCII
corrispondente al valore binario 00000000 e
non ha niente a che vedere con il carattere 0
che ha, in ASCII, codice binario 00110000.

Esempio
char a[10];
dichiara un vettore costituito da un massimo di
dieci caratteri e:
char frase[] = "Oggi c'è il sole";
dichiara l'array monodimensionale frase il cui
numero di caratteri è determinato dalla
quantità di caratteri presenti fra doppi apici più
uno (il carattere null che chiude la stringa).

Assegnazione di valori
È importante notare la differenza tra le due
assegnazioni:
char a = 'r';
char b[] = "r";
Nel primo caso viene assegnato il solo carattere
r, nel secondo la stringa r0. In definitiva: se
si vuole fare riferimento ad un solo carattere,
questo deve essere racchiuso fra apici singoli;
se, invece, si vuole fare riferimento ad una
stringa, occorre racchiuderla fra doppi apici.

Funzioni per il trattamento
delle stringhe
Nonostante il linguaggio C non
possieda un dato di tipo stringa, sono
disponibili parecchie funzioni specifiche
per il trattamento di quest’ultime:
 gets e puts
 strcpy
 strcat, strlen e strcmp

Funzioni “gets” e “puts”
Le funzioni gets e puts sono funzioni specializzate
nell'input e output di una stringa. Il programma
seguente riceve in input una stringa e, subito dopo,
la rimanda in output.
Notare che in queste istruzioni si fa riferimento alla
stringa nel suo complesso e, quindi, viene utilizzato
il nome:
#include <stdio.h>
main() {
char s[80]; /* dichiara la stringa */
gets(s); /* riceve l'input */
puts(s); /* fornisce l'output */
}

Altre funzioni per il trattamento delle stringhe
sono disponibili, per usi particolari, a patto che
si includa nel programma la libreria delle
funzioni “string” mediante la seguente
istruzione:
#include <string.h>

Funzione “strcpy”
Questa funzione copia una stringa in un'altra.
Può essere utilizzata, per esempio, per
assegnare un valore a una stringa. La sua
sintassi è:
strcpy(s1,s2);
Si può immaginare che tale funzione equivale,
come effetto, all'assegnamento nelle variabili
di altro tipo (in altri termini è come se si
scrivesse: s1=s2) assegna, cioè, alla stringa
s1 il valore contenuto in s2.

Funzione “strcat”
La funzione:
strcat(s1,s2);
concatena la stringa s2 alla fine della stringa s1:
strcpy(s1,"buon"); /* stringa specificata
in s1 */
strcpy(s2,"giorno"); /* lo stesso per s2
*/
strcat(s1,s2); /* s1 conterrà "buongiorno"
*/

Funzione ” strlen ”
La funzione:
strlen(s1);
restituisce un valore numerico
che rappresenta la lunghezza
della stringa s1.
Es. a=strlen (s1);

Funzione “strcmp”
La funzione:
strcmp(s1,s2);
può essere utilizzata per effettuare
comparazioni sul contenuto di due stringhe.
In particolare tale funzione:
Restituisce un valore positivo se vale s1>s2
Restituisce un valore negativo se vale s1<s2
Restituisce 0 se s1 ed s2 sono uguali

Funzione “strcmp”
Per tenere conto mnemonicamente di
tali valori, basta pensare al confronto
come ad una sottrazione: fra l’altro ciò è
non è molto distante da quello che
avviene in effetti.
Se da s1 si sottrae s2 si avrà un valore
positivo nel caso s1>s2, negativo se
s1<s2 e nullo se sono uguali.

Esempio
#include <stdio.h>
#include <string.h>
main(){
char S1[10],S2[10]; /* dichiara le
stringhe */
gets (S1);
gets (S2);
if (strcmp (S1,S2)==0)
printf("n Le parole sono uguali ");
else
printf("n Le parole sono diverse
");
}

Array di stringhe
Una applicazione interessante delle matrici è
l’array di stringhe.
La stringa è un array di caratteri e quindi
potremmo dire che un array di stringhe è un
array di array di caratteri.
Per chiarire la gestione di questo tipo di array
esaminiamo un programma che si occupa di
cercare delle parole in un vocabolario e ci dica,
per ognuna, se è contenuta nel vocabolario
stesso:

Programma esempio
/* Cerca parole in un vocabolario */
#include <stdio.h>
#include <string.h> /*1*/
main(){
char vocab[10][20], parcerc[20]; /*2*/
int i,trovata;
/* Acquisisce parole da inserire nel
vocabolario */
for (i=0;i<=9;i++) {
printf("nParola %d ",i);
gets(vocab[i]); /*3*/
}

Programma esempio
/* Acquisisce la parola da cercare */
printf("nnParola da cercare (Invio per finire)
");
gets(parcerc);
while (strcmp(parcerc,"")) { /*4*/
/* Cerca la parola */
trovata=0; /*5*/
for (i=0;i<=9;i++) {
if (!strcmp(parcerc,vocab[i])) { /*6*/
trovata=1; /*7*/
break; /*8*/
}
}

Programma esempio
if (trovata) /*9*/
printf("nParola trovata");
else
printf("nParola non trovata");
/* Prossima parola da cercare */
printf("nnParola da cercare (Invio
per finire) ");
gets(parcerc);
}
}

Descrizione
#include <string.h> /*1*/
La dichiarazione della riga 1
permette l’utilizzo all’interno
del programma delle funzioni
per il trattamento delle
stringhe.

Descrizione
char vocab[10][20], parcerc[20]; /*2*/
Nella riga 2 viene dichiarato l’array di caratteri
vocab[10][20]. Il nostro vocabolario conterrà
quindi un massimo di 10 parole ognuna composta di
un massimo di 20 caratteri. La prima parola è
contenuta in vocab[0] e con vocab[2][7],
qualora dovesse interessare, si individuerebbe
l’ottavo carattere della terza parola del vocabolario.
Ogni riga della tabella conterrà una parola e in ogni
colonna ci sono i caratteri che compongono le
parole. L’array parcerc[20] servirà per contenere
la parola da cercare.

Descrizione
gets(vocab[i]); /*3*/
Nella riga 3 si acquisiscono le parole da inserire nel
vocabolario: la prima volta l’istruzione si leggerà
gets(vocab[0]), quindi gets(vocab[1]) e infine
gets(vocab[9]) in relazione ai diversi valori assunti
dal contatore i.
L’uso di un solo indice dipende dal fatto che, con la gets,
si acquisisce una stringa e quindi nel nostro caso una
intera riga della matrice.
Se avessimo voluto acquisire le stringhe un carattere per
volta, si sarebbero dovuti gestire due cicli uno annidato
nell’altro, contenenti l’istruzione
scanf("%c",&vocab[i][j]).
Alla fine avremmo dovuto aggiungere il carattere null.

Descrizione
while (strcmp(parcerc,"")) { /*4*/
Nella riga 4 si gestisce la condizione di uscita dal ciclo.
La stringa ricevuta dall’input viene comparata con la
stringa vuota (due doppi apici consecutivi): se alla
richiesta di input della stringa da cercare si risponde
premendo solamente il tasto Invio, viene acquisita una
stringa contenente solo il carattere terminatore null.
Ciò rende falsa la condizione e quindi il ciclo ha
termine (strcmp in questo caso restituisce 0).

Descrizione
trovata=0; /*5*/
La variabile trovata che viene azzerata nella riga 5
registrerà l’eventuale ritrovamento della stringa
all’interno del vocabolario.
Il valore assegnato non ha il senso di un valore
numerico a tutti gli effetti ma il senso di un valore
logico (0 = falso, un valore non nullo=vero).
Una variabile usata in questo modo viene chiamata
solitamente variabile logica, switch o flag.

Descrizione
if (!strcmp(parcerc,vocab[i])) { /*6*/
Nella 6 si confronta la parola da
cercare via via con le parole contenute
nel vocabolario.
L’equivalenza delle due stringhe, quella
da cercare e la parola del vocabolario
esaminata, rende vera la condizione.

Descrizione
trovata=1; /*7*/
break; /*8*/
In questo caso, riga 7, si rende vera
la variabile trovata assegnandole un
valore non nullo e con la break della
riga 8 si forza l’uscita dal ciclo
poiché è inutile continuare a
confrontare la parola cercata con il
resto delle parole del vocabolario: la
ricerca viene sospesa.

Descrizione
if (trovata) /*9*/
Nella riga 9 si esegue un test sul flag trovata: se
è vero (cioè è stata eseguita l’istruzione della riga 7)
la parola è stata trovata, se è falso (è rimasto
inalterato il valore assegnato nella istruzione della
riga 5) la ricerca ha avuto esito negativo.

Le stringhe e i puntatori
Un metodo comunemente
utilizzato per dichiarare e
manipolare stringhe nei
programmi è offerto dai
puntatori.
Come si vede nel
programma dell'esempio
seguente, che visualizza
"Ciao Ciao" e porta a
capo il cursore.

Esempio
#include <stdio.h>
char *string = "Ciao";
void main(void)
{
printf(string);
printf(" %s
n",string);
}

Descrizione
La dichiarazione di string può apparire, a prima vista,
anomala.
Si tratta infatti, a tutti gli effetti, della dichiarazione di
un puntatore e la stranezza consiste nel fatto che a
questo non è assegnato un indirizzo di memoria, come
ci si potrebbe aspettare, bensì una costante stringa.
Ma è proprio questo l'artificio che consente di gestire le
stringhe con normali puntatori a carattere: il
compilatore, in realtà, assegna a string, puntatore a
16 bit, l'indirizzo della costante "Ciao".

Descrizione
Dunque la word occupata da string non contiene la
parola "Ciao", ma i 16 bit che esprimono la parte
offset del suo indirizzo.
A sua volta, "Ciao" occupa 5 byte di memoria.
Proprio 5, non si tratta di un errore di stampa: i 4 byte
necessari a memorizzare i 4 caratteri che compongono
la parola, più un byte, nel quale il compilatore
memorizza il valore binario 0, detto terminatore di
stringa o null terminator.
In C, tutte le stringhe sono chiuse da un null
terminator, ed occupano perciò un byte in più del
numero di caratteri "stampabili" che le compongono.

Descrizione
printf(string);
La prima chiamata a printf() passa quale
argomento proprio string: dunque la stringa
parametro indispensabile di printf() non deve
essere necessariamente una stringa di formato
quando l'unica cosa da visualizzare sia proprio una
stringa. Lo è, però, quando devono essere visualizzati
caratteri o numeri, o stringhe formattate in un modo
particolare, come avviene nella seconda chiamata.
printf(" %s n",string);

Osservazioni
Per visualizzare una stringa con printf() occore
fornirne l'indirizzo, che nel nostro caso è il contenuto
del puntatore string.
Se string punta alla stringa "Ciao", che cosa
restituisce l'espressione *string?
La tentazione di rispondere "Ciao" è forte, ma se così
fosse perché per visualizzare la parola occorre passare
a printf() string e non *string?

Osservazioni
Il problema non si poneva con gli esempi precedenti,
perché tutti i puntatori esaminati indirizzavano un
unico dato di un certo tipo.
Con le dichiarazioni:
float numero = 12.5;
float *numPtr = &numero;
si definisce il puntatore numPtr e lo si inizializza in
modo che contenga l'indirizzo della variabile numero,
la quale, in fondo proprio come string, occupa più di
un byte. In questo caso, però, i 4 byte di numero
contengono un dato unitariamente considerato.

Osservazioni
In altre parole, nessuno dei 4 byte che la compongono
ha significato in sé e per sé.
Con riferimento a string, al contrario, ogni byte è un
dato a sé stante, cioè un dato di tipo char: bisogna
allora precisare che un puntatore indirizza sempre il
primo byte di tutti quelli che compongono il tipo di
dato considerato, se questi sono più d'uno.
Se ne ricava che string contiene, in realtà, l'indirizzo
del primo carattere di "Ciao", cioè la 'C'.
Allora *string non può che restituire proprio quella,
come si può facilmente verificare con la seguente
chiamata a printf():
printf("%c è il primo carattere...n",*string);

Le stringhe come sequenze di
caratteri
Le stringhe sono, per il compilatore C, semplici
sequenze di char: la stringa del nostro esempio:
inizia con il char che si trova all'indirizzo contenuto
in string (la 'C') e termina con il primo byte nullo
incontrato ad un indirizzo uguale o superiore a quello
del primo carattere (nell’esempio il byte che segue
immediatamente la 'o').
Per accedere ai caratteri che seguono il primo è
sufficiente incrementare il puntatore o, comunque,
sommare ad esso una opportuna quantità (che
rappresenta l'offset, cioè lo spostamento, dall'inizio
della stringa stessa).

Esempio
int i = 0;
while(*(string+i) != 0)
{ printf("%cn",*(string+i));
++i; }
L'esempio si basa sull'aritmetica dei puntatori, cioè
sulla possibilità di accedere ai dati memorizzati ad un
certo offset rispetto ad un indirizzo sommandovi
algebricamente numeri interi.

Descrizione
++i; }
Il ciclo visualizza la stringa "Ciao" in senso verticale.
Infatti l'istruzione while esegue le istruzioni comprese
tra le parentesi graffe finché la condizione espressa tra
le parentesi tonde è vera (se questa è falsa la prima
volta, il ciclo non viene mai eseguito): in questo caso
la printf() è eseguita finché il byte che si trova
all'indirizzo contenuto in string aumentato di i unità
è diverso da 0, cioè finché non viene incontrato il null
terminator.

Descrizione
printf("%cn",*(string+i));
La printf() visualizza il byte a quello stesso indirizzo
e va a capo.
Il valore di i è inizialmente 0, pertanto nella prima
iterazione l'indirizzo espresso da string non è
modificato, ma ad ogni loop i è incrementato di 1
(tale è il significato dell'operatore ++), pertanto ad
ogni successiva iterazione l'espressione string+i
restituisce l'indirizzo del byte successivo a quello
appena visualizzato.

Descrizione
Al termine, i contiene il valore 4, che è anche la
lunghezza della stringa: questa è infatti
convenzionalmente pari al numero dei caratteri
stampabili che compongono la stringa stessa; il null
terminator non viene considerato.
int i = 0;
++i; }
In altre parole la lunghezza di una stringa è inferiore di 1
al numero di byte che essa occupa effettivamente in
memoria.

Lunghezza di una stringa
La lunghezza di una stringa può quindi essere calcolata
così:
unsigned i = 0;
while(*(string+i)) ++i;
La condizione tra parentesi è implicita: non viene
specificato alcun confronto.
In casi come questo il compilatore assume che il
confronto vada effettuato con il valore 0, che è proprio
quel che fa al nostro caso.
Inoltre, dato che il ciclo si compone di una sola riga
(l'autoincremento di i), le graffe non sono necessarie.

Osservazione
Quando ad una funzione viene passata una
costante stringa, come in:
printf("Ciao!n");
il compilatore, astutamente, memorizza la
costante e ne passa l'indirizzo.

Esempio: modifica di una
stringa
char *string = "Rosson";
Void main(void)
{ printf(string);
*(string+3) = 'p';
printf(string);
}
Il programma dell'esempio visualizza dapprima la
parola "Rosso" e poi "Rospo".

Osservazioni
Il valore di string non è mutato: esso continua a
puntare alla medesima locazione di memoria, ma è
mutato il contenuto del byte che si trova ad un offset di
3 rispetto a quell'indirizzo.
Dal momento che l'indirezione di un puntatore a
carattere restituisce un carattere, nell'assegnazione
della lettera 'p' è necessario esprimere quest'ultima
come un char, e pertanto tra apici (e non tra
virgolette).
La variabile string non a casp è dichiarata all'esterno
di main().

Come troncare una stringa
Per troncare una stringa basta inserire un NULL
dove occorre:
*(string+2) = NULL;
A questo punto una chiamata a printf()
visualizzerebbe la parola "Ro".
NULL è una costante manifesta definita in
STDIO.H, e rappresenta lo zero binario; infatti la
riga di codice precedente potrebbe essere scritta
così:
*(string+2) = 0;

Come allungare una stringa
Se si sovrascrive il NULL con un carattere, la stringa si allunga sino
al successivo NULL.
Occorre fare alcune considerazioni:
 in primo luogo, tale operazione ha senso, di solito, solo nel caso
di concatenamento di stringhe (quando cioè si desidera
accodare una stringa ad un'altra per produrne una sola, più
lunga).
 In secondo luogo, se i byte successivi al NULL sono occupati da
altri dati, questi vengono perduti, sovrascritti dai caratteri
concatenati alla stringa: l'effetto può essere disastroso.
 Abbiamo visto che esiste una funzione di libreria concepita
appositamente per concatenare le stringhe: la strcat(), che
richiede due stringhe quali parametri. L'azione da essa svolta
consiste nel copiare i byte che compongono la seconda stringa,
NULL terminale compreso, in coda alla prima stringa,
sovrascrivendone il NULL terminale.

Osservazioni
In una dichiarazione come quella di string, il
compilatore riserva alla stringa lo spazio
strettamente necessario a contenere i caratteri
che la compongono, più il NULL.
E' evidente che concatenare a string un'altra
stringa sarebbe un grave errore (peraltro non
segnalato dal compilatore, perché esso lascia il
programmatore libero di gestire la memoria
come crede: se sbaglia, peggio per lui).

E' meglio sottolineare che le librerie standard
del C comprendono un gran numero di
funzioni (dichiarate in STRING.H) per la
manipolazione delle stringhe, che effettuano
le più svariate operazioni: copiare stringhe o
parte di esse (strcpy(), strncpy()),
concatenare stringhe (strcat(),
strncat()), confrontare stringhe
(strcmp(), stricmp()), ricercare
sottostringhe o caratteri all'interno di stringhe
(strstr(), strchr(), strtok())...

FINE

Lezioni di programmazione in c le stringhe By Cristian Randieri - www.intellisystem.it

More Related Content

What's hot (20)

Viewers also liked (17)

Similar to Lezioni di programmazione in c le stringhe By Cristian Randieri - www.intellisystem.it (20)

More from Cristian Randieri PhD (20)

Recently uploaded (11)

Lezioni di programmazione in c le stringhe By Cristian Randieri - www.intellisystem.it