|
PREPARAZIONE DI UN
PROGRAMMA
Iniziamo a preparare un codice
in C dal quale vengano effettuate le seguenti operazioni: (a) la dichiarazione
di tre variabili di tipo int e di una variabile di tipo double; (b) l’inizializzazione
delle variabili; (c) il
calcolo del prodotto di due variabili di tipo int; (d) il
calcolo del rapporto tra due variabili di tipo int; (e) il
calcolo del rapporto tra una variabile di tipo int ed una di tipo double; (f) la
stampa dei risultati ottenuti. Iniziamo a sviluppare il
programma passo per passo: Organizzazione del
codice: (1) l’esercizio
richiede di dichiarare alcune variabili, quindi il codice dovrà iniziare con istruzioni
che permettano di effettuare tali operazioni (2) dopo
la dichiarazione, l’esercizio richiede l’inizializzazione delle variabili;
tale operazione può essere svolta in concomitanza con la dichiarazione o con
istruzioni separate. Fatto questo si può procedere con il calcolo delle
quantità richieste (3) l’esercizio
richiede di visualizzare sul monitor i risultati ottenuti. Sarà quindi necessario
far riferimento alla libreria standard per
poter richiamare la funzione necessaria alla visualizzazione delle variabili,
ovvero printf(). Tale funzione si trova inserita nel file di
intestazione stdio.h. Preparazione della struttura del codice: /* inizialmente si richiamano
i file necessari al funzionamento del programma, in questo caso il file di intestazione
della libreria standard stdio.h (NOTA: i simboli che precedono e seguono
queste righe servono per inserire un commento nel codice)*/ #include <stdio.h> main() { … istruzioni … } Avendo stabilito quali sono le
operazioni da svolgere ed avendo preparato la struttura del codice, possiamo
iniziare a scrivere le istruzioni necessarie a svolgere le operazioni
richieste. Argomenti - ripasso
Espressioni, assegnazioni ed istruzioni Le espressioni e le
assegnazioni sono gli elementi costitutivi delle istruzioni del linguaggio.
Le espressioni sono composte da variabili ed operatori; le assegnazioni si
utilizzano per modificare il valore di una variabile, in particolare per
assegnarle il valore di un’espressione. Quando un’espressione e/o
un’istruzione sono seguite dal simbolo ‘;’ esse diventano istruzioni. IMPORTANTE: espressioni
ed assegnazioni POSSIEDONO UN VALORE (come le variabili) int
var1,var2,var3,var4; (var1 + var2) ; // la porzione
di codice tra parentesi è un’espressione var3 = var1 + var 2; //
assegno il valore dell’espressione alla variabile var3 var4 = (var3 = var1 + var2) ;
// assegno a var3 il valore dell’espressione “var1 + var2” /* visto che l’assegnazione ha
un valore (ovvero il valore che viene assegnato a var3), posso assegnare tale
valore a var4. Dopo aver eseguito questa istruzione var3 e var4 avranno lo
stesso valore */ var4 + var3 = var1 + var2; // questo invece NON ha senso ! Le conversioni esplicite ed
implicite (cast) (1) Nell’effettuare
operazioni tra variabili dello stesso tipo, il risultato viene automaticamente
rappresentato secondo il tipo delle variabili. (2) Quando
vengono effettuate operazioni che coinvolgono variabili di diverso tipo, il risultato
viene automaticamente rappresentato secondo il tipo della variabile che occupa
più memoria (per evitare di perdere cifre significative). Tali operazioni vengono effettuate
automaticamente dal programma, e si indicano pertanto con il termine di conversioni
implicite (cast implicito). Per non seguire tali regole e poter
rappresentare i valori delle variabili in modo arbitrario si ricorre alla
conversione esplicita del VALORE della variabile, si effettua quindi
un cast esplicito. int num = 4; double test = 0.; test = 4.35 + (double)
num; // conversione esplicita del
valore della variabile num La funzione printf(“
stringa di formato “,variabile1,variabile2,… ) La stringa di formato contiene le informazioni che permettono al programma di stabilire come la stringa stessa e le variabili inserite dopo la stringa debbano essere visualizzate. printf(“prova di stampa
\n”); // solo stringa di formato Tale istruzione produce il
seguente output: prova di stampa int num=1; printf(“ stampo un numero: %d
\n”,num); // stringa di formato
contenente uno //
specificatore di formato Tale istruzione produce il seguente
output: stampo un numero: 1 Nota: Ad ogni specificatore di
formato DEVE corrispondere una variabile. I caratteri contenuti nella stringa
di formato vengono visualizzati direttamente sul monitor; gli specificatori
di formato vengono sostituiti con il valore della variabile corrispondente. ---------------------------
Versione 1
---------------------------
---------------------------
Fine versione 1
--------------------------- L’output del programma è:
---------------------------
Versione 2
---------------------------
---------------------------
Fine versione 2
--------------------------- Attenzione: il carattere
‘;’ indica il termine di un’istruzione, quindi in linea di principio anche il
codice che segue è scritto in modo corretto: #include <stdio.h> main()
{int var1=5,var2=23,var3=0; double dec1=3.1415; var3 = var1 * var2 ;
printf(“il prodotto vale : %d \n”,var3); printf(“%d \n”,var1 * var2);
printf(“%d \n”,var3 = var1 * var2); var3 = var1 / var2 ; printf(“%d \n”,var3); printf(“%d \n”,var1
/ var2); printf(“%f \n”, ((double) var1)/var2); printf(“%e \n”, ((double)
var1)/var2); dec1 = ((double) var1)/var2; var3 = ((double) var1)/var2; dec1 =
var2 / dec1 ; } Tale codice, però, risulta
illeggibile ... La scelta degli identificatori: Gli identificatori servono ad identificare una data variabile e devono essere scelti, se possibile, in modo da far capire quale sia la funzione della medesima variabile all’interno del codice (non è buona norma, quindi, chiamare le variabili a, b, c, ... Un identificatore: (1) NON può iniziare con un numero (var_1 è lecito, 1_var no !) (2) NON può contenere caratteri speciali (come #, &, ., *, !, ?, (, ), ...) (3) È buona norma (ma non è una pratica illegale) che non inizi con il carattere ‘_’ in quanto in questo modo potrebbe interferire con variabili utilizzate dalla libreria standard Il programma appena scritto
utilizza delle variabili di tipo int e di tipo double; esso necessita quindi
di un certo quantitativo di memoria per poter conservare il valore di tali
variabili. Lo spazio occupato aumenta man mano che le variabili vengono
dichiarate ed ogni variabile occupa lo spazio che compete al tipo della
variabile stessa. La dimensione che una variabile occupa in memoria si
calcola mediante l’operatore sizeof(). Esempio:
calcolo della quantità di memoria occupata da una variabile #include <stdio.h> main() {int
numero = 234; printf("\n lo spazio occupato in
memoria dal tipo int e\’ pari a %d Byte \n",sizeof(int)); printf("\n la variabile \’ numero\’
occupa uno spazio pari a %d Byte \n",sizeof(numero)); printf("\n i due valori coincidono
\n") ; } L’operatore sizeof()
quindi si può applicare sia ai tipi che agli identificatori. Tornando all’esercizio di
prima, cerchiamo di stabilire quanta memoria venga utilizzata dal programma
in fase di esecuzione e quando essa venga resa accessibile.
|
