Stringhe: vettori di caratteri con terminatore L applicazione più comune degli array ad una dimensione è la creazione di stringhe 1. Nel linguaggio C++ tradizionale una stringa viene definita come un array di caratteri che finisce con un terminatore NULL. Un NULL viene specificato come \0 e ha valore zero. E pertanto necessario che un array di caratteri venga dichiarato più grande di una unità rispetto alla stringa più lunga che deve contenere. Il compilatore C++ aggiunge automaticamente il terminatore se si dichiara una variabile come costante stringa cioè racchiudendola tra doppi apici. Pertanto, se si deve dichiarare una stringa s che deve contenere la parola Ciao si userà la sintassi: ed effetto in memoria E possibile accedere ai singoli elementi (caratteri identificati da singolo apice) ed eventualmente modificarli. Il ciclo seguente, ad esempio, modifica tutti i caratteri della stringa s sostituendoli col carattere w : 1 Stringa: in informatica una sequenza di caratteri alfanumerici, p.es. una parola, una frase. Di solito la stringa è terminata da un carattere speciale (p.es. il carattere 0 del codice ASCII).
Uso di stringhe: vettori di caratteri con terminatore /*=============================================================================== Si vuole giocare al gioco dell'impiccato. Il conduttore del gioco propone una parola che rimane segreta e di cui la lunghezza e' nota. Lo scopo che si vuole raggiungere è indovinare la parola in un numero di tentativi fissato. Il giocatore propone una lettera: se è contenuta nella parola segreta, il conduttore del gioco la scrive su monitor in tutte le posizioni in cui compare nella parola. Il giocatore vince se riesce ad indovinare con un numero di tentativi inferiori o uguali al numero prefissato. ================================================================================*/ #include <cstring> // uso di strlen() che ritorna la lunghezza della stringa (eccettuato il terminatore NULL) // uso di strcmp() che confronta due stringhe carattere per carattere #include <cctype> // o <cstdlib> o <ctype.h> per tolower() per formato dei caratteri minuscolo int main() const int DIM = 7; const int tentativi = DIM-1; // numero dei tentativi pari al numero di lettere della parola char ch; int i, num = 0; // inizializzo contatore dei tentativi fatti char parola[dim] = "...", // una stringa termina con NULL espresso come intero cioè '\0' segreta[] = 'c','i', 'c', 'c', 'i','o','\0'; cout << "\nla lunghezza della parola e' di "; cout << strlen(segreta) <<" lettere\n"; cout << "\nhai " << tentativi <<" tentativi\n"; while(num<tentativi) cout << "\n\nimposta un carattere: "; cin >> ch; ch= tolower(ch); for (i=0; i< DIM-1; i++) if (ch == segreta[i]) parola[i] = segreta[i]; cout << parola[i]; num++; int result = strcmp(parola, segreta); if(result == 0) cout <<"\n\nbravo\n\n"; if (num >= tentativi) cout <<"\n\nla parola era "; for (i=0; i< DIM-1; i++) cout << segreta[i]; cout << endl << endl; cin.ignore (DIM, '\n'); // aggiorno numero tentativi // ignora il formato dei caratteri (minuscolo/maiuscolo)
/*=================================================================================== ordinamento per ordinare si INTENDA in modo CRESCENTE: Modo: BUBBLE SORT per ordine alfabetico facendo affiorare i valori minimi con continui confronti e scambi tra due elementi consecutivi; la prima scansione considera gli elementi con indice N ed N-1. - con uso di "enum" che consente di associare nomi simbolici a numeri interi raggruppandoli in unico insieme ad esempio enum NO, SI Ordinato dichiara: una variabile di nome Ordinato di tipo enumerazione e il compilatore associerà automaticamente una serie di interi crescenti iniziando da zero per realizzare il costrutto: fai... mentre (NON E' Ordinato) NB: caso peggiore è sequenza ordinata in ordine inverso dove N confronti = N*(N-1)/2 come per selection ===================================================================================*/ #include <cstring> #define N 20 void Acquisisci(); void Ordina(); void Stampa(); char Dati[N]; int main() cout << "\n\t\t\t\tbubble SORT\n\n"; Acquisisci(); cout << "\n\t\t\t*** Prima dell'ordinamento ***\n\n"; Stampa (); Ordina(); cout << "\n\t\t\t*** Dopo l'ordinamento ***\n\n"; Stampa (); cin.ignore (N, '\n');
void Acquisisci () cout << "Scrivi la stringa [massimo "<< N-2 << " caratteri] : "; cin >> Dati; void Ordina() enum NO, SI Ordinato; int fine = strlen(dati), Top = (fine-1), Bottom =0, i, posizione; char minimo; posizione = Bottom; do Ordinato = SI; for (i = Top; i>posizione; i--) // elementi superiore e inferiore // del vettore da ordinare // come una freccia che indica il livello di ordinamento // raggiunto scansione dopo scansione // carattere minimo if (Dati[i]<Dati[i-1]) minimo = Dati[i]; // scambio Dati[i] = Dati[i-1]; Dati[i-1]= minimo; Ordinato = NO; posizione++; while(!ordinato); void Stampa() int i; cout << "Vettore dei dati\n"; for (i = 0; i<n-1; i++) if (Dati[i] == '\0') cout << "Dati[" << i << "] = " << Dati[i] << "\n"; cout << "\n\n";
/*=================================================================================== Ordinamento per ordine alfabetico (si INTENDA in modo CRESCENTE): Modo: Selection Sort cioè ordinamento per selezione di tipo "per minimi successivi" NB: Numero confronti = N*(N-1)/2 ===================================================================================*/ #include <cstring> #define N 20 void Acquisisci(); void Ordina(); void Stampa(char[]); char Dati[N], ordinato[n]; int fine; // prototipi di funzioni // visibilità globale // lunghezza effettiva della stringa int main() cout << "\n\t\t\t\tselection SORT\n\n"; Acquisisci(); cout << "\n\t\t\t*** Prima dell'ordinamento ***\n\n"; Stampa (Dati); Ordina(); cout << "\n\t\t\t*** Dopo l'ordinamento ***\n\n"; Stampa (ordinato); cin.ignore (N, '\n'); void Acquisisci () cout << "Scrivi la stringa [massimo "<< N-2 << " caratteri] : "; cin >> Dati; fine = strlen (Dati); void Ordina() char minimo = Dati[0]; // carattere minimo provvisorio for (int z = 0; z <fine; z++) // indice di posizione per l ordinamento for (int i = 0; i< fine-1; i++) if ( Dati[i+1] < minimo) minimo = Dati[i+1]; // ricerca minimo ordinato[z] = minimo; // si memorizza nella posizione for (int j = 0; j<fine; j++) // soluzione ingenua con "eliminazione" invece di scambio di posizione if (Dati[j] == minimo) Dati[j] = ' '; // unico carattere da eliminare sostituendolo con carattere 124 ASCII minimo = Dati[0]; // carattere minimo provvisorio void Stampa(char D[]) cout << "Vettore dei dati\n"; for (int i = 0; i<fine; i++) cout << "Dati[" << i << "] = " << D[i] << "\n"; cout << "\n\n";