1. Fondamenti di Informatica
Array, stringhe e gestione delle
sequenze
1

2. La memorizzazione di sequenze
• Molti problemi richiedono la memorizzazione di
sequenze di dati
• Esempio: stampare al contrario una parola fornita
dall'utente
– Solo quando l'ultimo carattere è stato inserito è possibile
procedere alla stampa
– Ma nel frattempo si devono conservare i caratteri
precedenti
• I linguaggi di programmazione mettono a disposizione
un costruttore di tipi complessi che permette di definire
sequenze di valori dello stesso tipo
• Due tipi principali di costruttori:
– Sequenze di lunghezza fissa (array)
– Sequenze di lunghezza variabile (vector, string)
2

3. Gli array
• Gruppo di celle consecutive
dichiarazione
int v[12];
nome array
– Stesso nome e tipo
• Per riferirsi a un elemento, si
specificano:
– Il nome dell‟array
– La posizione dell‟elemento (indice)
• Formato: nomearray[posizione]
– Il primo elemento ha indice 0
– L‟n° elemento dell‟array v è v[n-1]
v[0]
-45
v[1]
6
v[2]
0
v[3]
72
v[4]
1543
v[5]
-89
v[6]
0
v[7]
62
v[8]
-3
v[9]
1
v[10]
6453
v[11]
78
posizione elemento
3

4. Il costruttore di tipo array
• Array: sequenza di elementi, omogenei, accessibili
individualmente mediante un indice
– char parola[12];
• È un array di 12 elementi di tipo char, vale a dire un
vettore di 12 caratteri
• La lunghezza dell‟array è assegnata nella dichiarazione
e inizializzazione dell'array
– La lunghezza dell‟array fa parte del tipo
– char parolaCorta[10];
– char parolaLunga[100]; hanno tipi diversi
• La dimensione degli array deve essere un'espressione
costante, determinabile dal compilatore, che alloca la
memoria necessaria all‟intero array

5. Accesso agli elementi di un array
• Ogni elemento della sequenza è individuato
mediante un indice con valore da 0 a N-1 (dove
N è la dimensione dell‟array)
• L‟accesso avviene mediante l‟operatore []
Esempio
int v[100];
. . .
v[3]=0; assegna
dell’array
il valore 0 al 4
elemento
• N.B. l‟accesso di un elemento al di fuori dei limiti
(v[i] con i >= 100) produce un errore e il
comportamento del programma è indefinito
5

6. Gestione della memoria
• int a[100];
– Si alloca spazio per 100 elementi interi, a partire
da un certo indirizzo di memoria, per questo
• la dimensione deve essere nota al compilatore
• deve essere una espressione costante
• Per accedere all' i-esimo elemento di a
– Si calcola l'indice i (può essere un'espressione)
– all‟indirizzo della prima cella di a si somma il
numero di celle pari allo spazio occupato da i
elementi
• Si ottiene così l'indirizzo dell'elemento cercato

7. Dichiarazione di un array
• Attenzione all'uso di espressioni costanti per le
dimensioni
unsigned cnt = 42; // not a constant expression
constexpr unsigned sz = 42; // constant expression
// (oppure: const unsigned sz = 42;)
int arr[10]; // ok array of ten ints
int bad[cnt]; // error: cnt not constant expression
• Alcuni compilatori ammettono l‟uso di variabili
nella dichiarazione delle dimensioni di un array
• Caratteristica dipendente dal compilatore:
meglio evitare
7

8. Inizializzazione di un array
• Sintassi compatta (list initialization):
int n[5]  {1, 2, 3, 4, 5};
– Inizializzazione parziale: gli elementi mancanti sono posti al
valore di default (0)
int n[5]  {13}; gli ultimi 4 elementi sono posti a 0
– Specificare troppi elementi è un errore di sintassi
• Se la lunghezza dell‟array è omessa, gli
inizializzatori la determinano:
int n[]  {5, 47, 2, 0, 24};
è equivalente a:
int n[5]  {5, 47,  2, 0, 24};
– In tal caso la dimensione è inferita automaticamente, e si avranno
5 elementi nell‟array (con indici che variano tra 0 e 4)
8

