INFORMATICA Sottoprogrammi

© Piero Demichelis 2 Sottoprogrammi Quando si scrive un programma succede spesso che si debba eseguire numerose volte una stessa sequenza di istruzioni, sugli stessi dati o su dati diversi. Supponiamo di dover realizzare un programma per il gioco degli scacchi: ogni volta che si esegue una mossa i pezzi devono essere ridisegnati o nella stessa posizione o nella nuova posizione conseguente alla mossa. Per evitare di riscrivere più volte queste sequenze di istruzioni e per limitare le dimensioni dei programmi, il linguaggio C dispone di una particolare struttura chiamata funzione

© Piero Demichelis 3 Sottoprogrammi Altra giustificazione allesistenza dei sottoprogrammi deriva dal fatto che un programma può consistere di decine di migliaia di istruzioni. Sebbene fattibile, una soluzione monolitica del problema è inefficiente in quanto complicata da collaudare (debuggare ) e difficile da leggere. Per questo si tende a organizzare il programma complessivo in moduli ognuno dei quali tratta e risolve solo una parte del problema. In altre parole si adotta, per la soluzione del problema, il cosiddetto approccio top-down

© Piero Demichelis 4 Sottoprogrammi Una funzione è un modulo di programma la cui esecuzione può essere invocata più volte nel corso del programma principale. In generale, al suo interno viene calcolato un valore che sarà comunicato al programma chiamante al termine dell'esecuzione della funzione. Il nome funzione deriva dall'evidente analogia con le funzioni intese in senso matematico. Poiché la funzione fornisce un valore, ad essa è associato un tipo.

© Piero Demichelis 5 Funzioni La forma generale è: tipo nome_funzione (parametro_1; ; parametro_n) { /* definizione delle costanti e delle variabili usate nella funzione */ /* istruzioni della funzione */ return (valore) } L'istruzione return provoca la restituzione del controllo al programma chiamante nel quale valore viene associato al nome della funzione che pertanto appare come una normale variabile.

© Piero Demichelis 6 Funzioni La struttura è del tutto analoga a quella del programma principale: lo stesso main è una funzione, anzi è l'unica che può avere quel nome! Quando si manda in esecuzione un programma, è come richiedere la valutazione della funzione main la quale, a sua volta, può richiamare altre funzioni. Se non si specifica il tipo, il C assume che la funzione sia di tipo intero (int). Capita talvolta che una funzione non debba restituire alcun risultato: per questi casi il C prevede un tipo speciale, void (vacante ): void nome_funzione è una funzione che non restituisce nulla.

© Piero Demichelis 7 Funzioni Anche i parametri possono mancare: in questo caso si può usare il tipo void, oppure niente (ma le parentesi che delimitano la lista dei parametri devono essere sempre presenti). Un modo per definire il programma principale è quindi int main (void) { /* corpo del programma */ } return può essere presente una o più volte o anche nessuna: se manca, la funzione termina dopo l'ultima istruzione.

© Piero Demichelis 8 Funzioni Nel corso del programma principale, per far eseguire la funzione, è sufficiente nominarla con gli eventuali parametri. Esempio: programma per disegnare un rettangolo di asterischi come il seguente: ************ * ************ La prima e l'ultima riga contengono una sequenza di 12 asterischi, mentre le 3 righe centrali sono formate da un asterisco seguito da 10 caratteri di spazio e da un altro asterisco.

© Piero Demichelis 9 Esempio Possiamo organizzare il programma in modo tale da avere una funzione, che chiameremo testacoda, per le righe estreme ed un'altra funzione, corporett, per le righe intermedie. #include void testacoda (void) { printf ("************\n"); /* visualizza 12 asterischi */ return; } void corporett (void) { printf ("* *\n"); /* visualizza *, poi 10 spazi, poi ancora * */ return; }

© Piero Demichelis 10 Esempio main() { testacoda (); corporett (); testacoda (); } L'esecuzione del programma partirà dalla prima istruzione del programma principale che è un'invocazione alla procedura testacoda. Il controllo è poi trasferito alla prima istruzione della funzione, al termine il controllo ritorna al programma principale all'istruzione successiva alla chiamata, ecc.

© Piero Demichelis 11 Esempio: funzione che restituisce un valore Esempio: funzione che legge un numero intero da tastiera e lo restituisce al programma chiamante. #include int lettura (void) { int dato_letto; printf (\nIntroduci un intero: "); scanf ("%d", &dato_letto); return (dato_letto); } main() { int dato; dato = lettura(); printf ("\nIl dato e': %d", dato); }

