G. Amodeo,
C. Gaibisso
Programmazione di Calcolatori
Lezione XIX
Le stringhe
Programmazione di Calcolatori: le stringhe
1
G. Amodeo,
C. Gaibisso
Premessa:
• Il tipo char
Lunghezza:
8 bit
Range:
da -128 a 127
Definizione:
char nomevariabile;
• Costanti di tipo char:
carattere racchiuso tra apici, equivale al
valore del codice ASCII per il carattere
Esempio: -
‘S’ (codice ASCII: 83)
‘c’ (codice ASCII: 67)
‘,’ (codice ASCII: 44)
‘+’ (codice ASCII: 43)
Programmazione di Calcolatori: le stringhe
2
La tabella dei codici ASCII
Tabella dei codici ASCII
G. Amodeo,
C. Gaibisso
Programmazione di Calcolatori: le stringhe
3
G. Amodeo,
C. Gaibisso
Le stringhe in memoria
• Stringa:
ogni sequenza di caratteri
memorizzati in locazioni
contigue di memoria e
terminata dal carattere ‘\0’,
detto carattere di fine stringa
‘s’
‘t’
‘r’
‘i’
‘n’
‘g’
‘a’
‘\0’
Programmazione di Calcolatori: le stringhe
x
x
x
x
x
x
x
x
x
x
4
G. Amodeo,
C. Gaibisso
Definizione di una stringa
• Allocazione dinamica:
// definisce la lunghezza massima di una stringa,
// ‘\0’ escluso
#define STR_LENGTH 80
…
// assegna un nome alla stringa e le alloca memoria
char *nomestringa=(char *) malloc(STR_LENGTH+1*
sizeof(char));
Alternativa:
char nomestringa[STR_LENGTH+1];
Attenzione!!! Impone, tra l’altro, dei vincoli notevoli
sull’utilizzo delle funzioni per la gestione delle stringhe
Programmazione di Calcolatori: le stringhe
5
G. Amodeo,
C. Gaibisso
I/O di stringhe
• Acquisizione:
scanf(“%s”, dst);
con dst espressione di tipo char * e %s specificatore di
formato per le stringhe
• Modifiche allo stato della memoria:
1. elimina dallo stream di input qualunque sequenza
iniziale di caratteri in un insieme di delimitatori (‘\n’,
‘ ‘,‘\r’, …);
2. copia caratteri dallo stream di input, fino al primo di
un insieme di delimitatori (‘\n’, ‘ ‘,‘\r’, …) escluso, in
memoria a partire dall’indirizzo dst;
3. memorizza ‘\0’ a partire dalla locazione successiva
all’ultima utilizzata per l’acquisizione.
Più informalmente:
memorizza i caratteri acquisiti nella stringa dst.
Programmazione di Calcolatori: le stringhe
6
G. Amodeo,
C. Gaibisso
I/O di stringhe
• Restituzione:
printf(“%s”, src);
con src espressione di tipo char * e %s
specificatore di formato per le stringhe
• Effetto:
visualizza i caratteri memorizzati a partire
dall’indirizzo src fino al primo ‘\0’
Più informalmente:
visualizza la stringa src
Programmazione di Calcolatori: le stringhe
7
G. Amodeo,
C. Gaibisso
Ingresso/uscita di stringhe
// sorgente: Lezione_XIX\StrIO.c
// illustra le modalità di acquisizione e restituzione di stringhe
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi di interesse generale e funzionali alle varie operazioni di I/O
#include <stdio.h>
#include <stdlib.h>
// definisce la lunghezza massima prevista per una stringa, ‘\0’ escluso
#define STR_LENGTH 80
// chiamante
int main ()
{
// definisce e alloca memoria per due stringhe. Se l'allocazione ha esito
// negativo, recupera la memoria eventualmente allocata e termina
char *Str1 = (char *) malloc((STR_LENGTH+1)*sizeof(char));
char *Str2 = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Str2 == NULL)
{
free(Str1);
return(0);
};
Programmazione di Calcolatori: le stringhe
Continua …
if (Str1 == NULL)
return(0);
8
G. Amodeo,
C. Gaibisso
Ingresso/uscita di stringhe
// acquisisce il contenuto delle due stringhe
printf("\nPrima Stringa? ");
scanf("%s", Str1);
printf("\nSeconda Stringa? ");
scanf("%s", Str2);
// restituisce il contenuto delle due stringhe
printf("\nPrima stringa: %s", Str1);
printf("\nSeconda stringa: %s\n", Str2);
// libera la memoria allocata per le stringhe
free(Str1);
free(Str2);
return(1);
}
Programmazione di Calcolatori: le stringhe
9
G. Amodeo,
C. Gaibisso
I/O di stringhe
• Compilazione:
• Esecuzione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
10
G. Amodeo,
C. Gaibisso
I/O di stringhe
• Esecuzione:
Programmazione di Calcolatori: le stringhe
11
G. Amodeo,
C. Gaibisso
Stringhe costanti
• Stringa costante:
sequenza di caratteri racchiusa tra doppi apici
• Esempio:
 “lkasdj jp656 #@!”
 “Sono andato a casa”
