Dichiarazioni Variabili

Tipi testuali
nome tipo	dichiarazione	dimensione
char	char ch	1 byte
char [N]	char stringa[10]	1 byte per il numero di elementi dell'array
Tipi Numerici Interi
nome tipo	dichiarazione	dimensione
bool	bool x	1 byte
short	short sx	2 byte
long / int	int x long y	4 byte
Tipi Numerici con Decimali
nome tipo	dichiarazione	dimensione
float	float a	4 byte
double	double d	8 byte

Tipi Numerici Complessi
nome tipo	dichiarazione	dimensione
float _Complex	float _Complex a	8 byte
double _Complex	double _Complex d	16 byte

Esempio

#include 
int main(int argc, char *argv[])
{
    printf("###################################################\n");
    printf("#  T I P I    D I   D A T O   I N   D E V  C + +  #\n");
    printf("###################################################\n\n");
    printf("- Tipi Testuali: ----------------------------------\n");
    printf("    char:                 %2d byte;\n",sizeof(char));
    printf("    char [10]:            %2d byte;\n",sizeof(char[10]));
    printf("---------------------------------------------------\n\n");

    printf("- Tipi Numerici Interi: ---------------------------\n");
    printf("    bool:                 %2d byte;\n",sizeof(bool));
    printf("    short:                %2d byte \n",sizeof(short));
    printf("      unsigned short:     %2d byte \n",sizeof(unsigned short));
    printf("      signed short:       %2d byte;\n",sizeof(signed short));
    printf("    int:                  %2d byte \n",sizeof(int));
    printf("      unsigned int:       %2d byte \n",sizeof(unsigned int));
    printf("      signed int:         %2d byte \n",sizeof(signed int));
    printf("      short int:          %2d byte \n",sizeof(short int));
    printf("      long int:           %2d byte \n",sizeof(long int));
    printf("      unsigned short int: %2d byte \n",sizeof(unsigned short int));
    printf("      signed short int:   %2d byte \n",sizeof(signed short int));
    printf("      unsigned long int:  %2d byte \n",sizeof(unsigned long int));
    printf("      signed long int:    %2d byte \n",sizeof(signed long int));
    printf("      long long int:      %2d byte;\n",sizeof(long long int));
    printf("    long:                 %2d byte \n",sizeof(long));
    printf("      unsigned long:      %2d byte \n",sizeof(unsigned long));
    printf("      signed long:        %2d byte \n",sizeof(unsigned long));
    printf("      long long:          %2d byte \n",sizeof(long long));
    printf("      unsigned long long: %2d byte \n",sizeof(unsigned long long));
    printf("      signed long long:   %2d byte;\n",sizeof(signed long long));
    printf("---------------------------------------------------\n\n");

    printf("- Tipi Numerici Decimali: --------------------------\n");
    printf("    float:                %2d byte;\n",sizeof(float));
    printf("    double:               %2d byte;\n",sizeof(double));
    printf("    long double:          %2d byte;\n",sizeof(long double));
    printf("---------------------------------------------------\n\n");

    printf("- Tipi Numerici Complessi : -----------------------\n");
    printf("    float _Complex:       %2d byte;\n",sizeof(float _Complex));
    printf("    double _Complex:      %2d byte;\n",sizeof(double _Complex));
    printf("    long double _Complex: %2d byte;\n",sizeof(long double _Complex));
    printf("---------------------------------------------------\n\n");
}

Link utili

Un programma è una sequenza lineare di istruzioni. Durante l'esecuzione questa può avere diramazioni, ripetere del codice o prendere delle decisioni. Le istruzioni condizionali (o di selezione) ci consentono di far eseguire in modo selettivo una singola riga di codice o una serie di righe di codice (che viene detta blocco di istruzioni).

IF

if (condizione) istruzioni-se_vero

L'istruzione if consente l'esecuzione di una porzione di codice sulla base della veridicità di una condizione:

Esempio IF

