Ingresso interattivo (scanf(); %lf)

Se un programma deve essere eseguito una sola volta, i dati possono essere inseriti direttamente nel programma stesso.

Tuttavia, nella maggior parte dei casi, è necessario immettere i dati in un programma mentre esso è in esecuzione.

A questo scopo si usa la funzione scanf().

scanf() consente di immettere da tastiera un valore che viene visualizzato sullo schermo e memorizzato direttamente in una variabile.

Mentre printf() visualizza una copia del valore memorizzato in una variabile,

Ad es., una chiamata alla funzione scanf() potrebbe essere l’istruzione

scanf(“%d”, &num1);

Come printf(), anche scanf() richiede una stringa di controllo come primo argomento dentro le parentesi del nome di funzione.

La stringa di controllo dice alla funzione il tipo dati che viene immesso e usa le stesse sequenze di controllo di printf().

Tuttavia, a differenza della stringa di controllo usata in printf(), quella passata a scanf() consiste tipicamente in

sole sequenze di controllo di conversione.

Inoltre, a differenza di printf(), dove la stringa di controllo può essere seguita da un elenco di NOMI di variabile,

scanf() richiede che la stringa di controllo sia seguita da un elenco di INDIRIZZI di variabile.

La sequenza di controllo di conversione %d è la stessa usata in printf(), e dice a scanf() che opererà su un numero intero.

Come si osserva, in scanf() si è usato l’operatore di indirizzo & davanti alla variabile num1 (ricordiamo che &num1 si legge l’indirizzo di num1).

Quando incontra un’istruzione del tipo scanf(“%d”, &num1); il computer sospende l’esecuzione del programma e scansiona in continuazione la tastiera per ricevere dati (scanf è un’abbreviazione per scan function).

Quando viene digitato un dato, scanf() lo memorizza nell’indirizzo che le viene fornito. Quindi il programma continua l’esecuzione con l’istruzione successiva a scanf().

A questo proposito consideriamo il programma seguente:

#include <stdio.h>void main(void){ float num1, num2, prodotto; printf(“Scrivi un numero: “); scanf(“%f”, &num1); printf(“Scrivi un altro numero: “); scanf(“%f”, &num2); prodotto = num1 * num2; printf(“%f per %f uguale %f”, num1, num2, prodotto);}

Esso produce la seguente uscita:

Scrivi un numero: 22Scrivi un altro numero: 422.000000 per 4.000000 uguale 88.0000

Il valore viene assegnato alla variabile num1, inviandolo al suo indirizzo (&num1) che è stato passato a scanf().

Quindi il computer esce dallo stato di attesa e il programma prosegue con l’istruzione successiva.

Questa è un’altra chiamata a printf(), che fa visualizzare il messaggio successivo.

Di nuovo la seconda chiamata a scanf() pone il computer in uno stato di attesa temporanea finché l’utente digita un secondo valore, che viene inviato all’indirizzo della variabile num2.

La prima chiamata a printf() produce un prompt, cioè un messaggio che dice all’utente cosa deve scrivere, in questo caso un numero.

Quindi il computer esegue l’istruzione successiva, che è una chiamata a scanf(); questa pone il computer in uno stato di attesa temporanea (o wait) fino a che l’utente digita un valore e lo invia a scanf() premendo il tasto <Invio>.

Sebbene nel programma ogni chiamata a scanf() sia stata usata per memorizzare un valore in una variabile, si può usare scanf() per immettere e memorizzare tanti valori quante sono le sequenze di controllo di conversione presenti nella sua stringa di controllo.

Ad es., l’istruzione

scanf(“%f %f”, &num1, &num2);

fa sì che due valori siano letti da tastiera e inviati agli indirizzi delle variabili num1 e num2.

Nella stringa di controllo lo spazio tra le due sequenze di controllo di conversione %f e %f è stato inserito solo per una migliore leggibilità, e anche la stringa di controllo %f%f avrebbe funzionato ugualmente.

Tuttavia, quando si immettono i numeri da tastiera, va lasciato almeno uno spazio tra essi (per indicare la fine di un numero e l’inizio del successivo), indipendentemente da quale stringa sia stata usata (%f %f o %f%f).

L’unico caso in cui uno spazio influenzi i valori immessi si ha quando scanf() si aspetta un tipo dati carattere.