9. Inizializzazione esplicita
• Array di tipi integral (ma non char)
const unsigned sz = 3;
int ia1[sz] = {0,1,2}; // array of three ints with values 0, 1, 2
int a2[] = {0, 1, 2}; // an array of dimension 3
int a3[5] = {0, 1, 2}; // equivalent to a3[] = {0, 1, 2, 0, 0}
int a5[2] = {0,1,2}; // error: too many initializers
• Array di char
– Sono trattati in modo speciale, per compatibilità con il concetto di
stringa del linguaggio C
char a1[] = {'C', '+', '+'}; // list initialization, no null
char a2[] = {'C', '+', '+', '0'}; // list initialization, explicit null
char a3[] = "C++"; // null terminator added automatically
const char a4[6] = "Daniel"; // error: no space for the null!
• Dimensione a1 = 3; Dimensione di a2 e a3 = 4
• La definizione di a4 è errata
• Ricordare sempre che le stringhe alla C hanno il
terminatore '0' che occupa un carattere in più
9

10. Inizializzazione per copia e assegnamento
• Il tipo array non supporta la copia diretta dei
valori
– Né nell'assegnamento
– Né nell'inizializzazione
int a[] = {0, 1, 2}; // array of three ints
int a2[] = a; // error: cannot init one array with another
a2 = a; // error: cannot assign one array to another
10

11. Copia di array
• Si opera sui singoli elementi, uno per volta
• Non è possibile operare sull‟intero array,
agendo su tutti gli elementi simultaneamente
/ come ricopiare array1 in array2 /
int array1[10], array2[10];
. . .
array2  array1;
/ ERRATO /
. . .
for (int i  0; i  10; ++i) 
array2[i]  array1[i];
/ CORRETTO /

11

12. Inizializzazione per default
• Gli elementi di un array non inizializzati
esplicitamente sono inizializzati per
default
• Se la dichiarazione dell'array NON è
contenuta in una funzione il valore degli
elementi è il default per il loro tipo (0)
• Se la dichiarazione dell'array è contenuta
in una funzione il valore degli elementi
non è definito
12

13. Uso degli elementi
• Gli elementi di un array sono normali variabili:
–
–
–
–
–
vett[0]  3;
cout << vett[0];
>3
cin >> vett[1];
> 17
vett[1] assume valore 17
• Si possono usare espressioni come indici:
– se x  3, y=7 e z=4
– vett[52] è uguale a vett[3]
– ed è uguale a vett[x]
– ed è uguale a vett[y-z]

14. Esempi sugli array
• Dichiarazione del vettore:
int a[20];
• Riempimento del vettore:
for (int i = 0; i < 20; ++i)
a[i] = 0;
• Lettura da terminale dei valori:
for (int i = 0; i < 20; ++i) {
cout << "Scrivi un intero: " << endl;
cin >> a[i];
}
14

15. Esempi sugli array
• Ricerca del massimo:
max = a[0];
for (int i = 1; i < 20; ++i)
if (a[i] > max)
max = a[i];
• Calcolo della media:
media = 0;
for (i = 0; i <20; ++i)
media += a[i];
media = media / 20.0; // attenzione alle
// conversioni di tipo
15

16. Esempi sugli array
•
Calcolo di massimo, minimo e media di un vettore
– È sufficiente una sola scansione del vettore (un solo ciclo)
int main() {
const int size = 10;
int a[size] = {1,2,3,4,5,6,7,8,9,10};
float media = a[0];
int max = a[0], min = a[0];
for (int i = 1; i < size; ++i) {
media += a[i];
if (a[i] > max)
max = a[i];
if (a[i] < min)
min = a[i];
}
media /= size;
cout << "Media: " << media << " Min: " <<
<< " Max: " << max << endl;
return 0;
}
min
16

