La+sintassi

I controlli **IF**,**IF** – **ELSE** sono controlli condizionali, ovvero sono delle condizioni che, se verificate, eseguono un pezzo di codice o altrimenti ne eseguono un altro. Le sintassi dei comandi sopra elencati sono: 1- La sintassi dell’if : istruzione; // es. : // // somma=somma+a; // 2- La sintassi dell’if – else : istruzione1; // es. : // //num_pari=a;// **//else//** //num_disp=a;//
 * I CONTROLLI CONDIZIONALI **
 * if ** (espressione)
 * // if //**// (a != 0) //
 * if ** (espressione)
 * else ** istruzione2;
 * // if //**// (a%2==0) //

Esiste anche un modo molto più sintetico per scrivere l'istruzione if...else, ed è il seguente:
 * condizione ** ? **istruzione1** : **istruzione2;**

dove:

if = ? ed else = : esempio: (a%2 == 0) ? num_pari=a : num_disp=a; // // Se il modulo di a è uguale a zero assegni il valore di a alla variabile num_pari, altrimenti assegni il valore di a alla variabile num_disp. //

Nelle espressioni di controllo tra le parentesi dell’if, ci sono dei valori relazionali da ricordare: Inoltre bisogna conoscere degli operatori logici che ci permetteranno di unire, includere o negare delle condizioni: oltre agli operatori logici, ci sono anche gli operatori aritmetici, che servono per eseguire calcoli tra variabili:
 * a == b ** → testa se a è uguale a b (in C = vuol dire assegnazione!!);
 * a > b ** → testa se a è maggiore di b; **a >= b** → testa se a è maggiore o uguale a b; **a < b** → testa se a è minore di b; **a <= b** → testa se a è minore o uguale a b; **a != b** → testa se a è diverso da b.
 * && ** → AND; **||** → OR; **!** → NOT;

‘ ** * ** ’ → Prodotto; ‘ ** / ** ‘→ Rapporto; ‘**%**’ → Modulo. Calcola il resto di una divisione intera. (Es. 9 % 5 = 4); ‘ ** + ** ’ → Somma; ‘ ** - ** ‘ → Differenza (negativo); L’incremento o il decremento di una variabile avviene aggiungendo o togliendo 1 al valore già presente nella stessa tramite la seguente sintassi: **a++** ( → a=a+1) o **a--** ( → a=a-1). Esempio di programma con i controlli condizionali:
 * *= ** → Moltiplica il valore della variabile a sinistra per il valore a destra e lo riassegna alla variabile;
 * /= ** → Come il precedente, ma con il rapporto;
 * %= ** → Come il precedente, ma con l'operatore modulo;
 * += ** → Aggiunge alla variabile a sinistra il valore a destra;
 * -= ** → Sottrae alla variabile a sinistra il valore a destra.
 * 1) include "stdafx.h" ////libreria standard//
 * 2) include "stdlib.h" ////libreria per l'input/output//