#include <stdio.h>
int main() 
{
    int n,m;
    printf("Digita un numero intero : ");
    scanf("%d", &n);
    // CONSTRUTTO IF
    m=n;
    if (m<0)
       m=-n;
    // OUTPUT
    printf("Il modulo di %d e' %d",n,m);

    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

IF/ELSE

if (condizione)
   istruzioni-se_vero
else
   istruzioni-se_falso

L'istruzione if/else consente di selezionare quale porzione di codice eseguire sulla base di una condizione

Esempio IF / ELSE

#include <stdio.h>
int main() 
{
    int n,m;
    printf("Digita un numero intero : ");
    scanf("%d", &n);
    // CONSTRUTTO IF
    if (n<0)
       m=-n;
    else
       m=n;
    // OUTPUT
    printf("Il modulo di %d e' %d",n,m);

    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

L'istruzione if/else può essere nidificata una dentro l'altra.

Esempio IF / ELSE nidificato

#include <stdio.h>
int main() 
{
    int n;
    printf("Digita un numero intero : ");
    scanf("%d", &n);

	// CONSTRUTTO DI SELEZIONE
    if (n==0)
        printf("Il numero e' Zero");        
    else
        {
            if(n % 2 == 0) 
                printf("Il numero e' pari");        
            else
                printf("Il numero e' dispari");        
        }  

    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

IF/ELSE IF/ELSE

if (condizioni_1)
   Istruzioni_1;
else if (condizioni_2)
   Istruzioni_2;
   .
   .
   .
else if (condizioni_n)
   Istruzioni_n;
else
   Istruzioni_default;

Le istruzioni if/else if/else sono molto intuitive se si considera che le parole inglesi if, else, else if corrispondono rispettivamente alle italiane se, altrimenti e altrimenti se.

Esempio IF / ELSE IF / ELSE

#include <stdio.h>
int main() 
{
    int n;
    printf("Digita un numero intero : ");
    scanf("%d", &n);

	// CONSTRUTTO DI SELEZIONE
    if (n==0)
       printf("Il numero e' Zero");        
    else if(n % 2 == 0) 
       printf("Il numero e' pari");        
    else
       printf("Il numero e' dispari");
 	  	  
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

IF immediato

espressione_test ? azione_true : azione_false;

L’istruzione condizionale ? fornisce un modo rapido per scrivere una condizione di test. Le azioni associate all’istruzione condizionale vengono eseguite in base al valore dell’espressione_test (TRUE oppure FALSE). Quindi l’operatore ? può essere utilizzato per sostituire un’istruzione if-else. L’operatore ? viene anche denominato operatore ternario in quanto richiede tre operandi.

Esempio ?

#include <stdio.h>
int main() 
{
    int n;
    printf("Digita un numero intero : ");
    scanf("%d", &n);

    // CONSTRUTTO ?
    printf("E' %s",( (n==0) ?  "Zero" : ( (n % 2 == 0) ?  "Pari" : "Dispari" ) ) );

    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

Switch

switch (espressione)
{
   case constante1:
      Istruzioni_1;
      break;
   case constante2:
      Istruzioni_2;
      break;
   .
   .
   .
   default:
      Istruzioni_default
}

L'istruzione switch è particolarmente utile quando in un programma si deve dare all’utente la possibilità di scegliere tra più opzioni (esempio i menu). L'espressione_test deve essere un numero intero o un tipo enumerativo oppure una classe che ha una singola funzione di conversione che restituisce un intero o un tipo enumerativo.
Il costrutto switch esegue le seguenti operazioni:
- Valuta il valore dell’espressione intera passata come parametro all’istruzione switch.
- Rimanda lo svolgimento del programma al blocco in cui il parametro dell’istruzione case ha lo stesso valore di quello ottenuto nell’istruzione switch.
- Se il blocco individuato termina con un’istruzione break allora il programma esce dallo switch altrimenti, vengono eseguiti anche i blocchi successivi finché un’istruzione break non viene individuata oppure non si raggiunge l’ultimo blocco dello switch.
- Se nessun blocco corrisponde ad un valore uguale a quello dell’istruzione switch allora viene eseguito il blocco default, se presente.

Esempio SWITCH

#include <stdio.h>
int main ()
{
   // Stampa Menu
   char c;
   printf("MENU:\n------------------------\n");
   printf("a) INSERISCI SCHEDA\n");
   printf("b) MODIFICA  SCHEDA\n");
   printf("c) ELIMINA   SCHEDA\n");
   printf("0) ESCI\n------------------------\n");
   printf("\t\tscelta: ");
   scanf("%c", &c);
   // Gestione Menu
   switch(c)
   {
       case 'A' :
       case 'a' :
          printf("Hai selezionato il menu a)");
          break;
       case 'B' :
       case 'b' :
          printf("Hai selezionato il menu b)");
          break;
       case 'C' :
       case 'c' :
          printf("Hai selezionato il menu c)");
          break;
      case '0' :
          printf("Hai selezionato l'uscita");
          break;
       default :
          printf("Voce non prevista!");
    }
    
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

Link utili

Le istruzioni iterative sono quelle che ci consentono di ripetere l'esecuzione di una singola riga di codice o di una serie di righe di codice (che viene detta blocco di istruzioni).

While

while (condizione)
{
   Blocco Istruzioni;
}

All'inizio di ogni ciclo WHILE la condizione viene valutata assieme agli effetti collaterali, dopodiche' se l'espressione risulta vera (diversa da zero), viene eseguito il "blocco istruzioni" ed il ciclo viene riavviato nuovamente. Il while ha termine appena l'espressione risulta falsa (o ha un valore nullo). E' possibile che il "blocco istruzioni" non venga mai eseguito. All'interno del "blocco istruzioni" può comparire l'istruzione break che, se eseguita, provoca il termine del while nonché l'istruzione continue che, una volta invocata, riavvia immediatamente un nuovo ciclo. In caso di cicli innestati, entrambe le istruzioni break e continue non hanno influenza sui cicli più esterni.

Esempio WHILE

#include <stdio.h>
int main() 
{
    int n;
    // Continuo a leggere finche' non digito 0
    printf("Digita un numero intero : ");
    scanf("%d", &n);
    while (n!=0) 
    {
        printf("Digita un numero intero : ");
        scanf("%d", &n);
    }
 
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

Link utili

DO WHILE

do {
   Blocco Istruzioni;
} while (condizione)

Per ogni ciclo viene prima eseguito il "Blocco istruzioni" e poi viene valutata la condizione. Se risulta vera (diversa da zero) il ciclo viene riavviato, altrimenti l'istruzione do ha termine. Lo statement viene eseguito almeno 1 volta.
All'interno del "blocco istruzioni" può comparire l'istruzione break che, se eseguita, provoca il termine del while nonché l'istruzione continue che, una volta invocata, riavvia immediatamente un nuovo ciclo. In caso di cicli innestati, entrambe le istruzioni break e continue

Esempio DO/WHILE

#include <stdio.h>
int main() 
{
    // Continuo a leggere finche' non digito 0
    int n;
    do {
        printf("Digita un numero intero : ");
        scanf("%d", &n);
    } while (n!=0); 
    
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

Link utili

FOR

for ( inizializzazione; condizione; incremento )
{
   Blocco Istruzioni;
}

Si osservi che inizializzazione, condizione ed incremento sono opzionali. Se nella sezione inizializzazione ed incremento  voglio inserire più di una istruzione mi basta separarle con la virgola. Prima di iniziare il ciclo FOR, viene valutata l'inizializzazione (se presente). In seguito ha inizio il ciclo FOR. Per ogni ciclo viene valutata la condizione  (se presente). Se la condizione risulta vera (diversa da zero), oppure se e' assente, viene eseguito il "blocco istruzioni" e al termine viene eseguita l'istruzione "incremento" (se presente) ed il ciclo riprende nuovamente. All'interno del "blocco istruzioni" può comparire l'istruzione break che, se eseguita, provoca il termine del for nonché l'istruzione continue che, una volta invocata, riavvia immediatamente un nuovo ciclo. In caso di cicli innestati, entrambe le istruzioni break e continue

Esempio FOR

#include <stdio.h>
#include 
#include  // Richiesta da system()
int main() 
{
    // DICHIARAZIONE VARIABILI/INIZIALIZZAZIONE
    int n=1; // inizializzazione fittizia per attivare l'iterazione
    for ( ; n!=0; printf("Digita un numero intero : "),scanf("%d", &n) );
    
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return(0);
}

Link utili

int printf ( const char * format, ... );

La funzione printf() scrive sul canale standard di output (stdout) gli argomenti passati, eseguendo le opportune conversioni indicate nella stringa di formattazione format. Richiede: <stdio.h>

Valore di ritorno

Esempio

#include <stdio.h>
int main() 
{
    // ----------------------------------------------------
    // ESEMPI DI SCRITTURA
    // ----------------------------------------------------
    printf("Scrivo un int ogni 5 spazi: \n%5d\n%5d\n\n", 23, 32767);
    printf ("Characters: %c %c \n", 'a', 65);
    printf ("Decimals: %d %ld\n", 1977, 650000L);
    printf ("Preceding with blanks: %10d \n", 1977);
    printf ("Preceding with zeros: %010d \n", 1977);
    printf ("Some different radixes: %d %x %o %#x %#o \n", 100, 100, 100, 100, 100);
    printf ("floats: %4.2f %+.0e %E \n", 3.1416, 3.1416, 3.1416);
    printf ("Width trick: %*d \n", 5, 10);
    printf ("%s \n", "A string");
    
    // --------------------------------------------------------
    // - N U M E R I    I N T E R I     C O N    S E G N O
    // --------------------------------------------------------
    printf("Scrivo un short int (2 byte): %10hd\n", 32767);
    printf("Scrivo un int (4 byte)      : %ld\n", 2147483647);
    printf("Scrivo un long int (4 byte) : %ld\n", 2147483647);
    printf("\n");
   
    // --------------------------------------------------------
    // - N U M E R I    I N T E R I    S E N Z A    S E G N O
    // --------------------------------------------------------
    unsigned short int uSN=65535;
    unsigned int uN=4294967295;
    unsigned long int uLN=4294967295;
    printf("Scrivo un unsigned short int (2 byte - 2^16-1) : %10hu\n", uN);
    printf("Scrivo un unsigned int (4 byte - 2^32-1)       : %u\n", uN);
    printf("Scrivo un unsigned long int (4 byte - 2^32-1)  : %lu\n",uLN);
    printf("\n");

    // ----------------------------------------------------
    // - N U M E R I    R E A L I
    // ----------------------------------------------------
    float f=0.33333333333333333333;
    double lf=0.33333333333333333333;
    printf("Scrivo un float (4 byte)       : %.20f\n", f);
    printf("Scrivo un double (8 byte)      : %.20lf\n", lf);
    
    fflush(stdin);
    getchar();
    return(0);
}

Link utili

int int scanf(char *format, puntat1, puntat2, ...) ( const char * format, ... );

La funzione scanf legge dei caratteri dal canale standard di input (stdin), li converte secondo le specifiche di formattazione fornite dall'argomento format e li salva nelle locazioni di memoria puntate dagli argomenti puntat1, puntat2, .... Richiede: <stdio.h>. E' importante notare che la funzione scanf richiede di specificare l'indirizzo di ogni variabile, oppure un puntatore ad essa. Ad esempio: scanf("%d",&i); Non è necessario mettere l'operatore indirizzo & se l'argomento della scanf è un array oppure una stringa poichè il nome della variabile corrisponde all'indirizzo di partenza dell'array/stringa

char Nome[20];
scanf("%s",Nome);

oppure

char Nome[20];
scanf("%s",&Nome[0]); La stringa di formattazione formatpuo' contenere sia caratteri ordinari che direttive di conversione. Caratteri a spazio (spazi, tab o new line) contenuti in format attendono dall'input un numero qualsiasi, compreso nessuno, di caratteri a spazio (spazi, tab o new line). La maggior parte delle conversioni, saltano gli spazi bianchi iniziali. In caso che format contenga dei caratteri ordinari, questi devono corrispondere ai caratteri letti in input. La scansione si arresta quando un carattere in input non trova piu' corrispondenza con la stringa di formattazione, oppure quando una conversione non puo' essere eseguita. La direttiva di conversione e' formata da:

Valore di ritorno

Esempio

#include <stdio.h>
int main() 
{
    // ----------------------------------------------------
    // ESEMPI DI LETTURA
    // ----------------------------------------------------
    char s[30],p[30];
    printf("STRINGHE:\n");
    scanf("%5s",s); // leggo al + 5 char
    scanf("%8s%*s",p); // leggo al + 8 char e scarico il buffer
    printf("Ho letto: %s - %s\n",s,p);

    int i, n, m;
    printf("NUMERI INTERI:\n");
    i=scanf("%d%d",&n,&m); // Usa come separatore \n, \t o blank
    printf("Ho letto %d argomenti: %d - %d\n",i, n,m);
    // Scrittura Equivalente
    scanf("%d",&n); // Usa come separatore \n, \t o blank
    scanf("%d",&m); // Usa come separatore \n, \t o blank
    printf("Ho letto: %d - %d\n", n,m);
    
    // ----------------------------------------------------
    // - N U M E R I    I N T E R I     C O N    S E G N O
    // ----------------------------------------------------
    // SHORT INT: provare i valori 32767, 32768 e 65536 (2^15-1, 2^15, 2^16)
    printf("NUMERI SHORT INT (2 byte):\n");
    short int SInt; 
    scanf("%hd",&SInt); 
    printf("Ho letto: %hd\n", SInt);
    // LONG INT: provare i valori 65536 e 4294967295 (2^16, 2^32-1)
    printf("NUMERI LONG INT (4 byte):\n");
    long int LInt;
    scanf("%ld",&LInt); // Usa come separatore \n, \t o blank
    printf("Ho letto: %ld\n", LInt);
    // LONG LONG INT: provare i valori 9223372036854775807 (2^63-1) e
    //                9223372036854775808 (2^63)
    printf("NUMERI LONG LONG INT (8 byte):\n");
    long long int LLInt;
    scanf("%lld",&LLInt); // Usa come separatore \n, \t o blank
    printf("Ho letto: %lld\n", LLInt);

    // --------------------------------------------------------
    // - N U M E R I    I N T E R I    S E N Z A    S E G N O
    // --------------------------------------------------------
    // SHORT UNSIGNED INT: provare i valori 65535 e 65536 (2^16-1, 2^16)
    printf("NUMERI SHORT INT (2 byte):\n");
    short unsigned int SuInt; 
    scanf("%hu",&SuInt); 
    printf("Ho letto: %hu\n", SuInt);
    // LONG INT: provare i valori 4294967295 e 4294967296 (2^32-1, 2^32)
    printf("NUMERI LONG INT (4 byte):\n");
    long int LuInt;
    scanf("%lu",&LuInt); // Usa come separatore \n, \t o blank
    printf("Ho letto: %lu\n", LuInt);
    // LONG LONG INT: provare i valori 9223372036854775807 (2^64-1) e
    //                9223372036854775808 (2^64)
    long long int LLuInt;
    printf("NUMERI LONG LONG INT (8 byte):\n");
    scanf("%llu",&LLuInt); // Usa come separatore \n, \t o blank
    printf("Ho letto: %llu\n", LLuInt);
   
    // ----------------------------------------------------
    // - N U M E R I    R E A L I
    // ----------------------------------------------------
    // FLOAT: prova 0.33333333333333333333
    printf("NUMERI FLOAT (4 byte):\n");
    float f;
    scanf("%f",&f); 
    printf("Ho letto: %.20f\n", f);
    // DOUBLE: prova 0.33333333333333333333
    printf("NUMERI DOUBLE (8 byte):\n");
    double d;
    scanf("%lf",&d); 
    printf("Ho letto: %.20lf\n", d);
    // LONG DOUBLE: prova 0.33333333333333333333
    // Si noti che tra long double e double non vi è alcuna differenza in devc++
    // Questo segue dal fatto che devc++ usa MinGW che è compilato con gcc
    // per cui utilizza il runtime della Microsoft - Si tratta di un bugs di MinGW
    printf("NUMERI LONG DOUBLE (12 byte):\n");
    long double ld;
    scanf("%Lf",&ld); 
    printf("Ho letto: %.20Lf\n", ld);
    
    fflush(stdin);
    getchar();
    return(0);
}

Link utili

int rand ( void );

La funzione rand genera un numero intero casuale. Richiede: <stdlib.h>. Per evitare che generi sempre la stessa sequenza occorre usare la funzione srand() che inizializza il generatore di numeri casuali.

Valore di ritorno

Restituisce un numero intero casuale tra 0 e RAND_MAX. Il valore RAND_MAX è definito nella libreria: <stdlib.h>. Generalmente vale 32.767 (2¹⁵-1).

Esempio

#include <stdio.h>
#include <stdlib.h>
int main() 
{
    // Genera sempre lo stesso numero (41)
    int n;
    n=rand();
    printf("%d",n);
    
    fflush(stdin);
    getchar();
    return(0);
}

Link utili

void srand ( unsigned int seed );

La funzione srand() inizializza il generatore di numeri casuali. Richiede: <stdlib.h>. Usando come argomento la funzione time(NULL) facciamo dipendere il seme (seed) dal tempo e di conseguenza le sequenze generate risultano sempre diverse nelle diverse esecuzioni.

Valore di ritorno

Nessuno.

Esempio

#include <stdio.h>
#include <stdlib.h>
#include <time.h> // richiesto dalla funzione time()
int main() 
{
    // Genera sempre lo stesso numero (41)
    // Equivale all'inizializzazione srand(1)
    int n;
    n=rand();
    printf("%d\n",n);

    // Genera sempre lo stesso numero (38)
    srand(0);
    n=rand();
    printf("%d\n",n);

    // Genera sempre lo stesso numero (41)
    srand(1);
    n=rand();
    printf("%d\n",n);
    
    // Genera sempre lo stesso numero (45)
    srand(2);
    n=rand();
    printf("%d\n",n);

    // Genera numeri sempre diversi
    srand((unsigned int)time(NULL));
    n=rand();
    printf("%d\n",n);

    fflush(stdin);
    getchar();
    return(0);
}

Link utili

time_t time ( time_t * timer );

Restituisce l'orario corrente come oggetto time_t. Lo stesso valore può essere registrato anche nel parametro *timer (se questo non è reso assente ponendo l'argomento a NULL!). Il tipo time_t, restituito dalla funzione time(), è generalmente definito come un long int che contiene il numero di secondi trascorsi dalle 00:00 del 1 gennaio 1970 (corrisponde al timestamp di unix). Con questa rappresentazione del tempo è possibile effettuare delle operazioni aritmetiche. Richiede <time.h>.

Valore di ritorno

Restituisce un oggetto t_time contenente l'orario corrente. Se l'argomento non è NULL il valore ritornato dalla funzione viene memorizzato nella locazione di memoria puntata dall'argomento stesso. In caso di errore restituisce -1.

Esempio

#include <stdio.h>
#include <time.h> // richiesto dalla funzione time()
int main() 
{
    unsigned int n;
    n=(unsigned int)time(NULL);
    printf("%u\n",n);

    fflush(stdin);
    getchar();
    return(0);
}

Link utili