• Esempio:
// sorgente: Lezione_XIX\StrCost.c
// illustra un semplice esempio di uso delle stringhe costanti
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi funzionali alle varie operazioni di I/O
#include <stdio.h>
// chiamante
int main ()
{
// visualizza due diverse stringhe costanti
printf("\n%s", "Vado a casa");
printf("\n%s\n", "Vado a \0 casa");
return(0);
};
Programmazione di Calcolatori: le stringhe
12
G. Amodeo,
C. Gaibisso
I/O di stringhe
• Compilazione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
13
G. Amodeo,
C. Gaibisso
Input di linee di testo da tastiera: fgets()
• Signature:
char * fgets(char *dst, size_t length, FILE *stream)
• Modifiche allo stato della memoria:
1. copia caratteri dallo stream di input in memoria a
partire dall’indirizzo dst. Termina:
• al raggiungimento di un ‘\n’ o di un EOF ;
• in ogni caso dopo aver copiato length-1 caratteri;
2. memorizza ‘\0’ a partire dalla locazione successiva
all’ultima utilizzata per l’acquisizione.
Più informalmente:
copia length-1caratteri dallo stream di input, se disponibili,
nella stringa dst
ultimo carattere di ogni
• Valore restituito:
file (End Of File)
l’indirizzo dst
Programmazione di Calcolatori: le stringhe
14
G. Amodeo,
C. Gaibisso
Acquisizione di linee di input
Continua …
// sorgente: Lezione_XIX\LineInput.c
// illustra le modalità di acquisizione di una linea di input attraverso la fgets()
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi funzionali alle varie operazioni di I/O e di interesse generale
#include <stdio.h>
#include <stdlib.h>
// definisce la lunghezza massima prevista per una linea di input, '\0' escluso
#define IN_LINE_LENGTH 80
// chiamante
int main ()
{
// definisce e alloca memoria per una stringa
char *Str = (char *) malloc((IN_LINE_LENGTH+1)*sizeof(char));
// se l'allocazione ha esito negativo termina
if (Str == NULL)
return(0);
// memorizza al piu’ IN_LINE_LENGTH caratteri dell'input nella stringa
printf("\nInput? ");
fgets(Str, IN_LINE_LENGTH+1, stdin);
// restituisce il contenuto della stringa
printf("\nStringa acquisita: %s", Str);
Programmazione di Calcolatori: le stringhe
15
G. Amodeo,
C. Gaibisso
Acquisizione di linee di input
// libera la memoria allocata per la stringa
free(Str);
return(1);
};
Programmazione di Calcolatori: le stringhe
16
G. Amodeo,
C. Gaibisso
Acquisizione di una linea di input
• Compilazione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
17
G. Amodeo,
C. Gaibisso
Direttiva per il preprocessore
Attenzione!!!
Le librerie del C mettono a disposizione del
programmatore un insieme di funzioni per il
processamento delle stringhe. Per utilizzare tali
funzioni all’interno di un file è necessario
includere in testa allo stesso la direttiva per il
preprocessore:
# include <string.h>
Programmazione di Calcolatori: le stringhe
18
G. Amodeo,
C. Gaibisso
La funzione strlen()
• Signature:
dichiara che la funzione
non modificherà il
contenuto della stringa
size_t strlen (const char *str);
• Modifiche allo stato della memoria:
nessuno
• Valore restituito:
il numero di caratteri memorizzati a partire
dall’indirizzo str fino al primo '\0' escluso
Più informalmente:
la lunghezza della stringa str
Programmazione di Calcolatori: le stringhe
19
G. Amodeo,
C. Gaibisso
La funzione strlen()
• Esempio:
int main ()
char *str
‘p’
{
// definisce la stringa
‘r’
char *str = (char *) malloc (...);
‘o’
// definisce la variabile per la lunghezza
‘v’
// della stringa
‘a’
size_t lung;
‘\0’
….
5
// assegna alla variabile la lunghezza
// della stringa
lung = strlen(stringa);
….
}
Programmazione di Calcolatori: le stringhe
20
G. Amodeo,
C. Gaibisso
La funzione strlen()
Programmazione di Calcolatori: le stringhe
Continua …
// sorgente: Lezione_XIX\Strlen.c
// illustra le modalità di utilizzo della funzione strlen()
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi di interesse generale, funzionali alle varie operazioni di I/O
// e alla gestione delle stringhe, rispettivamente
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
// definisce la lunghezza massima prevista per una stringa, ‘\0’ escluso
#define STR_LENGTH 80
// chiamante
int main ()
{
// defisce una stringa ed una variabile per la sua lunghezza
char *Str;
size_t lung;
// alloca memoria per la stringa
Str = (char *) malloc((STR_LENGTH+1)*sizeof(char));
// se l'esito dell'operazione e' negativo termina
if (Str == NULL)
return(0);
// acquisisce il contenuto della stringa
printf("\nStringa? ");
scanf("%s", Str);
21
G. Amodeo,
C. Gaibisso
La funzione strlen()
// assegna alla variabile e visualizza la lunghezza della stringa, ad
// esclusione del ‘\0’
printf("La lunghezza della stringa e': %u\n", lung = strlen(Str));
// libera la memoria allocata per la stringa
free(Str);
return(1);
};
Programmazione di Calcolatori: le stringhe
22
G. Amodeo,
C. Gaibisso
La funzione strlen()
• Compilazione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
23
G. Amodeo,
C. Gaibisso
La funzione strcpy()
• Signature:
char *strcpy(char *dst, const char *src);
• Modifiche allo stato della memoria:
copia la sequenza di caratteri di indirizzo
iniziale src, fino al primo '\0' incluso, a
partire dall’indirizzo dst.
Più informalmente:
copia la stringa src sulla stringa dst
• Valore restituito:
l’indirizzo dst
Programmazione di Calcolatori: le stringhe
24
G. Amodeo,
C. Gaibisso
La funzione strcpy()
• Esempio:
….
‘p’
‘v’
‘r’
‘i’
‘o’
‘a’
‘\0’
‘n’
‘t’
‘i’
‘\0’
// copia la stringa sorgente sulla
// destinazione e visualizza il
// risultato dell’operazione char *src;
printf(“%s”, strcpy(dst, src));
…
}
‘v’
‘i’
‘a’
‘\0’
char *dst;
int main ()
{
// definisce la stringa destinazione e
// la stringa sorgente
char *dst = (char *) malloc (...);
char *src = (char *) malloc (...);
dst
Programmazione di Calcolatori: le stringhe
25
G. Amodeo,
C. Gaibisso
La funzione strcpy()
Continua …
// sorgente: Lezione_XIX\Strcpy.c
// illustra le modalità di utilizzo della funzione strcpy()
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi di interesse generale, funzionali alle varie operazioni di I/O
// e alla gestione delle stringhe, rispettivamente
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
// definisce la lunghezza massima prevista per una stringa, '\0' escluso
#define STR_LENGTH 80
// chiamante
int main ()
{
// definisce e alloca memoria per la stringa destinazione e la stringa
// sorgente. Se l’operazione ha esito negativo, recupera la memoria
// eventualmente allocate e termina
char *Dst , *Src;
Src = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Src == NULL)
return(0);
Programmazione di Calcolatori: le stringhe
26
G. Amodeo,
C. Gaibisso
La funzione strcpy()
Dst = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Dst == NULL)
{
free(src);
return(0);
};
// acquisisce il contenuto delle due stringhe
printf("\nDestinazione? ");
scanf("%s", Dst);
printf("\nSorgente? ");
scanf("%s", Src);
// copia la stringa sorgente sulla destinazione e visualizza il
// risultato dell’operazione
printf("\nDestinazione: %s\n", strcpy(Dst, Src));
// libera la memoria allocata per la stringa sorgente e la stringa
// destinazione
free(Srg);
free(Dst);
return(1);
};
Programmazione di Calcolatori: le stringhe
27
G. Amodeo,
C. Gaibisso
La funzione strcpy()
• Compilazione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
28
G. Amodeo,
C. Gaibisso
La funzione strncpy()
• Signature:
char *strcnpy(char *dst,
const char *src, size_t length);
• Modifiche allo stato della memoria:
copia la sequenza di caratteri di indirizzo
iniziale src a partire dall’indirizzo dst.
Termina dopo length caratteri o al primo '\0'
incontrato incluso.
Più informalmente:
copia length caratteri della stringa src sulla
stringa dst
• Valore restituito:
l’indirizzo dst
Programmazione di Calcolatori: le stringhe
29
G. Amodeo,
C. Gaibisso
La funzione strncpy()
• Esempio:
char *dst;
int main ()
{
// definisce la stringa destinazione e
// la stringa sorgente
char *dst = (char *) malloc (...);
char *src = (char *) malloc (...);
‘c’
‘t’
‘o’
‘a’
‘r’
‘t’
‘a’
‘\0’
….
// copia due caratteri della stringa
// sorgente sulla destinazione e
// visualizza il risultato
char *src;
printf(“%s”, strncpy(dst, src, 2));
…
}
dst
Programmazione di Calcolatori: le stringhe
‘c’
‘a’
‘s’
‘a’
‘\0’
30
G. Amodeo,
C. Gaibisso
La funzione strncpy()
• Esempio:
‘p’
‘v’
char *dst;
‘r’
‘i’
int main ()
{
‘o’
‘a’
// definisce la stringa destinazione e la stringa
‘\0’
‘n’
// sorgente
char *dst = (char *) malloc (...);
‘t’
char *src = (char *) malloc (...);
‘i’
….
‘\0’
// copia quattro caratteri della
// stringa sorgente sulla destinazione
‘v’
// e visualizza il risultato
char *src;
‘i’
printf(“%s”, strncpy(dst, src, 8));
‘a’
…
}
‘\0’
dst
Programmazione di Calcolatori: le stringhe
31
G. Amodeo,
C. Gaibisso
La funzione strncpy()
Programmazione di Calcolatori: le stringhe
Continua …
// sorgente: Lezione_XIX\Strncpy.c
// illustra le modalità di utilizzo della funzione strcnpy()
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi di interesse generale, funzionali alle varie operazioni di I/O
// e alla gestione delle stringhe, rispettivamente
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
// definisce la lunghezza massima prevista per una stringa, '\0' escluso
#define STR_LENGTH 80
// chiamante
int main ()
{
// definisce la stringa destinazione, la stringa sorgente
// e una variabile per il numero di caratteri da copiare
char *Dst, *Srg;
size_t nro;
// alloca memoria per la stringa destinazione e la stringa
// sorgente. Se l’operazione ha esito negativo, recupera la
// memoria eventualmente allocate e termina
Src = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Src == NULL)
return(0);
32
G. Amodeo,
C. Gaibisso
La funzione strncpy()
Dst = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Dst == NULL)
{
free(src);
return(0);
};
// acquisisce il contenuto delle due stringhe
printf("\nDestinazione? "); scanf("%s", Dst);
printf("\nSorgente? ");
scanf("%s", Srg);
// acquisisce il numero di caratteri da copiare
printf("\nNumero di caratteri? ");
scanf("%u", &nro);
// copia nro caratteri dalla stringa sorgente sulla destinazione e
// visualizza il risultato dell’operazione
printf("\nDestinazione: %s\n", strncpy(Dst, Srg, nro));
// rilascia la memoria allocata per le stringhe
free(Src);
free(Dst);
return(1);
};
Programmazione di Calcolatori: le stringhe
33
G. Amodeo,
C. Gaibisso
La funzione strncpy()
• Compilazione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
34
G. Amodeo,
C. Gaibisso
La funzione strncpy()
• Esecuzione:
Programmazione di Calcolatori: le stringhe
35
G. Amodeo,
C. Gaibisso
La funzione strcat()
• Signature:
char *strcat(char *dst, const char *src);
• Modifiche allo stato della memoria:
copia la sequenza di caratteri di indirizzo
iniziale src, fino al primo '\0' incluso, a
partire dall’indirizzo del primo '\0'
successivo a dst
Più informalmente:
concatena la stringa src alla stringa dst
• Valore restituito:
l’indirizzo dst
Programmazione di Calcolatori: le stringhe
36
G. Amodeo,
C. Gaibisso
La funzione strcat()
• Esempio:
‘c’
char *Dst;
‘o’
int main ()
{
‘\0’
‘r’
// definisce la stringa destinazione e la stringa
‘t’
// sorgente
char *Src = (char *) malloc (...);
‘o’
char *Dst = (char *) malloc (...);
‘\0’
….
// concatena la stringa sorgente
// alla destinazione e visualizza
// il risultato
char *Src;
printf(“%s”, strcat(Src, Dst));
…
}
‘r’
‘t’
‘o’
‘\0’
Dst
Programmazione di Calcolatori: le stringhe
37
G. Amodeo,
C. Gaibisso
La funzione strcat()
Programmazione di Calcolatori: le stringhe
Continua …
// sorgente: Lezione_XIX\Strcat.c
// illustra le modalità di utilizzo della funzione strcat()
// concatenando due stringhe, separandole con uno spazio bianco
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi di interesse generale, funzionali alle varie operazioni di I/O
// e alla gestione delle stringhe, rispettivamente
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
// definisce la lunghezza massima prevista per una stringa, '\0' escluso
#define STR_LENGTH 80
// chiamante
int main ()
{
// definisce la stringa destinazione e la stringa sorgente
char *Dst, *Src;
// alloca memoria per la stringa destinazione e la stringa
// sorgente. Se l’operazione ha esito negativo, recupera la
// memoria eventualmente allocate e termina
Src = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Src == NULL)
return(0);
38
G. Amodeo,
C. Gaibisso
La funzione strcat()
Dst = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Dst == NULL)
{
free(Src);
return(0);
};
// concatena uno spazio bianco alla stringa destinazione
strcat(Dst, " ");
// concatena la stringa sorgente alla destinazione e visualizza il
// risultato dell’operazione
printf("\nDestinazione: %s\n", strcat(Dst, Src));
// rilascia la memoria allocata per le stringhe
free(Src);
free(Dst);
return(1);
};
Programmazione di Calcolatori: le stringhe
39
G. Amodeo,
C. Gaibisso
La funzione strcat()
• Compilazione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
40
G. Amodeo,
C. Gaibisso
La funzione strncat()
• Signature:
char *strcncat(char *dst,
const char *src, size_t length);
• Modifiche allo stato della memoria:
copia i caratteri della sequenza di indirizzo
iniziale src, a partire dall’indirizzo del primo
'\0' successivo a dst.Termina dopo aver copiato
length caratteri o al primo '\0' incontrato
escluso. Termina la sequenza di caratteri
copiati con '\0'.
Più informalmente:
concatena i primi length caratteri della stringa
src alla stringa dst
• Valore restituito:
l’indirizzo dst
Programmazione di Calcolatori: le stringhe
41
G. Amodeo,
C. Gaibisso
La funzione strncat()
• Esempio:
int main ()
‘t’
char *Dst;
‘a’
{
‘p’
// definisce la stringa destinazione e la stringa
‘\0’
‘p’
// sorgente
char *Dst = (char *) malloc (...);
‘o’
char *Src = (char *) malloc (...);
‘\0’
….
// concatena i primi 2 caratteri della
// stringa sorgente alla destinazione
// e visualizza il risultato
char *Src;
printf(“%s”, strcat(Src, Dst,2));
…
}
‘p’
‘o’
‘c’
‘o’
‘\0’
Dst
Programmazione di Calcolatori: le stringhe
42
G. Amodeo,
C. Gaibisso
La funzione strncat()
Programmazione di Calcolatori: le stringhe
Continua …
// sorgente: Lezione_XIX\Strncat.c
// illustra le modalità di utilizzo della funzione strncat()
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi di interesse generale, funzionali alle varie operazioni di I/O
// e alla gestione delle stringhe, rispettivamente
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
// definisce la lunghezza massima prevista per una stringa, '\0' escluso
#define STR_LENGTH 80
// chiamante
int main ()
{
// definisce la stringa destinazione, la stringa sorgente
// e una variabile per il numero di caratteri da copiare
char *Dst, *Src;
size_t nro;
// alloca memoria per la stringa destinazione e la stringa
// sorgente. Se l’operazione ha esito negativo, recupera la
// memoria eventualmente allocate e termina
Src = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Src == NULL)
return(0);
Dst = (char *) malloc((STR_LENGTH+1)*sizeof(char));
43
G. Amodeo,
C. Gaibisso
La funzione strncat()
if (Dst == NULL)
{
free(Src);
return(0);
};
// acquisisce il contenuto delle due stringhe
printf("\nDestinazione? ");
scanf("%s", Dst);
printf("\nSorgente? ");
scanf("%s", Src);
// acquisisce il numero di caratteri da concatenare
printf("\nNumero di caratteri? ");
scanf("%u", &nro);
// concatena nro caratteri della stringa sorgente alla destinazione e
// visualizza il risultato dell’operazione
printf("\nDestinazione: %s\n", strncat(Dst, Src, nro));
// rilascia la memoria allocata per le stringhe
free(Src);
free(Dst);
return(1);
};
Programmazione di Calcolatori: le stringhe
44
G. Amodeo,
C. Gaibisso
La funzione strncat()
• Compilazione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
45
G. Amodeo,
C. Gaibisso
La funzione strncat()
• Esecuzione:
Programmazione di Calcolatori: le stringhe
46
G. Amodeo,
C. Gaibisso
La funzione strcmp()
• Signature:
int strcmp(const char *str1, const char *str2)
• Modifiche allo stato della memoria:
Alcuna
• Valore restituito:
confronta carattere per carattere le due
sequenze di caratteri di indirizzo iniziale str1 e
str2.
Termina al raggiungimento del primo '\0' o
della prima coppia di caratteri differenti.
Nel primo caso, siano c1 e c2 l’ultima coppia di
caratteri raggiunti (almeno uno tra di loro è
'\0') a partire da str1 e da str2, rispettivamente.
Programmazione di Calcolatori: le stringhe
47
G. Amodeo,
C. Gaibisso
La funzione strcmp()
Restituisce:
• 0 se c1 = c2 = ‘\0’;
• un valore negativo se c1 = ‘\0’ e c2 ≠ ‘\0’
• un valore positivo se c1 ≠ ‘\0’ e c2 = ‘\0’
Nel secondo caso siano c1 e c2 l’ultima coppia
di caratteri confrontati (c1, c2 ≠ ‘\0’; c1≠ c2 ), a
partire da str1 e da str2, rispettivamente.
Restituisce:
• un valore negativo se c1 < c2 (codici ASCII)
• un valore positivo se c1 > c2
Più informalmente:
restituisce un intero il cui segno identifica il
risultato del confronto lessicografico tra str1 e
str2
Programmazione di Calcolatori: le stringhe
48
G. Amodeo,
C. Gaibisso
La funzione strcmp()
Programmazione di Calcolatori: le stringhe
Continua …
// sorgente: Lezione_XIX\Strcmp.c
// illustra le modalità di utilizzo della funzione strcmp()
// inclusione del file di intestazione della libreria standard che
// contiene definizioni di macro, costanti e dichiarazioni di funzioni
// e tipi di interesse generale, funzionali alle varie operazioni di I/O
// e alla gestione delle stringhe, rispettivamente
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
// definisce la lunghezza massima prevista per una stringa, '\0' escluso
#define STR_LENGTH 80
// chiamante
int main ()
{
// defisce le due stringhe oggetto del confronto
char *Str1, *Str2;
// alloca memoria per le due stringhe. Se l’operazione ha esito negativo,
// recupera la memoria eventualmente allocate e termina
Str1 = (char *) malloc((STR_LENGTH+1)*sizeof(char));
if (Str1 == NULL)
return(0);
Str2 = (char *) malloc((STR_LENGTH+1)*sizeof(char));
49
G. Amodeo,
C. Gaibisso
La funzione strcmp()
if (Str2 == NULL)
{
free(Str1);
return(0);
};
// acquisisce il contenuto delle due stringhe
printf("\nI Stringa? ");
scanf("%s", Str1);
printf("\nII Stringa? ");
scanf("%s", Str2);
// confronta lessicograficamente le due stringhe e visualizza il risultato
// del confronto
if (strcmp(Str1, Str2) > 0)
printf("\n%s > %s\n", Str1, Str2);
else
if (strcmp(Str1, Str2) < 0)
printf("\n%s < %s\n", Str1, Str2);
else
printf("\n%s = %s\n", Str1, Str2);
// rilascia la memoria allocata per le stringhe
free(Str1);
free(Str2);
return(1);
};
Programmazione di Calcolatori: le stringhe
50
G. Amodeo,
C. Gaibisso
La funzione strcmp()
• Compilazione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
51
G. Amodeo,
C. Gaibisso
La funzione strcmp()
• Esecuzione:
• Esecuzione:
Programmazione di Calcolatori: le stringhe
52
G. Amodeo,
C. Gaibisso
Raccomandazione
Attenzione!!!
Consultare la manualistica per avere un
quadro esaustivo delle funzioni per la
manipolazione delle stringhe messe a
disposizione dalle librerie del C
Programmazione di Calcolatori: le stringhe
53