Visita Orebla.it su Facebook Segui Orebla.it su Twitter Vedi i video su YouTube di Orebla.it Unisciti alle cerchie di Orebla.it
DOVE TI TROVI: \\ Home Page\c\Guida al C : Uso delle variabili

Guida al C/C++

autore: BlackLight
xx/xx/xx

Uso delle variabili:

In tutti i linguaggi di programmazione le variabili rivestono un ruolo molto importante, se non fondamentale, nella scrittura del programma.
Le variabili dell'informatica sono una sorta di "contenitori" che al loro interno possono contenere numeri interi, numeri a virgola mobile, caratteri di testo ecc.
Ecco come si dichiara una variabile in C:

tipo nome_variabile;


Possiamo anche assegnarle un valore iniziale, in questo modo:

tipo nome_variabile = valore_iniziale;


Il tipo di variabile è la caratteristica principale della variabile stessa: ecco i principali tipi ammessi dal C:

Tipo

Uso

Memoria occupata (bit)

char

Caratteri di testo ASCII

8

short int

Numeri interi piccoli (da -32768 a 32768)

16

unsigned short int

Numeri positivi interi piccoli (da 0 a 65536)

16

int

Numeri interi (da -2147483648 a 2147483648)

32

unsigned int

Numeri interi positivi (da 0 a 4294967296)

32

long int

Numeri interi grandi

32

float

Numeri a virgola mobile (precisione singola)

32

double

Numeri a virgola mobile (doppia precisione, notazione scientifica)

64



Esempio:

int a; // Dichiaro una variabile intera chiamata a senza inizializzarla
int b = 3; // Dichiaro una variabile intera b che vale 3
char c = 'q'; // Dichiaro una variabile char che contiene il carattere q
float d = 3.5; // Dichiaro una variabile float d che vale 3.5
a = 2; // Adesso a vale 2
int e = a+b; // e vale la somma di a e b, ossia 5

Come vedete, è possibile fare con le variabili ogni tipo di operazione matematica: addizione (+), sottrazione (-), moltiplicazione (*), divisione (/), resto della divisione (%). Diamo però un'occhiata a questo codice:
int a = 2; // Variabile int
float b = 3.5; // Variabile float
int c = a+b; // ERRORE!