© Piero Demichelis 12 Funzioni con parametri Affinché le funzioni possano essere utilizzate più volte nello stesso programma o in programmi differenti è necessario che possano operare su valori diversi dei dati ad ogni chiamata. Il C prevede la trasmissione di parametri da un modulo ad un altro: il programma che utilizza una funzione dichiara nella chiamata il valore dei dati. Nell'esempio precedente (rettangolo), si potrebbero generalizzare le funzioni consentendo all'utente di specificare le dimensioni del rettangolo, la posizione dello stesso rispetto ai bordi dello schermo, il carattere da utilizzare per la stampa al posto di *, ecc.

© Piero Demichelis 13 Passaggio dei parametri by value Affinché una funzione possa ricevere dati dal programma chiamante, occorre che essi siano indicati tra parentesi nella dichiarazione di funzione, ognuno con il proprio tipo, così: tipo_parametro identificatore e separati da, tra di loro. Il programma richiama una funzione parametrizzata facendo seguire al nome della funzione stessa la lista degli identificatori dei dati racchiusi tra parentesi. Generalmente gli identificatori usati nel programma chiamante sono diversi da quelli usati nella funzione: la corrispondenza è basata solo sull'ordine nella lista.

© Piero Demichelis 14 Passaggio dei parametri by value Esempio: funzione che calcola la media tra due numeri interi. #include int media (int val1, int val2) { int vmed; vmed = (val1 + val2) / 2; /* divisione tra interi! */ return (vmed); } main() { int primo, secondo, finale; printf (\nIntroduci due numeri interi: ); scanf (%d%d, &primo, &secondo); finale = media (primo, secondo); printf (\nLa media tra %d e %d è: %d, primo, secondo, finale); }