{ ////apertura della funzione main// **int** a, b, ris=0; ////dichiarazione di variabili intere// **char** car; ////dichiarazione di variabile char// printf("inserisci il primo valore: "); ////richiesta di inserimento da parte dell'utente// scanf("%d",&a); ////assegnazione del valore inserito alla variabile a// printf("inserisci il secondo valore: "); //richiesta di inserimento da parte dell'utente scanf("%d",&b); ////assegnazione del valore inserito alla variabile b// printf("inserisci l'operando: "); ////richiesta di inserimento da parte dell'utente// getchar; ////siccome lo scanf prenderebbe l'invio come carattere, questo comando fa si che non succeda// scanf("%c",&car); ////assegnazione del carattere inserito alla variabile car// **if**(car=='+') ////se car è uguale a +, esegue l'istruzione ed esce, altrimenti va avanti// ris=a+b; ////assegna a ris il valore di a+b// **if**(car=='-') ////se car è uguale a -, esegue l'istruzione ed esce, altrimenti va avanti// ris=a-b; ////assegna a ris il valore di a-b// **if**(car=='*') ////se car è uguale a *, esegue l'istruzione ed esce, altrimenti va avanti// ris=a*b; ////assegna a ris il valore di a*b// **if**(car=='/') ////se car è uguale a / esegue l'istruzione ed esce, altrimenti va avanti// ris=a/b; ////assegna a ris il valore di a/b// printf("il risultato dell' operazione %d %c %d e' %d\n", a, car, b, ris); ////manda in output la scritta con i valori indicati// **system**("pause"); //ferma l'esecuzione del programma **return** 0; } ////chiusura della funzione main// ** COSTRUTTO MULTICONDIZIONALE ** I costrutti multicondizionali sono costrutti in cui si confronta una variabile per più condizioni, elaborando processi diversi per ogni condizione, ma utilizzandone una sola. Un metodo è l’indentazione di più **IF**-**ELSE**: printf(“scelta == %d”, scelta); printf(“scelta == %d”, scelta); printf(“scelta == %d”, scelta); **else**. ..
 * int ** _tmain(int argc, _TCHAR* argv[]) ////tipo nome_funzione(parametri) __! FUNZIONE MAIN !__//
 * if ** (scelta == 0)
 * else **
 * if ** (scelta == 1)
 * else **
 * if ** (scelta == 2)

Questo metodo è molto macchinoso e lungo, decisamente sconsigliato. Un metodo migliore è lo **SWITCH CASE**. Questo particolare comando permette di rappresentare più condizioni. Il comando si utilizza in questo modo: { **case** valore_variabile : comandi; **break**; **case** valore_variabile: comandi; **break**; **case** valore_variabile: comandi; } Es.: printf(“inserisci 1 per saluto, 2 per domanda, 3 per risposta \n”); scanf(“%d”, &scelta); { **case** 1: printf(“Ciao \n” ); **break**; printf(“Che ore sono? \n” ); **break**; **case** 3: printf(“Sono le dieci e mezza \n” ); } In questo caso la scelta comportava la visualizzazione di uno solo dei tre **CASE**.
 * switch ** (nome_variabile)
 * int ** scelta;
 * switch ** (scelta)
 * case ** 2:

** Nota: //BREAK// è un comando che interrompe una sequenza di comandi dentro gli //SWITCH CASE//, per non eseguire gli altri //CASE//, dentro i cicli //FOR// e //WHILE//, per interrompere un ciclo. **  ** I CICLI ** I cicli in un linguaggio di programmazione servono per far eseguire più volte una stessa istruzione senza dover necessariamente riscrivere il codice, rendendolo più snello e comprensibile. Esistono 3 tipo di cicli, pre-condizionali, post-condizionali ed il ciclo for.


 * CICLO PRE-CONDIZIONALE **

Il ciclo pre condizionale o ciclo **WHILE** permette di verificare la condizione prima di entrare nel ciclo dando la possibilità di conseguenza di poter non eseguire il ciclo o si a discrezione dell’operatore o del programmatore.

La sua sintassi è:
 * while ** (condizione){

istruzione } Esempio pratico ciclo **while**:
 * 1) include "stdafx.h"

{ **int** i = 0;
 * int ** _tmain(**int** argc, _TCHAR* argv[])

{ printf("%d n", i); i++; } getchar;
 * while ** (i != 100)

**return** 0; }

Questo ciclo permette al compilatore di stampare a video tutti i numeri fino al 99, momento in cui la condizione non sarà più vera e di conseguenza uscirà dal ciclo.


 * CICLO POST-CONDIZIONALE **

Il ciclo post-condizionale, o ciclo **DO-WHILE**, ha la caratteristica a differenza dell’while di far eseguire almeno una volta l’istruzione contenuta tra le due parentesi e solo dopo verificare se la condizione per eseguire una nuova volta il ciclo è vera o no.

La sua sintassi è:
 * do ** {

istruzione

}

**while**( condizione); Ad esempio può essere utile per chiedere ad un utente se vuole o no rieseguire nuovamente il programma.


 * 1) include "stdafx.h"

{ {  printf("prema 1 per rieseguire il programma\nprema due per uscire"); scanf("%d",&test); } **while**(test==1);
 * int ** _tmain(**int** argc, _TCHAR* argv[])
 * int ** test;
 * do **

getchar; **return** 0; }

Il ciclo **FOR** è senza dubbio il ciclo più usato e più potente presente nel linguaggio C. La sua sintassi è:
 * CICLO FOR **

**for**( inizializzazione variabile; Condizione; incremento) { Istruzione; } {  a++ }
 * for ** (int i=0; i<10; i++)