17. Problemi di elaborazione delle sequenze
• Invertire una sequenza di tot (10) interi
introdotta dall‟utente
• Cosa serve?
– Un array di tot caratteri
– Un contatore che scorra sull'array
• Flusso di controllo?
– Leggi la sequenza e mettila nell'array
– Stampa il contenuto dell'array a partire dal
fondo fino all'inizio
17

18. Codice sorgente: versione base
int main() {
const int size = 10;
char buffer[size];
int i=0;
while (i<size){
cout << "Prossimo carattere: " << endl;
cin >> buffer[i];
++i;
}
--i; // perché serve?
while (i>=0){
cout << buffer[i] << endl;
--i;
}
return 0;
}

19. Sequenza di lunghezza variabile, ma limitata
int main() {
const int maxSize = 10;
char buffer[maxSize];
int size, i = 0;
cout << "Inserire la lunghezza della sequenza: " << endl;
cin >> size;
if (size > maxSize)
cout << "Sequenza troppo lunga, max = " << maxSize << endl;
else {
while (i < size) {
cout << "Prossimo carattere: " << endl;
cin >> buffer[i];
++i;
}
--i;
while (i >= 0) {
cout << buffer[i] << endl;
--i;
}
}
return 0;
}
19

20. Sequenza delimitata da end-of-file
int main() {
// uso ctrl-z come sentinella
const int maxSize = 10;
char buffer[maxSize];
int i = 0;
cout << "Prossimo carattere, ctrl-z per finire: " << endl;
while (i < maxSize && cin >> buffer[i]) {
cout << "Prossimo carattere, ctrl-z per finire: " << endl;
++i;
}
--i;
while (i >= 0) {
cout << buffer[i] << endl;
--i;
}
return 0;
}
Analizzare le condizioni di uscita dal
primo ciclo
20

21. Stampa di un istogramma
• Data una serie di valori interi, stampare un
istogramma dei valori a barre orizzontali
• Cosa serve?
– Un array contenente la serie
– Un contatore per iterare sulla serie
• Flusso
– Per ogni elemento della serie
– Stampa un numero di caratteri pari al valore
dell'elemento
21

22. Output richiesto
Element
Value
0
1
2
3
4
5
6
7
8
9
19
3
15
7
11
9
13
5
17
1
Histogram
*******************
***
***************
*******
***********
*********
*************
*****
*****************
*
22

23. Codice sorgente
int main() {
const int size = 10;
int arr[size] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < size; ++i) {
for (int j = 1; j <= arr[i]; ++j)
cout << "*";
cout << 'n';
}
return 0;
}
23

24. Esercizio (semplice, ma apparentemente difficile)
• Si scriva un programma che visualizzi gli
istogrammi verticalmente:
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
19
0
*
*
*
3
1
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
15
2
*
*
*
*
*
*
*
7
3
*
*
*
*
*
*
*
*
*
*
*
11
4
*
*
*
*
*
*
*
*
*
9
5
*
*
*
*
*
*
*
*
*
*
*
*
*
13
6
*
*
*
*
*
5
7
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
17
8
*
1
9
24

25. Progettazione
• Cosa serve?
– Un array contenente la serie
– Un contatore per iterare sulla serie
• Flusso
– Calcola l'altezza della barra più alta (cioè il
massimo valore dell'array)
– Altezza corrente = max
– Per ogni riga j da max a 1
• Per ogni colonna i da 1 a size
– Se array[i] >= j stampa * altrimenti stampa uno spazio
– Decrementa j
– Stampa righe con valori e indici
25

26. Codice sorgente
#include <iostream>
#include <iomanip>
using namespace std;
int main() {
int arr[size] = { 1, 4, 3, 10, 5, 6, 7, 8, 9, 2 };
int max = arr[0];
cout << "Istogramma Verticale" << endl;
for (int k = 1; k < size; ++k) // trovo il massimo
if (arr[k] > max)
max = arr[k];
for (int riga = max; riga >= 1; --riga) { // per ogni riga da max a 1
for (int col = 0; col < size; ++col) // per ogni colonna da 1 a size
if (arr[col] >= riga)
cout << setw(3) << "*";
else
cout << setw(3) << " ";
cout << 'n';
}
for (int i = 0; i < size; ++i) {
cout << setw(3) << i;
}
cout << 'n';
for (int i = 0; i < size; ++i) {
cout << setw(3) << arr[i];
}
return 0;
}

