![Page 1: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/1.jpg)
STRINGHE DI CARATTERI
Una stringa di caratteri in C è un array di ca-ratteri terminato dal carattere '\0'
Un vettore di N caratteri può dunque ospitarestringhe lunghe al più N-1 caratteri, perchéuna cella è destinata al terminatore '\0'.
a p e \0s0 1 2 3
![Page 2: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/2.jpg)
STRINGHE DI CARATTERI
Un array di N caratteri può ben essere usatoper memorizzare stringhe più corte
In questo caso, le celle oltre la k-esima (k essendo lalunghezza della stringa) sono concettualmente vuote:praticamente sono inutilizzate e contengono un valo-re casuale.
d i \0s0 1 2 3
![Page 3: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/3.jpg)
STRINGHE DI CARATTERI
Una stringa di caratteri si può inizializzare, come ogni altro array, elencando le singolecomponenti:
char s[4] = {'a', 'p', 'e', '\0'};
oppure anche, più brevemente, con la formacompatta seguente:
char s[4] = "ape" ;Il carattere di terminazione ‘\0’ è automaticamenteincluso in fondo. Attenzione alla lunghezza!
![Page 4: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/4.jpg)
ESEMPIO
Problema: Data una stringa di caratteri, calcolarne la lunghezza.
Ipotesi: La stringa è “ben formata”, ossia correttamente terminata dal carattere ‘\0’.
Specifica:• scandire la stringa elemento per elemento, fino a trovare
il terminatore ‘\0’ (che esiste certamente)• il risultato è l’indice corrispondente al terminatore.
![Page 5: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/5.jpg)
ESEMPIO
int lunghStr( char s[] ) {
int lung=0;
for (lung=0; s[lung]!='\0'; lung++);
return lung;
}
Non occorre dare una dimensioneesplicita, data la presenza
del terminatore.
![Page 6: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/6.jpg)
Nel trasferimento di una stringa ad una procedurao funzione, non occorre un argomento intero che rappresenta la dimensione logica, data la presenza per ipotesi del terminatore
Esempio: LUNGHEZZA DI UNA STRINGA
int lunghStr( char s[] ) {
int lung=0;
for (lung=0; s[lung]!='\0'; lung++);
return lung;
}
![Page 7: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/7.jpg)
ESEMPIO
Problema: Data una stringa di caratteri, copiarla in un altro array di caratteri (di lunghezza non inferiore).
Ipotesi: La stringa è “ben formata”, ossia correttamente terminata dal carattere ‘\0’.
Specifica:• scandire la stringa elemento per elemento, fino a
trovare il terminatore ‘\0’ (che esiste certamente)• nel fare ciò, copiare l’elemento nella posizione
corrispondente dell’altro array.
![Page 8: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/8.jpg)
void copiaStr( char s1[],char s2[] ) {
//IPOTESI:
//1) s1 e s2 hanno la stessa dimensione fisica
//2) s1 è l’ingresso, s2 è l’uscita
int i=0;
for (i=0; s1[i]!='\0'; i++)s2[i] = s1[i];
s2[i] = '\0';
}
Al termine, occorre garantireche anche la nuova stringa
sia “ben formata”, inserendoesplicitamente il terminatore.
![Page 9: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/9.jpg)
Problema
Data una stringa, copiarla in un array di caratteri, con eventuale troncamento se la stringa è più lunga dell’array dato.
Specifica:• scandire la stringa elemento per elemento, o fino a
trovare il terminatore ‘\0’ (che esiste certamente), o fino alla lunghezza dell’array di destinazione (-1)
• nel fare ciò, copiare l’elemento nella posizione corrispondente dell’altro array.
![Page 10: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/10.jpg)
ESEMPIO
Codifica:
#define N 20
main() {
char s[] = "Nel mezzo del cammin di";
char s2[N];
int i=0;
for (i=0; s[i]!='\0' && i<N-1; i++)s2[i] = s[i];
s2[i] = '\0';
}
Si prosegue solo se non si èincontrato il terminatore e inoltrec’è spazio nell’array destinazione
La condizione è i<N-1 perchédeve rimanere uno spazio per ‘\0’
![Page 11: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/11.jpg)
ESEMPIO
Problema: Date due stringhe di caratteri, decidere quale precede l’altra in ordine alfabetico.
Rappresentazione dell’informazione:• poiché vi possono essere tre risultati (s1<s2,
s1==s2, s2<s1), un boolean non basta• possiamo usare:
– due boolean (uguale e precede)– tre boolean (uguale, s1precedes2, s2precedes1)– un intero (negativo, zero, positivo)
scegliamo la terza via.
![Page 12: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/12.jpg)
ESEMPIO
Problema: Date due stringhe di caratteri, decidere quale precede l’altra in ordine alfabetico.
Specifica:• scandire uno ad uno gli elementi di egual posizione
delle due stringhe, o fino alla fine delle stringhe, o fino a che se ne trovano due diversi– nel primo caso, le stringhe sono uguali– nel secondo, sono diverse
• nel secondo caso, confrontare i due caratteri così trovati, e determinare qual è il minore– la stringa a cui appartiene tale carattere precede l’altra
![Page 13: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/13.jpg)
ESEMPIO
Codifica:
main() {
char s1[] = "Sempre caro mi fu quell’\ermo colle";
char s2[] = "Sempre odiai quell’orrido\colle";
int i, stato;
for (i=0; s1[i]!='\0' && s2[i]!='\0' && s1[i]==s2[i] ; i++);
stato = s1[i]-s2[i];
}negativo s1 precede s2positivo s2 precede s1zero s1 è uguale a s2
la costante stringa continua a capo
![Page 14: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/14.jpg)
UNA RIFLESSIONE
Nell’esempio della copiatura:
Data una stringa di caratteri, copiarla in un altro array di caratteri (di lunghezza non inferiore).
abbiamo deciso di copiare la stringa nell’ar-ray carattere per carattere.
Avremmo potuto fare diversamente?
Perché non copiarla “tutta in un colpo”?
![Page 15: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/15.jpg)
IL CONTROESEMPIO
Perché non fare così?
main() {
char s[] = "Nel mezzo del cammin di";
char s2[40];
s2 = s;}
Perché non dovrebbefunzionare???
PERCHÉ GLI ARRAY NON POSSONOESSERE MANIPOLATI “IN TOTO” !
![Page 16: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/16.jpg)
IL CONTROESEMPIO
Perché non fare così?
main() {
char s[] = "Nel mezzo del cammin di";
char s2[40];
s2 = s;} ERRORE DI COMPILAZIONE:
incompatible types in assignment !!
![Page 17: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/17.jpg)
ARRAY “VISTI DA VICINO”
Concettualmente, un array è una collezionefinita di N variabili dello stesso tipo, ognunaidentificata da un indice compreso fra 0 e N-1
v0 1 2 3
v[0]
v[1] v[2]
v[3]
Praticamente, le cose non stanno proprio così.
![Page 18: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/18.jpg)
ARRAY “VISTI DA VICINO”
In C un array è in realtà un puntatore costanteche punta a un’area di memoria pre-allocata,di dimensione prefissata.
Pertanto, il nome dell’array è un sinonimoper il suo indirizzo iniziale: v &v[0]
v
0 1 2 3
![Page 19: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/19.jpg)
CONSEGUENZA
Il fatto che il nome dell’array indichi
• non l’array in sé,
• ma l’indirizzo iniziale dell’area di memoria ad esso associata
ha una importante conseguenza:
È impossibile denotare un array nellasua globalità, in qualunque contesto.
![Page 20: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/20.jpg)
CONSEGUENZA
Quindi, non è possibile:
• assegnare un array a un altro (s2 = s)
• che una funzione restituisca un array
E soprattutto:
• passare un array come parametro a una funzione non significa affatto passare l’intero array !!
![Page 21: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/21.jpg)
IL CONTROESEMPIO
Ecco perché non si compilava!
main() {
char s[] = "Nel mezzo del cammin di";
char s2[40];
s2 = s;}
Questo assegnamento viene interpretato come il tentativo di cambiare l’indirizzo
iniziale della stringa s2, cosa eviden-temente impossibile !!!
![Page 22: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/22.jpg)
ARRAY PASSATI COME PARAMETRI
Poiché un array in C è un puntatore costanteche punta a un’area di memoria pre-allocata,di dimensione prefissata, il nome dell’array:
• non rappresenta l’intero array
• è un alias per il suo indirizzo iniziale (v &v[0] )
v
0 1 2 3
![Page 23: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/23.jpg)
ARRAY PASSATI COME PARAMETRI
Quindi, passando un array a una funzione:
• non si passa l’intero array !!
• si passa solo (per valore!) il suo indirizzo iniziale (v &v[0] )
v
0 1 2 3
w
![Page 24: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/24.jpg)
ARRAY PASSATI COME PARAMETRI
Conclusione:
• agli occhi dell’utente, l’effetto finale è che l’array passa per riferimento!!
v
0 1 2 3
w
![Page 25: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/25.jpg)
CONCLUSIONE
A livello fisico:
• il C passa i parametri sempre e solo per valore
• nel caso di un array, si passa il suo indiriz-zo iniziale (v &v[0] ) perché tale è il significato del nome dell’array
A livello concettuale: • il C passa per valore tutto tranne gli array,
che vengono trasferiti per riferimento.
![Page 26: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/26.jpg)
ESEMPIO
Problema: Data una stringa di caratteri, scrivere una funzione che ne calcoli la lunghezza.
Codifica:
int lunghezza(char s[]) {
int lung=0;
for (lung=0; s[lung]!='\0'; lung++);
return lung;
} La dimensione non serve, perchétanto viene passato solo l’indirizzo
iniziale (non tutto l’array)
![Page 27: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/27.jpg)
UN’ALTRA RIFLESSIONE
• Ma se quello che passa è solo l’indirizzo iniziale dell’array, che è un puntatore...
• ...allora tanto vale adottare direttamente la notazione a puntatori nella intestazione della funzione!!
In effetti, l’una o l’altra notazione sono, a livel-lo di linguaggio, assolutamente equivalenti
– non cambia niente nel funzionamento– si rende solo più evidente ciò che accade
comunque
![Page 28: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/28.jpg)
ESEMPIO
Da così...
int lunghezza(char s[]) {int lung=0;for (lung=0; s[lung]!='\0'; lung++);return lung;
}
… a così:
int lunghezza(char *s) {int lung=0;for (lung=0; s[lung]!='\0'; lung++);return lung;
}
Per il C è identico!!
![Page 29: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/29.jpg)
UN’ULTIMA RIFLESSIONE
Ma se le due notazioni
char *s char s[]sono identiche agli occhi del compilatore,
Cosa possiamo dire dei due operatori * e [] ?
C’è qualche relazione?
![Page 30: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/30.jpg)
OPERATORI DI DEREFERENCING
• L’operatore *, applicato a un puntatore, accede alla variabile da esso puntata
• L’operatore [], applicato a un nome di array e a un intero i, accede alla i-esima variabile dell’array
Sono entrambi operatori di dereferencing
*v v[0]
![Page 31: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/31.jpg)
ARITMETICA DEI PUNTATORI
• Oltre a *v v[0], vale anche:
*(v+1) v[1]...
*(v+i) v[i]• Espressioni della forma p+i vanno sotto il
nome di aritmetica dei puntatori, e denota-no l’indirizzo posto i celle dopo l’indirizzo denotato da p (celle, non bytes!)
![Page 32: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/32.jpg)
ARITMETICA DEI PUNTATORI
Più in generale:
• se p è un puntatore a T, e n è un intero positivo, l’espressione
p+ndenota un altro puntatore a T, che punta “n celle dopo” l’indirizzo puntato da p
• Se n è negativo, la cella denotata da p+n in realtà precede di n posizioni quellapuntata da p.
![Page 33: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/33.jpg)
ARITMETICA DEI PUNTATORI
q = p+n (n>0)
p
q
+n*size
size
![Page 34: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/34.jpg)
ARITMETICA DEI PUNTATORI
Analogamente,
• se q e p sono puntatori a T, l’espressioneq-p
denota un intero, che rappresenta il numero di celle comprese fra q e p
• se q precede p, l’intero denotato è negativo.
NB: somme di puntatori, come p+q, sono illegaliin quanto prive di significato.
![Page 35: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/35.jpg)
CONCLUSIONE
• Gli operatori * e []sono intercambiabili
*(v+i) v[i]
• Ne basterebbe uno solo: il C li fornisce entrambi solo per nostra comodità– in effetti, operare sui vettori scrivendo *(v+i)
sarebbe poco pratico!
• Internamente, il compilatore C converte ogni espressione con [] nella corrispon-dente espressione con *
![Page 36: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/36.jpg)
ESEMPIO
Problema: Scrivere una funzione che, dato un array di N interi, ne calcoli il massimo.
Si tratta di riprendere l’esercizio già svolto, e impostare la soluzione come funzione anziché codificarla direttamente nel main.
Dichiarazione della funzione:
int findMax(int v[], int dim);
![Page 37: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/37.jpg)
ESEMPIO
Il cliente:
main() {
int max, v[] = {43,12,7,86};
max = findMax(v, 4);
}
Trasferire esplicitamente la dimensionedell’array è NECESSARIO, in quanto la
funzione, ricevendo solo l’indirizzoiniziale, non avrebbe modo di sapere
quanto è lungo l’array !
![Page 38: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/38.jpg)
ESEMPIO
La funzione:
int findMax(int v[], int dim) {
int i, max;
for (max=v[0], i=1; i<dim; i++)if (v[i]>max) max=v[i];
return max;
}
![Page 39: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/39.jpg)
ESEMPIO
La funzione:
int findMax(const int v[], int dim) {
int i, max;
for (max=v[0], i=1; i<dim; i++)if (v[i]>max) max=v[i];
return max;
}Per evitare che la funzione modifichi l’array(visto che è passato per riferimento), si può
imporre la qualifica const Se lo si tenta: cannot modify a const object
![Page 40: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/40.jpg)
ESEMPIO
La funzione:
int findMax(const int *v, int dim) {
int i, max;
for (max=v[0], i=1; i<dim; i++)if (v[i]>max) max=v[i];
return max;
}Volendo si può usare anche la
notazione a puntatore: tanto, per il linguaggio sono equivalenti!!
… e la si può anche mischiare con l’altra!
![Page 41: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/41.jpg)
ESEMPIO
Problema: Data una stringa di caratteri, scrivere una funzione che ne calcoli la lunghezza.
Codifica:
int lunghezza(char s[]) {
int lung=0;
for (lung=0; s[lung]!='\0'; lung++);
return lung;
}Nel caso delle stringhe, la dimensione non serve perché può essere dedotta dalla posizione dello ‘\0’
![Page 42: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/42.jpg)
UNA VARIANTE
Da così...
int lunghezza(char *s) {int lung=0;for (lung=0; s[lung]!='\0'; lung++);return lung;
}
… a così:
int lunghezza(char *s) {char *s0 = s;while (*s!='\0') s++;return s-s0;
}
Sfrutta il fatto ches è una copia del-l’indirizzo inizialedella stringa, ergosi può modificare!
Sfrutta l’aritmetica dei puntatori
![Page 43: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/43.jpg)
UNA VARIANTE “DA HACKER”
Uno hacker la compatterebbe prima così...
int lunghezza(char *s) {char *s0 = s;while (*s) s++;return s-s0;
}
… e poi così:
int lunghezza(char *s) {char *s0 = s;while (*s++);return s-s0;
}
Il test “diverso da 0”è tautologico!
Il post-incremento puòessere inglobato.
![Page 44: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/44.jpg)
ESEMPIO
Problema: Scrivere una procedura che copi una stringa in un’altra.
Codifica:
void strcpy(char dest[], char source[]) {
while (*source) { *dest = *(source++);}
*dest = '\0';
}
![Page 45: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/45.jpg)
LIBRERIA SULLE STRINGHE
Il C fornisce una nutrita libreria di funzioniper operare sulle stringhe:
#include < string.h >
Include funzioni per:• copiare una stringa in un’altra (strcpy)• concatenare due stringhe (strcat)• confrontare due stringhe (strcmp)• cercare un carattere in una stringa (strchr)• cercare una stringa in un’altra (strstr)• ...
![Page 46: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/46.jpg)
ARRAY MULTIDIMENSIONALI
È anche possibile definire matrici e, più ingenerale, array a più dimensioni
int matrice[N][M];• N indica il numero di righe
– numerate da 0 a N-1
• M indica il numero di colonne– numerate da 0 a M-1
![Page 47: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/47.jpg)
ARRAY MULTIDIMENSIONALI
Per selezionare la cella di indici i, j:
x = matrice[i][j];Attenzione:• matrice[i,j] ha un altro significato!!
– l’espressione i,j denota un solo numero (j),non la coppia di indici necessaria!
• matrice[k] denota l’intera riga k– non c’è modo di denotare un’intera colonna
![Page 48: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/48.jpg)
ARRAY MULTIDIMENSIONALI
Esempio (somma elementi di una matrice)
main(){
float m[4][4] = { {1,2,3,4}, {5,6,7,8}, {4,3,2,1},
{9,8,7,6}};
float somma = 0;
int i,j;
for (i=0;i<4;i++)for (j=0;j<4;j++) somma += m[i][j];
}
![Page 49: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/49.jpg)
ARRAY MULTIDIMENSIONALI
E per passarli a una funzione?• il C passa sempre solo l’indirizzo iniziale• però, nella funzione occorre specificare
tutte le dimensioni successive alla prima
int f(int mm[4][4], int n, int m) { ... }
int f(int *mm[4], int n, int m) { ... }
![Page 50: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/50.jpg)
ARRAY MULTIDIMENSIONALI
Perché occorre specificare le dimensionisuccessive alla prima?• perché un array multidimensionale è, di
fatto, un array di array– è visto come un array di N “cose”, ciascuna
delle quali, in effetti, è un altro array
• per distinguere dove cominciano le diverse righe, bisogna sapere quanto sono grandi le singole colonne– bisogna perciò sapere quante sono le colonne
![Page 51: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/51.jpg)
STRUTTURE
Una struttura è una collezione finita di varia-bili non necessariamente dello stesso tipo,ognuna identificata da un nome.
struct persona nome
stringa di 20 char
età
stipendio
un intero
un float
![Page 52: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/52.jpg)
STRUTTURE
Una struttura è una collezione finita di varia-bili non necessariamente dello stesso tipo,ognuna identificata da un nome.
Definizione di una variabile di tipo struttura:
struct [<etichetta>] { { <definizione-di-variabile> }
} <nomeStruttura> ;
![Page 53: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/53.jpg)
STRUTTURE - ESEMPIO
struct persona {char nome[20];int eta;float stipendio;
} pers ;
struct persona nome
stringa di 20 char
età
stipendio
un intero
un float
Definisce una variabilepers strutturata nel
modo illustrato.
![Page 54: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/54.jpg)
ESEMPI
struct punto {int x, y;
} p1, p2 ;
struct data {int giorno,mese,anno;
} d ;
p1 e p2 sono fatteciascuna da due interi
di nome x e y
d è fatta da tre interidi nome giorno, mese e anno
![Page 55: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/55.jpg)
STRUTTURE
Una volta definita una variabile struttura, si accede ai singoli campi mediante lanotazione puntata.
Ad esempio:
p1.x = 10; p1.y = 20;
p2.x = -1; p2.y = 12;
d.giorno = 25;d.mese = 12;d.anno = 1999;
Ogni campo si comportae si usa come unanormale variabile.
![Page 56: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/56.jpg)
UN ALTRO ESEMPIO
main(){
struct frutto {char nome[20]; int peso;
} f1;struct frutto f2 ;
...
}Non occorre ripetere l’elencodei campi perché è implicito
nell’etichetta frutto, cheè già comparsa sopra.
![Page 57: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/57.jpg)
ESEMPIO
main(){
struct frutto {char nome[20]; int peso;
} f1 = {"mela", 70};struct frutto f2 = {"arancio", 50};
int peso = f1.peso + f2.peso;
} Non c’è alcuna ambiguità perché ogni variabile di nome peso è definita nel
proprio environment.
![Page 58: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/58.jpg)
UNA PRECISAZIONE
A differenza di quanto accade con gli array, il nome della struttura rappresenta la strut-tura nel suo complesso.
Quindi, è possibile:• assegnare una struttura a un’altra (f2 = f1)• che una funzione restituisca una struttura
E soprattutto:
• passare una struttura come parametro a una funzione significa passare una copia
![Page 59: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/59.jpg)
ASSEGNAMENTO FRA STRUTTURE
main(){
struct frutto {char nome[20]; int peso;
} f1 = {"mela", 70};struct frutto f2 = {"arancio", 50};
f1 = f2;
}Equivale a copiare f2.peso in f1.peso, e f2.nome in f1.nome.
![Page 60: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/60.jpg)
STRUTTURE PASSATE COME PARAMETRI
• Il nome della struttura rappresenta, come è naturale, la struttura nel suo complesso– niente scherzi come con agli array…!!
• quindi, non ci sono problemi nel passarle a come parametro a una funzione: avviene il classico passaggio per valore
• è perciò possibile anche restituire come risultato una struttura
• tutti i campi vengono copiati, uno per uno!
![Page 61: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/61.jpg)
ESEMPIO
struct frutto macedonia(struct frutto f1, struct frutto f2){
struct frutto f;f.peso = f1.peso + f2.peso;strcpy(f.nome, "macedonia");return f;
}La funzione di libreria strcpy() copia lacostante stringa “macedonia” in f.nome.
Si crea una nuova struct frutto, la si inizializza e la si restituisce come risultato.
![Page 62: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/62.jpg)
RIFLESSIONE
Se una struttura, anche molto voluminosa,viene copiata elemento per elemento..... perché non usare una struttura per
incapsulare un array?
In effetti:• il C non rifiuta di manipolare gli array come un
tutt’uno “per principio”: è solo la conseguenza del modo in cui si interpreta il loro nome
• quindi, “chiudendoli in una struttura” dovremmo riuscirci!
![Page 63: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/63.jpg)
E INFATTI...
main(){
struct string20 {char s[20];
} s1 = {"Paolino Paperino" }, s2 = {"Gastone Fortunato" };
s1 = s2; /* FUNZIONA!! */
}
![Page 64: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/64.jpg)
STRUTTURE CHE RACCHIUDONO ARRAY
Usando una struttura per “racchiudere” unarray, si fornisce all’array esattamente quelloche gli mancava:
un modo per denotare “il tutto”ossia
un “contenitore” dotato di nome,che consenta di riferirsi all’array
nella sua globalità.
![Page 65: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/65.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
Come si è detto più volte, il main è unafunzione come le altre:
• ha un nome convenzionale, fissato
• è la funzione invocata per far partire il programma.
Ma… CHI LA INVOCA?
Visto che è una funzione, HA DEI PARAMETRI?
![Page 66: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/66.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
Il main è una funzione
• invocata dal sistema operativo
• cui è passato un array di stringhe
• che corrispondono agli argomenti scritti dall’utente sulla linea di comando
Esempio di invocazione da linea di comando:
C:> prog pippo 12 paperino 23
I° argomentonome delprogramma
II° argomento III° argomento
IV° argomento
![Page 67: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/67.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
Perciò, main ha due parametri:
• un intero che rappresenta la lunghezza dell’array– int argc (argument counter)
• l’array di stringhe vero e proprio (ovvia-mente, si passa il suo indirizzo iniziale)– char* argv[] (argument vector)
Ogni elemento dell’array è un puntatore a carattere,che punta a uno degli argomenti della linea di comando.
![Page 68: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/68.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
Quindi, l’interfaccia completa del main è la seguente:
int main(int argc, char* argv[])
Se non servono, argc e argv possono essere omessi, nel qual caso il main assume la forma semplificata già nota:
int main()
Valore di ritorno: può essere usato per restituire al SistemaOperativo un codice numerico di errore.Convenzione: 0 = OK, ogni altro valore = un tipo di errore
![Page 69: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/69.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
• argv[0] è il nome del programma stesso• da argv[1] ad argv[argc-1] vi sono
gli argomenti passati, nell’ordine• argv[argc] è per convenzione NULL
argv argv[0]"prog""pippo""12"
"paperino""23"(NULL)
argv[1]argv[2]argv[3]argv[4]
argc 5
![Page 70: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/70.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
• argv[0] è il nome del programma stesso• da argv[1] ad argv[argc-1] vi sono
gli argomenti passati, nell’ordine• argv[argc] è per convenzione NULL
argv argv[0]"prog""pippo""12"
"paperino""23"(NULL)
argv[1]argv[2]argv[3]argv[4]
argc 5
Attenzione: sono aree del sistema operativo disponibili solo in lettura
![Page 71: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/71.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
Problema:
Come passare argomenti dalla linea di comando… quando non c’è una linea di comando, come negli ambienti di sviluppo integrati (DJGPP / Turbo C) ?
C:> prog pippo 12 paperino 23
Esiste un’apposita opzione da menù.
![Page 72: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/72.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
In Turbo C: Options / Environment / Debugger
![Page 73: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/73.jpg)
ARGOMENTI DALLA LINEA DI COMANDO
In RHide: Run / Arguments...
![Page 74: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/74.jpg)
ESEMPIO 1
Problema:
Scrivere un programma che analizzi gli argomenti passati dalla linea di comando, e restituisca il numero di lettere minuscole.
Specifica:
Per ogni argomento da 1 ad argc-1, occorre:• recuperare l’argomento (una stringa)• contare le minuscole presenti in tale stringa• sommare questo valore alla variabile che
rappresenta il numero totale di minuscole.
Alla fine si restituisce il valore di tale variabile.
![Page 75: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/75.jpg)
ESEMPIO 1
Codifica
int contaMinuscole(char s[]);
int main(int argc, char* argv[]) { int sum=0, i; for(i=1; i<argc; i++)
sum += contaMinuscole(argv[i]); return sum;
}
![Page 76: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/76.jpg)
ESEMPIO 1
Codifica
#include <ctype.h> /* islower() */
int contaMinuscole(char *s){ int n=0; while (*s) if (islower(*s++)) n++; return n;}
![Page 77: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/77.jpg)
ESEMPIO 2Problema:
Scrivere un programma che, dati un carattere e una stringa sulla linea di comando, conti quante volte il carattere compare nella stringa (sia in versione maiuscola che minuscola), e restituisca questo valore come risultato del main.
Specifica:• occorre in primis recuperare gli argomenti• poi, si scandisce la stringa carattere per carattere
e si contano le occorrenza del carattere dato (facendo attenzione alle maiuscole e minuscole)
Alla fine si restituisce il risultato di tale conteggio.
![Page 78: STRINGHE DI CARATTERI Una stringa di caratteri in C è un array di ca- ratteri terminato dal carattere '\0' Un vettore di N caratteri può dunque ospitare](https://reader036.vdocuments.mx/reader036/viewer/2022062702/5542eb73497959361e8da5d8/html5/thumbnails/78.jpg)
ESEMPIO 2
Codifica
#include <ctype.h>
int main(int argc, char* argv[]) { int cont=0; char ch = toupper(argv[1][0]); char *s = argv[2]; while (*s) if (toupper(*s++)==ch) cont++; return cont;}