Il for potrebbe tranquillamente essere sostituito da un while se non fosse che è più conciso ed è usato quando sappiamo quante volte dovrà essere eseguito il ciclo. I parametri all'interno del for hanno diversi compiti, e sono separati da un punto e virgola: -Inizializzazione: viene eseguito prima di entrare nel ciclo, ed inizializza una variabile, generalmente la variabile è usata come variabile di controllo del ciclo, in poche parole servirà per tenere traccia del numero di iterazioni del ciclo. -Condizione: la condizione, che coinvolge anche la variabile di controllo, permette di uscire dal ciclo se risulta falsa. -Incremento: Il terzo parametro è l'istruzione di incremento, che viene eseguita dopo ogni ciclo del for; questa istruzione agisce sulla variabile dichiarata all’inizio. Esempio pratico:
 * 1) include "stdafx.h"

{ for(int i=0; i<100; i++){ printf("%d\n",i); } getchar; return 0; } Questo semplice programma permette al compilatore di contare fino a 99, esattamente come nel ciclo while mostrato sopra, con la differenza di risultare più immediato e di essere più breve nella scrittura. ** ARRAY MONODIMENSIONALE ** Gli array, o vettori, sono delle particolari variabili che contengono un numero finito di valori. Può essere visto come un raggruppamento di variabili con caratteristiche comuni. Il tipo più semplice è l’array monodimensionale. Si dichiara nel seguente modo: Es.:
 * int ** _tmain(**int** argc, _TCHAR* argv[])
 * tipo_variabile ** nome_varibile [Dimensione];
 * int ** vett[10];

La dimensione può essere statica o variabile, ma per ora tratteremo gli array statici. Questi hanno una dimensione prestabilita, in valore numerico o con una costante intera. Es.:
 * const int ** dim = 10;
 * int ** vett[dim];

Per inserire un singolo valore all’interno di un array basta nominare la posizione da utilizzare Es.: vett[5] = 90;
 * int ** vett[10];

In questo caso ho dato valore 90 a vett nella posizione 5.


 * NOTA: le posizioni di un array spaziano da 0 al valore massimo meno 1. Ciò significa che non esiste la posizione 10 in un array di dimensione 10, ma le sue posizioni vanno da 0 a 9. **

Ovviamente non è consigliabile il caricamento di una posizione singola. Un buon metodo è il caricamento tramite un ciclo **FOR**. Es.:
 * const ** **int** dim = 10;
 * int ** vett[dim], i;

{ scanf(“%d”, &vett[i]); }
 * for ** (i = 0; i < dim; i ++)

Si può anche utilizzare dei valori random per velocizzare ancora di più il processo. ** ARRAY MULTIDIMENSIONALE ** L’ array multidimensionale è un array con più dimensioni. Si dichiara nel seguente modo: Es.:
 * tipo_variabile ** nome_variabile[dimensione_1][dimensione_2]…[dimensione_k]
 * int ** multi[5][10][8];
 * float ** multi_dim[10][3];

Il numero di valori è definito dal prodotto delle dimensioni, ovvero se multi_dim ha dimensione 10 e 3, le variabili che contiene sono 30, mentre multi ne contiene 400.

Per caricare una sola posizione dell’array multidimensionale basta nominare la variabile con le varie coordinate della posizione. Es.: multi[3][0] = 35;
 * int ** multi [6][2];

multi alla posizione 3 della prima dimensione e 0 della seconda è uguale a 35.


 * NOTA: come gli array monodimensionali, le posizioni di ogni dimensione spaziano da 0 al valore massimo meno 1, quindi non puoi attribuire un valore a //multi [6][2]//, ma //multi[0-5][0-1]// . **

Il caricamento di un array multidimensionale è simile a quello monodimensionale, solo che bisogna mettere in ciclo per ogni dimensione. Es.:
 * const int ** dim = 10;
 * int ** multi[dim][dim][dim], i, j, k;

{ **for**(j = 0; j < dim; j ++) { **for**(k = 0; k < dim; k++) { scanf(“%d”, &multi [i][j][k]); } }  }
 * for ** (i = 0; i < dim; i ++)

In questo caso ci sono tre cicli indentati, ognuno per ogni dimensione.