27. Output formattato
• La librerie iostream e iomanip
contengono la definizione di vari manipolatori
• Un manipolatore assomiglia a una variabile
stampabile ma produce un cambio nel modo
in cui l'output viene presentato
• I manipolatori definiscono
– La modalità di rappresentazione dei valori
numerici, la precisione
– L'incolonnamento dell'output
• setw(int): definisce l'ampiezza in numero di colonne
del successivo comando di output
• left, right giustificano a sx, dx l'output
27

28. Manipolatori
iostream
iomanip
28

29. Ricerca e ordinamento
• Sono due tra le operazioni più importanti
sulle sequenze
– Dato un elemento verificare se esiste nella
sequenza e restituire la posizione
– Data una sequenza, rielaborarla in modo che
gli elementi risultino ordinati
• Oggetto di molto studio, per cui esistono
molti algoritmi diversi
• Usate come esempio per spiegare e
comparare la complessità degli algoritmi
29

30. Ricerca sequenziale in un array
const int size=10;
int main() {
int dato, posizione= -1;
int array[size] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
cout << "Inserisci il numero da ricercare: " << endl;
cin >> dato;
int i; // riusato al di fuori del ciclo for!
for (i = 0; i < size; ++i) // riscrevetelo con ciclo while
if (array[i] == dato) {
posizione = i;
break; // interrompe il ciclo
}
if (posizione != -1)
cout << "Risultato trovato all'indice: " << i << endl;
else
cout << "Risultato non presente" << endl;
return 0;
}
30

31. Ricerca binaria in un array
int main() {
int dato, posizione;
bool trovato = false;
int array[size] = { -6, -2, -1, 4, 5, 6, 7, 8, 9, 10 };
cout << "Inserisci il numero da ricercare: " << endl;
cin >> dato;
int low = 0, high = size - 1, mid;
while (low <= high && !trovato) {
mid = (low + high) / 2;
if (array[mid] == dato) {
trovato = true;
posizione = mid;
} else if (array[mid] > dato)
high = mid - 1;
else
// array[mid] < dato
low = mid + 1;
}
if (trovato)
cout << "Risultato trovato all'indice: " << posizione << endl;
else
cout << "Risultato non presente" << endl;
return 0;
}
31

32. Ordinare un array
• Data un vettore V[n] permutare i suoi
elementi in modo che risulti ordinato in
senso crescente:
V[0] <= V[1] <= V[2] <= … <= V[n-1]
• Esistono diversi algoritmi
– Gli algoritmi vengono valutati in base alle loro
prestazioni nel caso peggiore
– Per la caratterizzazione delle prestazioni nel
caso peggiore si utilizza il concetto di
complessità

33. Bubblesort
• Confronta i primi due elementi e se non sono ordinati si
scambia
– Confronta il secondo e il terzo e se non sono ordinati li scambia
… e così via sino a confrontare penultimo e ultimo elemento
– Dopo aver scandito una prima volta tutto il vettore si è sicuri che
l‟elemento maggiore è nella cella più a destra,
• Si comincia un nuovo ciclo che confronta ancora a due a
due le celle dalla prima all‟ultima.
• Se n è il numero di elementi del vettore si itera questo
processo di scansione per n-1 volte
• Alla fine il vettore risulta ordinato
• Algoritmo semplice ma inefficiente
– Numero di scambi proporzionale a N2 (N dimensione dell‟array)
• Ci sono algoritmi più veloci che richiedono l‟uso della
ricorsione