Ad es., l’istruzione

scanf(“%c%c%c”, &car1,&car2,&car3);

fa sì che scanf() memorizzi i prossimi tre caratteri digitati rispettivamente nelle variabili car1, car2, car3.

Se si scrive

x y z

x è memorizzato in car1, uno spazio vuoto è memorizzato in car2 e y in car3.

Se invece si usa l’istruzione

scanf(“%c %c %c”, &car1,&car2,&car3);

scanf() si aspetta tre caratteri separati esattamente da uno spazio.

Si tenga presente che,

Come printf(), nemmeno scanf() controlla i tipi dati dei valori immessi, ma deve essere l’utente ad assicurarsi che tutte le variabili siano dichiarate corettamente e che tutti numeri immessi siano del tipo corretto.

Tuttavia, scanf() è abbastanza versatile da eseguire qualche conversione di tipi dati.

Per esempio, se viene fornito un intero al posto di un numero in virgola mobile o in doppia precisione, scanf() aggiunge automaticamente il punto decimale alla fine del numero prima di memorizzarlo.

Analogamente, se viene immesso un numero in virgola mobile o in doppia precisione quando è atteso un intero, scanf() usa solo la parte intera del numero.

se va immesso un numero in precisione doppia, con scanf() si deve usare la sequenza di controllo di conversione %lf