Quello che ho riportato sopra è un errore molto frequente anche fra i programmatori più esperti, se provo a compilare un codice del genere otterrò un warning (un "avvertimento del compilatore, che però non pregiudica la compilazione vera e propria) o, più spesso, un errore vero e proprio (la compilazione viene arrestata).
Non posso effettuare operazioni fra due tipi di variabili diversi fra loro (int questo caso, int e float): per farlo devo ricorrere alla conversione di cast. Esempio corretto:
int a = 2;
float b = 3.5;
int c = (int) a+b; // Converto il risultato in int. c vale 5 in questo caso
Oppure:
int a = 2;
float b = 3.5;
float c = (float) a+b; // Converto il risultato in float. c vale 5.5 in questo caso


A differenza delle variabili "matematiche", in C una scrittura del genere è concessa:
int a = a+2; // Aggiorno il valore di a

Oppure, in modo più sintetico:

int a += 2;


La scrittura a += 2 sta per a = a+2 (sono concesse scritture come += -= *= /= %=).
La scrittura a++ è invece un incremento della variabile a, ed equivale a a=a+1 (così come la scrittura a-- equivale a a=a-1).
È anche possibile usare le variabili in funzioni come la printf(). Prendete ad esempio il seguente codice:
int x = 3;
printf ("x vale %d",x);

L'output sarà:
x vale 3

La direttiva %d dice al compilatore di stampare la variabile intera posta fuori i doppi apici "". In questo caso stampa il valore di x, che è proprio 3.
Se invece voglio stampare una variabile di tipo float, farei così:
float x = 3.14;
printf ("x vale %f",x);


dove la scrittura %f dice al compilatore di stampare una variabile di tipo float. Ecco le direttive principali usate per stampare i principali tipi di variabili:

Direttiva

Uso

%c

Variabili char

%d %i

Variabili int e short int in formato decimale (quello che usiamo comunemente)

%x %X

Varabili int, short int, long int o char in formato esadecimale

%o

Variabili in formato ottale

%l %ld

Variabili long int

%u

Variabili unsigned

%f

Variabili float

%lf

Variabili double

%p

Indirizzo esadecimale di un puntatore (li vedremo più avanti...)

%s

Stringhe di testo (le vedremo più avanti...)

%n

Scrive i byte scritti finora sullo stack dalla funzione printf() (la vedremo più avanti, quando parleremo del format string overflow...)



Esempio:
/* variabili.c */

#include < stdio.h >
int main() {
int a,b,c; // Dichiaro 3 variabili int
a = 3;
b = 4;
c = a+b; // c vale 7
printf ("c vale %d\n",c);
a += 3; // Ora a vale 6
b++; // Ora b vale 5
c = a-b; // Ora c vale -1
printf ("Ora c vale %d\n",c);
return 0;
}


Abbastanza semplice, no?
Il fatto interessante è che possiamo eseguire opeazioni anche sulle variabili char! Le variabili char, infatti, vengono considerate dal programma come codici ASCII, ovvero ogni variabile ha il suo codice numerico (da 0 a 255) che viene convertito in runtime in un carattere (attenzione che in linguaggi come Java queste operazioni non sono concesse, in quanto i caratteri non sono in formato ASCII ma Unicode). Ecco un esempio:
char c = 65; // Equivale a scrivere char c = 'A', infatti
// 65 è il codice per la lettera A
char c += 4; // Ora a vale E
printf ("a = %c\n",c);

Variabili locali e globali
In C, le variabili vanno dichiarate o all'inizio del programma o all'inizio della funzione che le usa. Attenzione che è un errore dichiarare una variabile in altri posti! Esempio:
int main() {
printf ("Ciao ciao a tutti!\n");
int b = 3; // ERRORE!
}

In C++ non si ha questo errore, in quanto la dichiarazione di una variabile è considerata un'istruzione vera e propria e può essere messa ovunque, ma in C c'è l'errore.

Le variabili dichiarate all'inizio del programma vengono dette globali e possono essere usate da ogni funzione del programma (lo vedremo meglio quando parleremo delle funzioni), mentre le variabili locali possono essere viste solo dalla funzione che le dichiara (in C++ è anche possibile far vedere le variabili ad un solo blocco di codice). Esempio:
#include < stdio.h >

int var_globale = 3; // Variabile globale
int main() {
int var_locale = 2; // Variabile locale
.......
var_globale += var_locale; // È possibile perchè var_globale è una variabile globale
.......
}


Variabili static e auto
Le variabili globali in genere sono statiche, ossia vengono instanziate in memoria quando il programma viene chiamato e distrutte quando il programma viene chiuso. Le variabili locali invece in genere sono automatiche, ossia vengono instanziate quando la funzione che le dichiara viene invocata e vengono distrutte quando la funzione chiamante è termnata. È però possibile stabilire se una variabile deve essere static e automatica attraverso le keyword static e auto. Esempio:


.....
auto int x = 7; // Variabile automatica
int main() {
static float pi = 3.14; // Variabile statica
.....
}


Costanti: l'istruzione #define e la keyword const
È possibile dichiarare anche delle costanti in C, o variabili a sola lettura, delle variabili cioè che possono venire lette ma su cui non è possibile scrivere. I modi sono due:
  • Attraverso l'istruzione #define:

    #include < stdio.h >
    /* Definisco la costante PI, che vale 3.14 */
    #define PI 3.14
    int main() {
    float area, raggio;
    .....
    area = raggio*PI*PI;
    .....
    }
  • Attraverso la keyword const:

    .....
    const float pi = 3.14;
    .....
    area = raggio*pi*pi;
    .....


L'istruzione #define è, come la #include, un'istruzione al preprocessore. In poche parole, quando il compilatore incappa in una #define, legge il valore assegnato alla costante (anche se non è propriamente una costante, in quanto non viene allocata in memoria), cerca quella costante all'interno del programma e gli sostituisce il valore specificato in real-time. Con la const, invece, creo una vera e propria variabile a sola lettura in modo pulito e veloce, e per dichiarre una costante è di gran lunga preferito quest'ultimo metodo. Ovviamente una scrittura come questa darà un errore (o un warning):

const float pi = 3.14;
pi += 1;
in quanto una costante non si può modificare. Variabili register e volatile

Le variabili vengono in genere allocate nella memoria RAM (nello stack se sono statiche, nello heap se sono dinamiche). Ma in C è anche possibile allocare una variabile in un registro del processore (in genere l'accumulatore, EAX) attraverso la keyword register:

register int var_reg = 3;

Ovviamente, in genere è sconsigliato allocare variabili nei registri, in quanto per i registri ci passa una marea di informazioni importanti per la sessione, per il programma ecc. e la variabile può facilmente andar persa.

Dichiarando invece una variabile come volatile, questa variabile può venir modificata da alti processi o da altre parti del programma in qualsiasi momento:

volatile int vol_var;





Articoli utili:
Jailbreak iOS 10: tweaks compatibili

Recensione iPhone 6

IPhone 7 uscito, novita, prezzi