34. Codice sorgente
int main() {
int aux, array[size];
cout << "Inserire gli elementi del vettore:" << endl;
for (int k = 0; k < size; ++k)
cin >> array[k];
for (int i = 0; i < size - 1; ++i) {
for (int j = 0; j < size - 1 - i; ++j) {
if (array[j] > array[j + 1]) {
// se l'ordine è invertito
aux = array[j + 1];
// scambia elementi consecutivi
array[j + 1] = array[j];
array[j] = aux;
}
}
}
cout << "Il vettore ordinato e’: " << endl;
for (int h = 0; h < size; ++h)
cout << array[h] << endl;
return 0;
}

35. Check this out
• https://www.youtube.com/watch?v=INHF_5RIxTE

36. Sequenze a lunghezza variabile
• Gli array memorizzano sequenze di lunghezza
predefinita
• Farne uso per sequenze di lunghezza non nota
o variabile porta al sovra-dimensionamento con
conseguente spreco di memoria
• Esistono tipi di dati C++ più idonei a
rappresentare sequenze di lunghezza variabile
– Stringhe: sequenze di caratteri
– Vettori: sequenze di elementi di un qualunque altro
tipo

37. La libreria string
• Sequenza di caratteri di lunghezza variabile
• Il tipo string è definito in una libreria
• Per utilizzarlo:
#include <string>
using std::string;
• Lo standard C++ 11 definisce le operazioni
effettuabili, ma anche i requisiti di prestazione
• L‟uso del tipo string è perciò piuttosto efficiente
• Il tipo string è un tipo class (class type)

38. Definizione e inizializzazione
• Il tipo string ammette varie forme di
inizializzazione
• Esempi
string
string
string
string
s1; // default initialization; s1 is the empty string
s2 = s1; // s2 is a copy of s1
s3 = "hiya"; // s3 is a copy of the string literal
s4(10, 'c'); // s4 is cccccccccc

39. Inizializzazione per copia
• Quando l‟inizializzazione fa uso esplicito dell‟operatore
di assegnamento ( = ), si dice per copia
– l‟oggetto di sinistra riceve come valore iniziale una copia
dell‟oggetto di destra
• Altrimenti l‟inizializzazione è gestita dal compilatore e si
dice diretta
string s5 = "hiya"; // copy initialization
string s6("hiya"); // direct initialization
string s7(10, 'c'); // direct initialization; s7 is cccccccccc
• La forma
string s8 = string(10, 'c'); // copy initialization; s8 is cccccccccc
• Equivale a
string temp(10, 'c'); // temp is cccccccccc
string s8 = temp; // copy temp into s8
• Attenzione: con la modalità diretta il compilatore può
creare oggetti temporanei, se necessari per
l‟inizializzazione

40. Operazioni del tipo string
• La definizione del tipo string comprende le
operazioni effettuabili su variabili di quel tipo
• Le operazioni ammissibili sono:
– is = input stream
– os = output stream

41. Uso del tipo string
• Grazie al meccanismo delle classi il tipo string si
usa (quasi) come se fosse un tipo predefinito
• Lettura e scrittura
• La lettura scarta spazi/tab/a capi iniziali e si
arresta al primo spazio
int main()
{
string s; // empty string
cin >> s; // read a whitespace-separated string into s
cout << s << endl; // write s to the output
return 0;
}
• NB: se si inserisce “Hello world” la stampa
produce Hello

42. Lettura ripetuta di stringhe
• Simile alla lettura ripetuta di tipi predefiniti
int main() {
string word;
while (cin >> word) // read until end-of-file
cout << word << endl; // write each word
// followed by a new line
cout << "Thank you for playing !" << endl;
return 0;
}
• Provare ad eseguirlo per familiarizzare con la
gestione (non ovvia) dell‟input di tipo stringa
• cin >> word si arresta al primo spazio bianco
e copia la parola precedente in word, ma l'input
viene comunicato al programma a seguito
dell'invio di un "a capo"