© Piero Demichelis 15 Passaggio dei parametri by value Le variabili che compaiono nella dichiarazione di funzione (nell'esempio val1 e val2), sono detti parametri formali. Le variabili che compaiono nella chiamata, (nellesempio primo e secondo), sono detti parametri effettivi. Quando, in seguito al richiamo di funzione, il controllo del programma passa a quest'ultima, prima dell'esecuzione delle istruzioni viene attivato un meccanismo per cui i valori contenuti nei parametri effettivi sono copiati nei parametri formali corrispondenti interni alla funzione.

© Piero Demichelis 16 Passaggio dei parametri by value Osservazioni: ­Il numero e il tipo dei parametri formali deve essere uguale al numero e al tipo dei parametri effettivi, perché l'azione di copiatura viene eseguita in modo meccanico durante l'esecuzione. ­La modifica di un parametro formale in una funzione non provoca alcun effetto sul corrispondente parametro effettivo del programma chiamante. ­Si dice che i parametri sono trasferiti per valore (by value). ­Questo meccanismo restringe il campo di propagazione degli errori: non è possibile che in una funzione, per errore, si alterino variabili non appartenenti alla funzione stessa. Si dice che si ha la protezione dagli effetti collaterali (side effects).

© Piero Demichelis 17 Passaggio dei parametri by reference Può succedere che una funzione debba restituire al programma chiamante più di un risultato o comunque effettuare alterazioni ai dati definiti nel programma chiamante. Il meccanismo di passaggio by value funziona solo nella direzione programma chiamante-funzione e non viceversa! Per restituire dati si deve ricorrere ad un nuovo tipo di dati, il tipo puntatore, e agli operatori ad esso connessi. Si consideri l'assegnazione: dato1 = dato2; il cui significato è: copia il valore contenuto nel contenitore dato2 e scrivilo nel contenitore dato1.

© Piero Demichelis 18 Passaggio dei parametri by reference In linguaggio macchina gli identificatori dato1 e dato2 non sono altro che gli indirizzi delle celle di memoria che costituiscono il contenitore. A differenza di altri linguaggi di alto livello, in C è possibile manipolare anche gli indirizzi; l'assegnazione: ind_dato = &dato2; significa: assegna a ind_dato non il contenuto di dato2, bensì l'indirizzo del contenitore (cioè della variabile) dato2 (si dice che ind_dato punta a dato2).

© Piero Demichelis 19 Passaggio dei parametri by reference In questo caso quindi & è un operatore d'indirizzo. Affinché l'assegnazione ind_dato = &dato2; sia lecita, ind_dato deve essere definito come puntatore allo stesso tipo di dato2: per realizzare questa operazione occorre semplicemente anteporre l'operatore* all'identificatore, così: int dato2; /* Definizione di un intero */ int *ind_dato; /* Definizione di un puntatore a un intero */

© Piero Demichelis 20 Passaggio dei parametri by reference Si consideri il seguente programma: main() { int dato2; int *ind_dato; ind_dato = &dato2; /* assegna l'indirizzo di dato2 */ dato2 = 5; *ind_dato = 5; } Le ultime due assegnazioni sono del tutto equivalenti: assegna 5 alla variabile dato2.

© Piero Demichelis 21 Passaggio dei parametri by reference Se si utilizzano i puntatori come parametri, ogni variazione del parametro formale effettuato nella funzione si ripercuote direttamente sul parametro effettivo, ovvero parametro formale e parametro effettivo sono la stessa cosa! E possibile quindi restituire più di un risultato al programma chiamante: questo metodo di passaggio dei parametri è detto per riferimento (by reference). Poiché parametro formale e parametro effettivo sono la stessa cosa è evidente che viene meno la protezione dagli effetti collaterali (side effects).

© Piero Demichelis 22 Passaggio dei parametri by reference Per passare un parametro by reference (nel modulo chiamante) occorre anteporre loperatore & al nome della variabile (per specificarne lindirizzo): media (&dato1, &dato2); Per ricevere un parametro by reference (nel modulo chiamato) occorre anteporre loperatore * alla variabile puntatore destinata a ricevere lindirizzo del dato: int media (int *val1, int *val2)

© Piero Demichelis 23 Passaggio dei parametri by reference Esempio - Programma per leggere da terminale un numero reale e calcolare il quadrato e il cubo, visualizzando i risultati. Soluzione - Si realizza una funzione che, dato un numero, ne calcola il quadrato e il cubo. Il numero è un parametro che passa dal programma chiamante alla funzione by value, mentre i risultati (quadrato e cubo) devono essere restituiti al programma chiamante by reference. #include

© Piero Demichelis 24 Passaggio dei parametri by reference void calcola (float valore, float *quad_val, float *cub_val) { *quad_val = valore * valore; *cub_val = *quad_val * valore; return; } main() { float un_dato, quadrato, cubo ; printf (\nIntroduci un dato reale: "); scanf ("%f", &un_dato); calcola (un_dato, &quadrato, &cubo); printf (\nIl quadrato di %f è: %f,", un_dato, quadrato); printf (" il cubo è: %f", cubo); }

© Piero Demichelis 25 Passaggio dei parametri by reference Osservazioni: ­Nella funzione calcola, l'operatore * davanti a quad_val e cub_val indica che questi parametri sono passati per indirizzo. ­Nel corpo della funzione, l'istruzione *quad_val = valore * valore; significa calcola il prodotto e assegnalo alla variabile il cui indirizzo è quad_val. ­Il programma chiamante passa gli indirizzi delle variabili quadrato e cubo anteponendo agli identificatori l'operatore &.

© Piero Demichelis 26 Definizione di una funzione Non è lecito inserire una funzione all'interno di unaltra, quindi le funzioni non possono essere annidate. Una funzione può però essere richiamata da altre funzioni purché siano soddisfatte alcune condizioni e può richiamare sempre se stessa (recursione). Non è indispensabile che la definizione delle funzioni preceda sempre il main, tuttavia la condizione affinché si possa richiamare una funzione è che sia già stata definita oppure dichiarata.

© Piero Demichelis 27 Prototipo di una funzione La dichiarazione di una funzione è costituita dalla sua intestazione, cioé dal tipo, nome e lista dei parametri formali che è anche detta prototipo della funzione. Il compilatore, disponendo del prototipo, può effettuare i controlli di congruenza sia sul tipo della funzione che sul tipo e sul numero dei parametri. Pertanto il prototipo può apparire più volte all'interno del programma. La definizione invece deve essere unica.

© Piero Demichelis 28 Esempio #include float media (int primo, int secondo); /* prototipo della funzione */ main() { int dato1, dato2; printf (\nIntroduci due interi: "); scanf ("%d%d", &dato1, &dato2); printf(\nMedia tra %d e %d: %f", dato1, dato2, media(dato1,dato2)); } float media (int primo, int secondo) { float somma; somma = primo + secondo; return (somma / 2.0); /* somma e conversione di tipo */ }

© Piero Demichelis 29 Osservazioni sull'uso dei parametri Nelle funzioni si potrebbero omettere i parametri e utilizzare variabili globali: questo comportamento è sconsigliabile perchè in questo modo si deve tener conto ovunque dell'utilizzo che ne vien fatto e possono prodursi effetti collaterali. Il passaggio dei parametri per valore è sempre da preferire perchè permette la massima elasticità senza effetti collaterali. Il passaggio dei parametri per riferimento è indispensabile quando si devono restituire dei risultati al programma chiamante: si mantiene la versatilità della parametrizzazione ma si possono avere effetti collaterali poiché, nel momento della chiamata, si crea una identità tra parametri formali ed effettivi. Per riferimento si possono passare solo variabili: non sono accettabili costanti od espressioni.

© Piero Demichelis 30 Osservazioni sull'uso dei parametri È buona norma dichiarare globali solo le variabili che rappresentano la base dati di un programma e sono manipolate da tutti i moduli. Conviene che le variabili globali compaiano come parametri nella chiamata di una funzione solo se ciò migliora la leggibilità del programma, rendendo evidente su quali variabili opera quella funzione. Sono invece da dichiarare locali tutti quegli identificatori a cui si fa riferimento solo all'interno della singola funzione. Per una migliore leggibilità del programma, è meglio usare nomi diversi per variabili locali e globali anche se non è affatto necessario.

© Piero Demichelis 31 Vettori come parametri di una funzione Nella definizione di una funzione in cui compare come parametro un vettore non è indispensabile che di questo sia definita la dimensione: è sufficiente indicare il carattere di vettore del parametro (cioè []): int nome (int vett[], int lung,...) {….. Infatti è nel programma chiamante che deve essere riservata larea fisica di memoria che ospita il vettore, nella funzione il compilatore deve gestire solamente gli indirizzi dei singoli elementi. Nel programma chiamante il vettore è passato semplicemente indicandone il nome (senza []).

© Piero Demichelis 32 Vettori come parametri di una funzione Nelle chiamate di funzioni, per i vettori, il compilatore C forza automaticamente il passaggio per riferimento. La ragione del passaggio by reference è conseguenza del fatto che il nome del vettore indica lindirizzo del primo elemento. Nella funzione si usa il vettore con le stesse modalità con cui lo si usa nel main, al contrario di quanto succede per le variabili scalari, che devono essere gestite in funzione del modo col quale è stato passato il parametro. Pertanto gli elementi di un vettore passato come argomento possono essere modificati nella funzione e non cè protezione dagli effetti collaterali !

© Piero Demichelis 33 Vettori come parametri di una funzione Poiché come sempre in C non ci sono controlli sugli indici, è buona norma passare a una funzione insieme al vettore anche la sua dimensione. Il programmatore può così controllare che allinterno della funzione non si trasbordi fuori dallarea di memoria dedicata al vettore. Esempio: scrivere una funzione nonnull che ritorni il numero di elementi non nulli di un vettore di interi passato come parametro.

© Piero Demichelis 34 int nonnull (int vett[], int dim) { int ind, n; n = 0; for (ind = 0; ind < dim; ind++) { if (vett[ind] != 0) n++; } return (n); } Esercizio Per risolvere il problema è necessario conoscere la dimensione del vettore Se modificassi vett[ ] dentro la funzione, il valore sarebbe modificato anche nel programma chiamante

© Piero Demichelis 35 Esercizio Programma che legge da tastiera 20 interi e li salva in un vettore. Ne elimina i doppioni e visualizza i dati del vettore prima e dopo l'eliminazione dei doppi. #include #define NUMDATI 20 int vett_dati[NUMDATI]; int ind, ind_aux; int attuali; /* prototipi */ void compatta (int vett[], int inizio, int *n_dati); void visualizza (int vett[], int n_dati); Dati globali

© Piero Demichelis 36 Esercizio main() { /* legge i dati da tastiera */ printf (\nIntroduci %d dati:\n",NUMDATI); for (ind = 0; ind < NUMDATI; ind++) { printf (\nDato n. %2d =", (ind+1)); /* la numerazione parte da 1 */ scanf ("%d", &vett_dati[ind]); } attuali = NUMDATI; printf (\nDati introdotti:\n"); visualizza (vett_dati, attuali);

© Piero Demichelis 37 Esercizio for (ind = 0; ind < (attuali-1); ind++) { for (ind_aux = (ind + 1); ind_aux < attuali; ind_aux++) { if (vett_dati[ind] == vett_dati[ind_aux]) { compatta (vett_dati, ind_aux, &attuali); ind_aux--; } printf (\nDati rimasti dopo leliminazione dei dati uguali:\n"); visualizza (vett_dati,attuali); } /* fine programma main */

© Piero Demichelis 38 Esercizio /* funzione che elimina lelemento di indice inizio dal vettore vett */ /* spostando in avanti di una posizione tutti gli elementi successivi */ /* aggiorna infine il numero di dati che compongono il vettore */ /* decrementandolo di una unità */ void compatta (int vett[], int inizio, int *n_dati) { int posiz; for (posiz = inizio; posiz < (*n_dati - 1); posiz++) vett [posiz] = vett [posiz + 1]; (*n_dati)--; /* decrementa n_dati */ return; } /* fine funzione compatta */

© Piero Demichelis 39 Esercizio /* Funzione che visualizza sul monitor il valore degli elementi del */ /* vettore vett composto da n_dati elementi. */ /* I dati sono scritti uno per riga nel formato: */ /* Vettore[xx] = valore */ void visualizza (int vett[], int n_dati) { int ind; for (ind = 0; ind < n_dati; ind++) printf ("Vettore[%2d] = %d\n", (ind + 1), vett [ind]); return; } /* fine funzione visualizza */

© Piero Demichelis 40 Funzioni di libreria Ogni linguaggio prevede che alcune funzioni siano già predefinite (quindi note al compilatore e comprese nelle sue librerie). In C il loro numero è grandissimo (centinaia) e sono suddivise in files a seconda della categoria di appartenenza: ci sono funzioni matematiche, di gestione dell'I/O, di conversione, ecc. Un certo numero è esplicitamente previsto dall'ANSI C (funzioni standard), ma i realizzatori dei compilatori sono soliti aggiungerne molte altre: l'uso di funzioni non standard è di ostacolo alla trasportabilità dei programmi e quindi deve essere evitato.

© Piero Demichelis 41 Funzioni di libreria L'elenco completo delle funzioni definite sono reperibili nel manuale (Reference Manual ) del compilatore usato e a volte sono rese disponibili anche nell'ambiente di sviluppo dei programmi (ad esempio nellhelp del TURBO- C della Borland) Per ciascuna funzione viene di solito specificato se appartiene o meno allo standard e quale file di libreria la contiene. Questo file deve essere incluso nel programma mediante la direttiva #include. In questi file sono contenuti anche i prototipi delle funzioni, che pertanto non devono essere specificati altrove.

© Piero Demichelis 42 Funzioni matematiche abs(x) calcola il valore assoluto di x; sia x che il risultato sono int; labs(x) calcola il valore assoluto di x; sia x che il risultato sono long int; fabs(x) calcola il valore assoluto di x; sia x che il risultato sono numeri floating-point ; ceil(x) restituisce un numero con parte decimale nulla e parte intera arrotondata al valore intero successivo; x e risultato sono double; floor(x) restituisce un numero con parte decimale nulla e parte intera troncata al valore intero; x e il risultato sono double; sqrt(x) calcola la radice quadrata di x con x positivo; x e il risultato sono double; Utilizzabili con la direttiva: #include

© Piero Demichelis 43 Funzioni matematiche log(x) calcola il logaritmo naturale di x con x positivo; x e il risultato sono double; log10(x) calcola il logaritmo in base 10 di x con x positivo; x e il risultato sono double; exp(x) calcola e x ; x e il risultato sono double; pow(x, y) calcola x y : se x è negativo y deve avere parte decimale nulla; x, y e risultato sono tutti double; sin(x) calcola il seno di x; x è l'angolo espresso in radianti; x e il risultato sono double; cos(x) calcola il coseno di x; x è l'angolo espresso in radianti; x e risultato sono double; tan(x) calcola la tangente di x; x è l'angolo espresso in radianti; x e il risultato sono double; Utilizzabili con la direttiva: #include

© Piero Demichelis 44 Funzioni matematiche asin(x) calcola larcoseno di x (tra –π /2 e +π /2); x e risultato sono double; acos(x) calcola larcocoseno di x (tra 0 e +π); x e risultato sono double; atan(x) calcola larcotangente di x (tra –π /2 e +π /2); x e risultato sono double; atan2(y, x) arcotangente di y / x (tra -π e +π); x, y e risultato sono double; sinh(x) calcola il seno iperbolico di x; x e risultato sono double; cosh(x) calcola il coseno iperbolico di x; x e risultato sono double; tanh(x) calcola la tangente iperbolica di x; x e il risultato sono double; Utilizzabili con la direttiva: #include

© Piero Demichelis 45 Funzioni di classificazione dei caratteri isalnum(c) restituice vero (1) se c è un carattere alfabetico o una cifra; c è char; isalpha(c) restituice vero (1) se c è un carattere alfabetico; c è char; isdigit(c) restituice vero (1) se c è una cifra; c è char; iscntrl(c) restituice vero (1) se c è delete o un carattere di controllo; c è char; isascii(c) restituice vero (1) se c è un carattere ASCII valido; c è char; isprint(c) restituice vero (1) se c è un carattere stampabile; c è char; isgraph(c) restituice vero (1) se c è un carattere stampabile escluso lo spazio; c è char; Utilizzabili con la direttiva: #include

© Piero Demichelis 46 Funzioni di classificazione dei caratteri islower(c) restituice vero (1) se c è un carattere minuscolo; c è char; isupper(c) restituice vero (1) se c è un carattere maiuscolo; c è char; ispunct(c) restituice vero (1) se c è un carattere di punteggiatura; c è char; isspace(c) restituice vero (1) se c è spazio, tab, carriage return, new line, vert. tab, form feed; c è char; isxdigit(c) restituice vero (1) se c è una cifra esadecimale; c è char; Utilizzabili con la direttiva: #include

© Piero Demichelis 47 Funzione per le stringhe strlen(s) restituice la lunghezza (numero di caratteri) della stringa s; il risultato è intero; strcmp(s1, s2) confronta due stringhe e restituisce un valore intero: negativo se s1 precede s2, zero se sono uguali, positivo se s1 succede a s2 nell'ordinamento alfabetico; strncmp(s1, s2, n) come strcmp, ma effettua il confronto per i primi n caratteri. strcat(s1, s2) concatena s1 con s2, copiando i caratteri di s2 in coda a quelli di s1 compreso il carattere NULL (quello di s1 viene sovrascritto). Il valore restituito dalla funzione è un puntatore a s1. strcpy(s1, s2) copia s2 in s1; strncpy(s1, s2, n) copia i primi n caratteri di s2 in s1. Utilizzabili con la direttiva: #include

© Piero Demichelis 48 Funzione per le stringhe strchr(str, car) cerca se il carattere car è presente in str. Il valore restituito dalla funzione è un puntatore alla prima occorrenza di car in str, oppure NULL se il carattere è assente; strstr(s1, s2) verifica se s2 è contenuta in s1. Il valore restituito dalla funzione è un puntatore al punto di s1 dove inizia s2, oppure NULL se s2 non è presente; strpbrk(s1, s2) cerca in s1 la prima occorrenza di uno dei caratteri presenti in s2. Mentre strchr cerca un unico carattere questa opera su un gruppo di caratteri: è utile, ad esempio, per cercare i caratteri d'interpunzione in un testo. Il valore restituito è un puntatore alla prima occorrenza di uno dei caratteri in s1, oppure NULL se nessun carattere di s2 è presente in s1. Utilizzabili con la direttiva: #include

© Piero Demichelis 49 Funzioni di conversione di stringhe atof (stringa) converte stringa in un numero reale in doppia precisione: restituisce il valore convertito in un tipo double; atoi (stringa) converte stringa in un numero intero; restituisce il valore convertito in un tipo int; atol (stringa) converte stringa in un numero intero lungo; restituisce il valore convertito in un tipo long int; Utilizzabili con la direttiva: #include Queste funzioni operano sulle stringhe con le stesse modalità della scanf: gli spazi neutri iniziali vengono ignorati, viene cercata una sequenza di caratteri compatibile con il tipo di dato, infine viene effettuata la conversione.

© Piero Demichelis 50 Osservazioni sulle funzioni per le stringhe Data la loro natura di tipo aggregato, le stringhe non possono essere usate come variabili qualunque. E già stato osservato, ad esempio, che non è lecito assegnare una stringa a un altra o aggiungere una stringa ad un altra. char s1[20], s2[10], s3[50];... s1 = abcdefg; s2 = hijklmno; s3 = s2; s3 = s1 + s2; Per questi scopi si devono usare le apposite funzioni di libreria. NO!

© Piero Demichelis 51 Osservazioni sulle funzioni per le stringhe NOTE: ­Non è possibile usare vettori come valori di ritorno delle funzioni di libreria. Esempio: char finale[40], stringa1[10], stringa2[10];... finale = strcat (stringa1, stringa2); ­Alcune funzioni possono essere usate senza risultato. Esempio: strcpy (finale, stringa1); strcat (finale, stringa2); NO!