** LE FUNZIONI ** Quando si deve sviluppare un programma complesso, oppure di grandi dimensioni, un'ottima tecnica è quella di utilizzare delle funzioni. Le funzioni sono comode perché il codice di una funzione è scritto una sola volta ma può essere eseguito più volte, ogni modulo può essere provato ed implementato singolarmente. Le funzioni non sono altro che blocchi di istruzioni. E’ possibile raggruppare questi blocchi di istruzioni (logicamente correlati) sotto un nome, il //nome della funzione// che verrà richiamata dove serve. La sintassi di una funzione qualsiasi è: #include ……….. //ambiente globale ** tipo ** nome_funzione {   // ambiente locale alla funzione ……………;   ……………;    }   ** main ** {   // ambiente locale al main …………….;   . // richiamo della funzione; ……………..;   }   Anche il **main** è una funzione perché raggruppa più istruzioni e non è richiamata da nessun'altra.

L'esecuzione comincia dal **main**.

Nella sintassi sopra descritta vediamo che le funzioni, come le variabili, hanno un tipo, che indica il tipo del valore da richiamare. I tipi di funzioni sono: 1- **void** --> non restituisce alcun valore; 2- **int** --> restituisce un valore di tipo intero; 3- **char** --> restituisce un valore di tipo char; 4- **float** --> restituisce un valore di tipo float.

L’invocazione della funzione, che avviene all’interno del main, avviene cosi: 1- funzione che restituisce un valore: var = nome_funzione(lista parametri attuali); Questa scrittura richiama il valore posto dopo il return nella funzione, ma con i parametri dichiarati nel main e nella lista parametri attuali. 2- funzione che non restituisce un valore: nome_funzione(lista parametri attuali);.

Ecco un programma semplice con le funzioni che fa la somma, la sottrazione, la moltiplicazione e la divisione:


 * 1) include "stdafx.h" ////libreria standard//
 * 2) include "stdlib.h" ////libreria di input/output//

{ **int** ris = 0; //// dichiarazione della variabile// ris = a+b; ////operazione da svolgere// **return** ris; ////valore che compare nella chiamata// } {  **int** ris = 0; //// dichiarazione della variabile// ris = a-b; ////operazione da svolgere// **return** ris; ////valore che compare nella chiamata// } {  **int** ris = 0; //// dichiarazione della variabile// ris = a*b; ////operazione da svolgere// **return** ris; ////valore che compare nella chiamata// } {  **int** ris = 0; //// dichiarazione della variabile// ris = a/b; ////operazione da svolgere// **return** ris; ////valore che compare nella chiamata// } {  **int** a, b, ris = 0; //// dichiarazione della variabile ed assegnazione della variabile ris// **char** car; //// dichiarazione della variabile// printf("inserisci il primo numero: "); //inserimento del numero da parte dell' utente scanf("%d",&a); ////assegnazione alla variabile a// printf("inserisci il secondo numero: "); ////inserimento del numero da parte dell' utente// scanf("%d",&b); ////assegnazione alla variabile b// printf("inserisci l'operando: "); ////inserimento dell'operatore aritmetico da parte dell'utente// getchar; //siccome lo scanf prenderebbe l'invio come carattere, questo comando fa si che non succeda scanf("%c",&car);//assegnazione alla variabile car **if**(car=='+') //controllo condizionale printf("%d %c %d = %d\n", a, car, b, ris=addizione(a,b)); ////se la condizione dell’ if è vera, esegue questo altrimenti va avanti// **if**(car=='-') //controllo condizionale
 * int ** addizione(**int** a, **int** b) ////nome_funz(parametri)//
 * int ** sottrazione(**int** a, **int** b)
 * int ** moltiplicazione(**int** a, **int** b)
 * int ** divisione(**int** a, **int** b)
 * int ** _tmain(**int** argc, _TCHAR* argv[])

printf("%d %c %d = %d\n", a, car, b, ris=sottrazione(a,b)); ////se la condizione dell’ if è vera, esegue questo altrimenti va avanti// **if**(car=='*') ////controllo condizionale// printf("%d %c %d = %d\n", a, car, b, ris=moltiplicazione(a,b)); ////se la condizione dell’if è vera, esegue questo altrimenti va avanti// **if**(car=='/') ////controllo condizionale// printf("%d %c %d = %d\n", a, car, b, ris=divisione(a,b)); ////se la condizione dell’if è vera, esegue questo altrimenti va avanti// system("pause"); //ferma il programma **return** 0; }

La differenza tra questo ed il programma con il controllo condizionale IF-ELSE è che, se avessimo bisogno di fare più operazioni uguali, dovremmo solo richiamare la funzione cambiando i parametri, rendendo cosi il programma più semplice alla lettura e rendendo più veloce anche la scrittura.