43. Lettura per linee
• A volte è nbecessario leggere anche gli spazi
• getline(istream, string)
– Legge lo stream di input fino al primo carattere di a capo
(newline)
– Copia il contenuto (escluso newline) nella stringa
– Se il primo carattere letto è newline, la stringa è vuota
int main() {
string line;
// read a line at a time until end-of-line
while (getline(cin, line))
cout << line << endl; // emit NL & flush
return 0;
}
• Verificare la differenza !

44. cin.ignore(), >>, getline()
• http://stackoverflow.com/questions/664985
2/getline-not-working-properly-what-couldbe-the-reasons
• http://stackoverflow.com/questions/126913
16/getline-does-not-work-if-used-aftersome-inputs
44

45. Le dimensioni di una stringa
• Un valore di tipo string per definizione non ha una
lunghezza prefissata
• La libreria offre funzioni per:
– Verificare se è vuota (empty())
– Determinare la lunghezza (size())
• La funzione empty() torna un valore di tipo bool
• La funzione size() torna un valore di un tipo speciale
string::size_type
– In questo modo non si deve scegliere quale tipo integral usare
per rappresentare la dimensione  ci pensa il compilatore
– Per brevità si può lasciare al compilatore l‟incombenza di
definire il tipo nella dichiarazioni di variabili di tipo “lunghezza”
– auto lung = line.size();
– auto  tipo stabilito dal compilatore
– Poi però è meglio non usare tipi int in espressioni che
comprendano lung

46. Comparare stringhe
• La libreria string mette a disposizione gli operatori
relazionali == != < > <= >=
• La comparazione tra s1 e s2 avviene così
1. Se s1 è più corta di s2 e tutti i caratteri di s1 sono
uguali ai corrispondenti di s2  s1<s2
2. Se due caratteri in posizione corrispondente di s1 e
s2 differiscono, il risultato coincide con quello della
comparazione della prima coppia di caratteri
corrispondenti diversi
string str1 = "Hello";
string str2= "Hello World";
string str3 = "Hiya";
– str1 < str2 per la regola 1
– str2< str3 per la regola 2
46

47. Assegnamento e concatenazione
• A differenza degli array, la libreria string supporta l'operatore
di assegnamento
– Esempio di tipo di alto livello, che nasconde i dettagli realizzativi
interni di un operatore e ne consente l'uso come per i tipi
predefiniti
string st1="Hello", st2;
st1=st2; // assegnamento sostituisce il contenuto // di st1 con una
copia del contenuto di st2
// entrambe stringhe vuote
• L'operatore + concatena le stringhe
string s1 = "hello, ", s2 = "worldn";
string s3 = s1 + s2; // s3 is hello, worldn
• E' possibile concatenare una stringa anche con caratteri o
costanti di tipo stringa, ma attenzione all'associatività del +:
string
string
string
string
s4
s5
s6
s7
=
=
=
=
s1 + ",
"hello"
s1 + ",
"hello"
"; // ok: adding a string and a literal
+ ", "; // error: no string operand
" + "world"; // ok: each + has a string operand
+ ", " + s2; // error: can't add string literals
47

48. Accesso agli elementi
• Esistono due notazioni per farlo
• Una simile a quella per l'array, mediante
l'operatore []
• Come per gli array, l'uso di indicizzazione
esplicita con [] richiede attenzione a non
eccedere la dimensione della stringa
• Il C++ offre un metodo di accesso più
"astratto", che evita l'uso di un indice
numerico esplicito (range for)
48

49. Accesso in lettura
#include <iostream>
#include <string>
#include <cctype> // contiene funzioni per il controllo del tipo dei caratteri
using namespace std;
int main() {
string s("Hello World!!!!!");
decltype(s.size()) punct_cnt = 0; // let the compiler decide the type
// punct_cnt assumes same type as s.size()
for (decltype(s.size()) index = 0;
index < s.size(); ++index)
// for every char in s
if (ispunct(s[index]))
// if the character is punctuation
++punct_cnt;
// increment the punctuation counter
cout << punct_cnt << " punctuation characters in " << s << endl;
return 0;
}
•Conta i caratteri simbolo di punteggiatura
•index != s.size() garantisce di non uscire dai limiti della stringa
•funzione bool ispunct(char) della libreria cctype
•decltype (C++11): si usa nelle dichiarazioni per introdurre una variabile dello
stesso tipo di un'espressione (nel caso presente evitiamo così precisare il tipo
integral delle dimensioni di una stringa)
49