Costanti simboliche (#define). Un dato letterale è un qualsiasi dato all’interno di un programma che identifichi esplicitamente se stesso.

Ad es., le costanti 2 e 3.1416 nell’istruzione di assegnazione

circonf = 2 * 3.1416 * raggio

si dicono anche letterali, perché sono letteralmente inserite direttamente nell’istruzione.

In molti casi uno stesso letterale compare più volte in un programma: per esempio un programma che calcola gli interessi bancari potrebbe usare spesso il tasso d’interesse.

In tale caso, se fosse necessario cambiare il valore del tasso, si dovrebbero effettuare numerose correzioni al programma, con il rischio di commettere errori.

Conviene allora sfruttare la possibilità, offerta dal C, di definire il valore una sola volta, uguagliando il numero a un nome simbolico e usando tale nome, in tutto il programma, al posto del numero.

Per uguagliare un numero a un nome simbolico si usa l’istruzione #define, come nei due esempi seguenti:

#define TASSO 0.05 #define PIGR 3.1416

Osservazioni.

1.L’istruzione #define, detta anche

istruzione di equivalenza

non viene elaborata dal compilatore C che trasforma le istruzioni in linguaggio macchina, ma è un’istruzione al preprocessore di C (come indica il simbolo #), e pertanto termina senza punto e virgola.

Essa ovviamente si deve trovare prima delle istruzioni che usano i relativi nomi simbolici, e di solito viene scritta all’inizio del file, prima della funzione main().

2. I nomi simbolici, detti anche costanti nominate o costanti simboliche, sono scritti di solito in lettere maiuscole, per distinguerli dai nomi di variabili dichiarati nelle istruzioni di dichiarazione.

#define TASSO 0.15#include <stdio.h>void main(void){ float netto, imposta, totale; printf(“\nScrivi il netto da pagare: “); scanf(“%f”, &netto); imposta = TASSO * netto; totale = netto + imposta; printf(“L’imposta da pagare è E %4.2f”, imposta); printf(“\nIl totale da pagare è E %5.2f”, totale);}

Ecco un esempio di uso dell’istruzione #define:

Selezione

Espressioni relazionali. Oltre a eseguire le operazioni di addizione, sottrazione, moltiplicazione e divisione, tutti i computer hanno la capacità di confrontare i numeri.

Giacché molte situazioni in cui vengono prese decisioni apparentemente “intelligenti” possono essere ridotte al livello di scegliere tra due valori, la capacità di confronto di un computer può essere usate per creare una prestazione più o meno simile all’intelligenza.

Le espressioni usate per confrontare gli operandi sono dette espressioni relazionali.

Una semplice espressione relazionale consiste in un operatore relazionale che collega due operandi, che possono essere variabili o costanti, come

Gli operatori relazionali disponibili in C sono indicati in tabella, e possono essere usati con dati interi, in virgola mobile, doppia precisione o caratteri.

Le espressioni relazionali sono spesso dette condizioni, e come tutte le espressioni in C sono valutate per fornire un risultato numerico, che può essere solamente un valore intero 0 o 1.

Una condizione interpretata come vera ha valore intero 1, e una falsa ha valore 0. Ad esempio, dato che la relazione 3 < 4 è sempre vera, essa ha valore 1, mentre la relazione 2.0 > 3.3, che è sempre falsa, ha valore 0.

Ciò può essere verificato eseguendo le istruzioni

printf(“Il valore di 3 < 4 è %d”, 3<4);printf(“\nIl valore di 2.0 > 3.3 è %d”, 2.0>3.3);

che producono appunto i risultati

Il valore di 3 < 4 è 1Il valore di 2.0 > 3.3 è 0

Il valore di un’espressione relazionale quale ore > 0 dipende dal valore memorizzato nella variabile ore.

In un programma C, non è tanto importante il valore di un’espressione relazionale quanto l’interpretazione che C fornisce del valore quando si usa l’espressione come parte di un’istruzione di selezione.

In tali espressioni, che vedremo tra poco, C usa il valore zero per rappresentare una condizione falsa, e qualsiasi valore diverso da zero per rappresentare una condizione vera.

La scelta di quale azione svolgere si baserà quindi sul valore ottenuto.

In aggiunta agli operandi numerici, con gli operatori relazionali si possono confrontare anche dati carattere.

Ricordando che, per esempio, il codice ASCII per la lettera A è minore di quello per la lettera B, e così via, le seguenti espressioni sono valutate come indicato.

Confronare le lettere è essenziale quando si debbano ordinare alfabeticamente dei nomi, o quando si usino i caratteri per selezionare una particolare scelta nelle situazioni in cui vadano prese decisioni.

Operatori logici. Oltre a usare come condizioni espressioni relazionali semplici, si possono creare condizioni più complesse usando gli operatori logici AND (&&), OR (||) e NOT (!), già visti in precedenza.

Quando si usa l’operatore OR, ||, la condizione composta è vera se almeno una delle condizioni è vera.

Perciò la condizione composta

peso < 60 || peso >70

è vera se la variabile peso ha un valore non compreso fra 61 e 69.

Quando si usa l’operatore AND, &&, con due espressioni semplici, la condizione composta è vera (ha valore 1) solo se entrambe le espressioni sono vere.

Perciò la condizione composta

peso > 60 && peso < 70

è vera solo se la variabile peso ha un valore compreso fra 61 e 69.

L’operatore NOT, !, viene usato per cambiare lo stato o valore di un’espressione.

Cioè

se espressione è falsaallora !espressione è vera.

Gli operatori relazionali e logici hanno una gerarchia di esecuzione simile a quella degli operatori aritmetci.

La tabella seguente elenca la precedenza di questi operatori in relazione agli altri che abbiamo visto.

Vediamo, come esempio, come verrebbe valutata la seguente espresione:

(6 * 3 == 36 / 2) || (13 < 3 * 3 + 4) && !((6 - 2) < 5)

( 18 == 18 ) || (13 < 9 + 4) && !( 4 < 5) 1 || (13 < 13) && !1 1 || 0 && 0 1 || 0 1

Istruzione if-else. Questa istruzione fa scegliere al computer una sequenza di una o più istruzioni a seconda del risultato di un confronto.

La sua forma generale è:

if (condizione) istruzione1;else istruzione2;

Prima di tutto viene valutata la condizione:

• se il suo valore è diverso da zero viene eseguita l’istruzione1• se è uguale a zero viene eseguita l’istruzione2.

Così, a seconda del valore della condizione, viene sempre eseguita una delle due istruzioni.

Per maggiore chiarezza, l’istruzione if-else si può scrivere anche su quattro linee:

if (condizione) istruzione1; else istruzione2;

L’uso di if-else è illustrato nel seguente programma:

#include <stdio.h>void main(void){ float imponibile, tasse; printf(“Scrivi l’importo tassabile: “); scanf(“%f”, &imponibile); if (imponibile <= 10000.0) tasse = 0.2 * imponibile; else tasse = 0.25 * (imponibile - 10000.0) + 2000.0; printf(“Le tasse sono E %7.2f”, tasse);}

Ecco l’uscita prodotta:

Istruzioni composte. Le parti if ed else della istruzione if-else possono in realtà contenere una istruzione composta, ossia un numero qualsiasi di istruzioni semplici racchiuse tra le parentesi { e }. Lo schema è il seguente:

L’uso di una istruzione composta è illustrato nel programma seguente, che converte una temperatura da gradi Celsius in gradi Fahrenheit o viceversa, secondo la formula F = 9/5*C + 32.

if (condizione){ istruzione1; istruzione2; . . .}else{ istruzioneA; istruzioneB; . . .}

#include <stdio.h>void main(void){ char tipo_temp; float temp, fahren, celsius; printf(“Scrivi la temperatura da convertire: “); scanf(“%f”, &temp); printf(“Scrivi f se la temperatura è in Fahrenheit”); printf(“\n o c se la temperatura è in Celsius ”); scanf(“\n%c”, &tipo_temp); if (tipo_temp == ‘f’) { celsius = (5.0/9.0) * (temp - 32.0); printf(“\nLa temperatura Celsius equivalente è %6.2f”, celsius); } else { fahren = (9.0/5.0) * temp + 32.0; printf(“\nLa temperatura Fahrenheit equivalente è %6.2f”, fahren); }}

Ecco l’uscita prodotta:

Scrivi la temperatura da convertire: 40Scrivi f se la temperatura è in Fahrenheit o c se la temperatura è in Celsius c

La temperatura Fahrenheit equialente è 104.00

Scrivi la temperatura da convertire: 104Scrivi f se la temperatura è in Fahrenheit o c se la temperatura è in Celsius f

La temperatura Celsius equivalente è 40.00

Istruzione if a una via. Una modifica talvolta utile dell’istruzione if-else consiste nell’omettere la sua parte else.

In tale caso l’istruzione assume la forma abbreviata:

if (condizione)istruzione;

l’istruzione che segue la condizione viene eseguita solamente se la condizione ha valore diverso da zero (è vera).

Anche adesso l’istruzione può essere composta.

Questa forma modificata dell’istruzione if è detta istruzione if a una via, ed è illustrata nel programma seguente, che chiede la targa e il chilometraggio di una vettura, e stampa un messaggio se la vettura ha percorso più di 30000 kilometri.

#define LIMITE 3000.0#include <stdio.h>void main(void){ int id_targa; float km; printf(“Scrivi la targa e il chilometraggio della vettura: “); scanf(“%d %f”, &id_targa, &km); if(km > LIMITE) printf(“ La vettura %d ha superato il limite.\n”, id_targa); printf(“Fine dell’esecuzione del programma.\n”);}

Esso produce l’uscita seguente:

Scrivi la targa e il chilometraggio della vettura: 12345 50000 La vettura 12345 ha superato il limite.Fine dell’esecuzione del programma.

Istruzioni if nidificate. Come abbiamo visto, un’istruzione if-else può contenere una qualsiasi istruzione valida in C, semplice o composta, quindi anche un’altra istruzione if-else.

Ad es., in un’istruzione if-else si può inserire una selezione a una via come nel seguente segmento di programma:

Esso stampa la parola “dentro” se la variabile ore ha valore 7 o 8, stampa “fuori” se ha un valore minore di 7 o maggiore di 8.

if (ore < 9){ if (ore > 6) printf(“dentro”);}else printf(“fuori”);

if (ore < 9) if (ore > 6) printf(“dentro”); else printf(“fuori”);

In questo caso si avrebbe la stessa stampa di prima se ore è minore di 9, e nessuna stampa se è uguale o maggiore di 9.

Catena if-else. Come si vede, il caso in cui l’istruzione nella parte if di un’istruzione if-else sia un’altra istruzione if crea confusione, e viene quindi evitato.

Tuttavia, può essere utile situare un’altra istruzione if-else nella parte else di un’istruzione if-else.

Ciò assume la forma:

Osservazione. Le parentesi {} che racchiudono l’if a una via interno sono essenziali, perché in loro assenza C assocerebbe else con il più vicino if non appaiato e non con quello più esterno, interpretando la precedente istruzione nel seguente modo:

Questa costruzione è detta catena if-else, ed è ampiamente usata nei programmi applicativi. Ogni condizione è valutata nell’ordine, e se qualcuna è vera viene eseguita l’istruzione corrispondente e il seguito della catena termina.

L’ultima istruzione else viene eseguita solamente se nessuna delle condizioni precedenti è soddisfatta, ed è utile per rivelare una condizione impossibile o di errore.

È ovvio che la catena può continuare indefinitamente, inserendo quante si vogliano istruzioni else if prima dell’ultima else, come pure che ciascuna istruzione individuale può essere sostituita da un’istruzione composta, racchiusa tra le parentesi { e }.

Esercizio. Scrivere un programma che:

• chieda di immettere la lettera iniziale dello stato civile di una persona (S=sposato/a, C/N=celibe/nubile, D=divorziato/a, V=vedovo/a;

• stampi il relativo stato civile.

#include <stdio.h>void main(void){ char codstatociv; printf(“Scrivi un codice di stato civile (S, C, N, D o V): “); scanf(“%c”, &codstatociv); if (codstatociv == ‘S’) printf(“\nLa persona è sposata”); else if (codstatociv == ‘C’ || codstatociv == ‘N’) printf(“\nLa persona è celibe o nubile”); else if (codstatociv == ‘D’) printf(“\nLa persona è divorziata”); else if (codstatociv == ‘V’) printf(“\nLa persona è vedova”); else printf(“È stato scritto un codice non valido”);}

Il programma seguente realizza quanto richiesto:

Istruzione switch

La catena if-else è usata in applicazioni di programmazione dove si deve scegliere un gruppo di istruzioni tra più alternative possibili.

L’istruzione switch fornisce un’alternativa alla catena if-else nei casi in cui si confronti il valore di un’espressione intera con un valore specifico.

La forma generale dell’istruzione switch è:

switch (condizione){ case valore_1: istruzione1; istruzione2; . break; case valore_2: . istruzionea . break; case valore_n: istruzionex; . break; default: istruzioneaa; .}

L’istruzione switch usa quattro nuove parole chiave:

switch, case, default, break.

Vediamone i compiti.

La parola chiave switch identifica l’inizio dell’istruzione. La condizione tra parentesi che la segue viene valutata e il risultato confrontato con i diversi valori alternativi contenuti nell’istruzione composta.

La condizione deve avere un valore intero, altrimenti si verifica un errore di compilazione.

All’interno dell’istruzione switch si usa la parola chiave case per identificare o etichettare i singoli valori che vengono confrontati con quello della condizione switch.

I valori sono confrontati nell’ordine con cui sono scritti, fino a che si trova una corrispondenza; in tale caso l’esecuzione comincia con la prima istruzione che segue il valore di corrispondenza.

Se il valore della condizione non corrisponde ad alcuno dei valori case, non viene eseguita alcuna istruzione, a meno che non s’incontri la parola chiave default.

In tale caso l’esecuzione del programma inizia dall’istruzione che segue la parola default.

default è opzionale, e opera nella stessa maniera dell’ultima else in un’istruzione if-else.

Una volta che l’istruzione switch abbia localizzato un punto d’ingresso, non vengono più valutate altre espressioni case, e vengono eseguite tutte le istruzioni che seguono all’interno delle parentesi { e }, fino a che non si incontri l’istruzione break.

Essa quindi identifica la fine di un particolare case e determina l’uscita immediata dall’istruzione switch.

In altri termini, come la parola case identifica i possibili punti di partenza dell’istruzione composta, così l’istruzione break determina i punti terminali.

Se si omettono le istruzioni break, vengono eseguite tutte le case che seguono quella con il valore di corrispondenza, compresa la default.

Esercizio. Scrivere un programma che:

• richieda due operandi e un codice numerico di operazione;

• a seconda del codice immesso, esegua sui due operandi una delle operazioni di addizione, moltiplicazione o divisione.

Un programa che usa l’istruzione switch è il seguente:

#include <stdio.h>void main(void){ int sceltaoper; double num1, num2; printf(“Scrivi due numeri: “); scanf(“%lf %lf”, &num1, &num2); printf(“Scrivi il codice operazione: “); printf(“\n 1 per addizione”); printf(“\n 2 per moltiplicazione”); printf(“\n 3 per divisione”); scanf(“%d”, &sceltaoper); switch (sceltaoper) { case 1: printf(“La somma dei numeri scritti è %6.3lf”, num1+num2); break; case 2: printf(“Il prodotto dei numeri scritti è %6.3lf”,num1*num2); break; case 3: printf(“Il quoziente dei numeri scritti è %6.3lf”,num1/num2); break; }}