50. Accesso in modifica
int main() {
string str("some string");
// uppercase and print the characters in str
cout << "Use of subscripting with strings" << endl;
for (decltype(str.size()) index = 0; // for every char in str
index < str.size(); ++index)
str[index] = toupper(str[index]);
cout << str << endl; // print the modified string
return 0;
}
•Converte i caratteri in maiuscoli
•Usa la funzione char toupper(char) della libreria
cctype
50

51. Le funzioni della libreria cctype
51

52. Iterazione con range for
• C++ 11 offre un nuovo costrutto (range for) per iterare sulle
sequenze di lunghezza indefinita senza usare []
for (declaration : expression)
statement
• Expression denota un oggetto di tipo sequenza,
declaration dichiara una variabile che assume in
successione i valori degli elementi della sequenza
string str("some string");
// print the characters in str one character to a line
for (auto c : str)
// for every char in str
cout << c << endl; // print the current character
// followed by a newline
• La variabile c (cursore)
–Ha tipo determinato dal compilatore, in questo caso char
–Ad ogni iterazione contiene una copia del carattere corrente
della stringa
–Va bene anche char c: str, visto che il tipo degli
elementi della sequenza è noto (char)
52

53. Accesso in lettura
• Anche con range for è possibile analizzare/modificare il contenuto di
una stringa, es: conteggio dei simboli di punteggiatura
#include <iostream>
#include <string>
#include <cctype>
using namespace std;
int main() {
string s("Hello World!!!");
decltype(s.size()) punct_cnt = 0;
// punct_cnt assumes same type as s.size()
for (auto c : s) // for every char in s
if (ispunct(c)) // if the character is punctuation
++punct_cnt; // increment the punctuation counter
cout << punct_cnt << " punctuation characters in "
<< s << endl;
return 0;
}
53

54. Il costruttore di tipo reference &
• Una reference è un nome alternativo per una variabile
int ival = 1024;
int &refVal = ival; // refVal è sinonimo di
int &refVal2; // errore manca l'oggetto!!
ival
• Quando si legge/modifica refVal si legge/modifica ival!
refVal = 2; // assegna 2 a … ival
int ii = refVal; // stesso che ii = ival
• Il tipo di refVal si dice "reference to int"
• Le reference devono riferirsi a oggetti, non a literal
• Il tipo dell'oggetto e della reference devono coincidere
int &refVal4 = 10; // error: initializer must be an object
double dval = 3.14;
int &refVal5 = dval; // error: initializer must be an int object
54

55. Accesso in modifica
• Si può dichiarare il cursore come
reference
– Il cursore è un altro nome per l'elemento
corrente della stringa, non una sua copia!
– Se si modifica il cursore si modifica l'elemento
della stringa
– Convertiamo una stringa in maiuscolo
string s("Hello World!!!"); // convert s to uppercase
for (auto &c : s) // for every char in s
c = toupper(c);
// c is a reference, the assignment
// changes the char in s
cout << s << endl;
55

56. Le stringhe del C
• Per compatibilità con il C, C++ supporta funzioni su
array di caratteri che svolgono compiti simili a quelli
della libreria string
• #include <cstring> include la versione C++ della
libreria, corisponde a string.h del C
– Meglio usare il tipo nativo C++ string
• Dichiarazione+inizializzazione di una stringa C:
char stringa[]  "word";
• Bisogna ricordarsi che il carattere nullo '0' termina
le stringhe
– Perciò l‟array stringa ha 5 elementi (non 4):
• Dichiarazione equivalente:
char stringa[]  {'w', 'o', 'r', 'd', '0'};
w o
r
d
0
56

57. Operazioni su stringhe C
char str1[32]; / str1 ha spazio per 32 char. /
char str2[64]; / str2 ha spazio per 64 char. /
/ assegna a str1 la stringa "alfa" /
strcpy(str1, "alfa");
/ str1 contiene "alfa"
/
/ copia str1 in str2 /
strcpy(str2, str1);
/ str2 contiene "alfa"
/
/ lunghezza di str1 /
x = strlen(str1);
/
/ x assume valore 4
/ scrivi str1 su standard output /
cout << str1;
/ scrive str1 su stdout /
/ leggi str1 da standard input /
cin >> str1;
/ legge str1 da stdin /
57

58. Problemi con le stringhe C
• Inizializzazione e accesso ai singoli caratteri:
char stringa[]  "word";
stringa[3] è un‟espressione di valore 'd'
•
cin >> stringa;
• Questa istruzione legge dall'input i caratteri fino a
quando trova il carattere “blank” (lo spazio), o l‟invio
• Perciò se in input si inserisce una stringa troppo lunga,
essa è memorizzata oltre la fine dell'array !!! Ed è un
errore grave !!!
58

59. strcpy(s1, s2)
• E se non ci fosse la funzione strcpy()?
– Assegneremmo sempre un carattere alla volta
char s1[N], s2[M];
…
int i = 0;
while( i <= strlen(s2) && i < N ) {
s1[i] = s2[i];
++i;
}
N.B. funziona correttamente se s2 è una
stringa ben formata (terminata da ‘0’) e s1
è sufficientemente grande (N >= strlen(s2))
59

60. Confrontare due stringhe
• Una funzione apposita: strcmp(s1,s2)
– restituisce un intero
– confronta le due stringhe fino al terminatore „0‟
char str1[32], str2[64];
int diverse;
/*... acquisizione di valori per le stringhe ... (codice
omesso)*/
ris = strcmp(str1, str2);
if (ris == 0)
cout << "UGUALIn";
else if ( ris < 0 )
cout << str1 << "MINORE DI" << str2;
else
cout << str1 << "MAGGIORE DI" << str2;
• Da confrontare con l'uso diretto degli operatori relazionali nel tipo
string

61. I "livelli di astrazione" del C++
• I linguaggi di programmazione hanno
diversi livelli di astrazione dall'architettura
del calcolatore
– Linguaggi di alto livello ( C, C++, Java..)
– Assembler
– Linguaggio macchina
• Ma anche all'interno di un linguaggio di
alto livello si possono distinguere diversi
ulteriori livelli di astrazione
• Il C++ è un buon esempio
61

62. Astrazione: confront0 string - array
Array
String
• Simile alla struttura fisica della
memoria: insieme di celle
contigue
• Dimensione prefissata
• Simulazione della variabilità
mediante terminatore 0
• Accesso mediante
indicizzazione esplicita
• Assegnamento non definito
• Operatori relazionali non
definiti
• Errori di fuoriuscita dai limiti e
assenza del terminatore
• Sequenza di elementi
• Dimensione non predefinita
• Mascheramento dei dettagli
interni
• Accesso mediante cursore,
compatibilità con l'accesso per
indicizzazione
• Assegnamento e operatori
relazionali predefiniti nel tipo
• Protezione da errori di
fuoriuscita
• Terminatore non necessario
62

63. Typedef
• C e C++ mettono disposizione un meccanismo per definire
"tipi nuovi": typdef
• Combinando typedef e costruttore di array:
typedef char venticaratteri[20];
• si introduce un nuovo tipo, venticaratteri, il tipo degli
array di 20 elementi di tipo char
• La dichiarazione
venticaratteri nome, cognome;
• usa venticaratteri come sinonimo di char[20]
• Attenzione!!
– venticaratteri ha le stesse identiche proprietà e limitazioni di
char[20]
– È solo una scrittura più leggibile per il programmatore, che rende
più facile modificare i programmi (pe: per cambiare la
dimensione del tipo, agendo su una sola definizione)