|
* il C è case sensitive, quindi le maiuscole sono distinte dalle minuscole
* il numero di caratteri significativi è di almeno 31 caratteri ('''63''' per l'ultimo standard) per i nomi ''interni'', e 6 caratteri ('''31''' per l'ultimo standard) per quelli ''esterni''
* le parole riservate come <ttcode>if</ttcode>, <ttcode>int</ttcode>, ... non possono essere usate per i nomi delle variabili
Il numero di caratteri significativi indica quanti caratteri iniziali, nel nome, possono essere uguali, prima che intervenga un conflitto di similitudine
==I tipi di variabili==
Ad ogni variabile in C deve essere associato un tipo, quindi quando si dichiara una variabile bisogna specificare sempre di che tipo è. In C le [[w:Variabile (informatica)|variabili]] possono essere di 5 tipi base:
* <ttcode>int</ttcode>: sono i numeri interi (16 bit).
* {{IndexItem|float}}<ttcode>float</ttcode>: sono i numeri a virgola mobile (in inglese "floating-point") a precisione singola (32 bit).
* {{IndexItem|double}}<ttcode>double</ttcode>: sono i numeri a virgola mobile a precisione doppia (64 bit).
* {{IndexItem|char}}<ttcode>char</ttcode>: sono le variabili che contengono un carattere (8 bit).
* {{IndexItem|void}}<ttcode>void</ttcode>: il non-tipo: non si possono creare variabili void, ma questo tipo è usato per dichiarare {{IndexItem|puntatore}}[[C/Vettori e puntatori/Puntatori|puntatori]] generici (che possono puntare a qualunque tipo di dati) e per definire funzioni che non restituiscono alcun valore.
Le dimensioni reali del tipo <ttcode>int</ttcode>, e che decidono quindi la gamma di numeri rappresentabili, dipendono strettamente dall'implementazione (compilatore e tipo di processore).
Le specifiche di linguaggio suggeriscono che abbia una ''dimensione naturale suggerita dall'ambiente di esecuzione''; questo si traduce solitamente in almeno 16 bit (gamma numerica da -32768 a +32767), anche nella maggioranza dei processori/compilatori a 8 bit, ma con processori a 32 bit è piuttosto comune che il compilatore usi <ttcode>int</ttcode> a 32 bit (gamma da -2147483648 a +2147483647).
In casi particolari anche le dimensioni del tipo <ttcode>char</ttcode> sono state aumentate dal minimo degli 8 bit, come per alcuni [[w:Digital_Signal_Processor|DSP]]. In quel caso poteva essere giocoforza, date alcune [[w:Arithmetic_Logic_Unit|ALU]] a soli 16 o 32 bit, costringere anche il tipo <ttcode>char</ttcode> a 16 o 32 bit.
Per la certezza delle dimensioni rimane in ogni caso fondamentale la documentazione del compilatore, oltre che il file [[C/Header|header]] <ttcode>limits.h</ttcode> fornito; in questo file sono presenti delle definizioni con [[C/Compilatore_e_precompilatore/Direttive|#define]], come ad esempio <ttcode>INT_MIN</ttcode> e <ttcode>INT_MAX</ttcode>, ai limiti di gamma numerica rappresentabile.
Uno scopo analogo è dato al file header <ttcode>float.h</ttcode>, per i numeri a rappresentazione in virgola mobile.
==Esempi d'uso==
==={{IndexItem|const}}const===
Il comando <ttcode>const</ttcode> dichiara delle {{IndexItem|costante}}costanti, ovvero dei nomi assegnati in modo fisso a dei valori. In pratica sono come delle {{IndexItem|macro}}macro, solo che non accettano funzioni come valore.
Si può usare anche la {{IndexItem|direttiva}}[[C/Compilatore e precompilatore/Istruzioni al precompilatore|direttiva]] <ttcode>#define</ttcode> per ottenere lo stesso risultato, ma in generale l'uso di <ttcode>const</ttcode> è preferibile.
Inoltre le variabili <ttcode>const</ttcode> sono anche usate come parametri delle {{IndexItem|funzione}}[[C/Blocchi e funzioni/Funzioni|funzioni]] per assicurarsi che all'interno della funzione il valore di una variabile non possa subire variazioni.
<source lang="c">
==={{IndexItem|volatile}}volatile===
La parola chiave <ttcode>volatile</ttcode> indica al compilatore che il valore della corrispondente variabile potrebbe essere modificato da eventi esterni al normale flusso sequenziale di esecuzione delle istruzioni.
In condizioni normali un compilatore può ottimizzare una sequenza consecutiva di accessi in lettura ad una variabile privi di scritture intermedie producendo un codice eseguibile che ne prelevi il valore dalla memoria un'unica volta, collocandolo in uno dei registri del processore, e successivamente riutilizzare tale registro nella certezza che questo continui a contenere il valore corretto.
L'opzione <ttcode>volatile</ttcode> elimina tale certezza, costringendo di fatto il compilatore a produrre codice che rilegge il valore della variabile dalla memoria per ogni accesso in lettura, non essendovi garanzia che questo sia, nel frattempo, rimasto inalterato.
<source lang="c">
Lo specificatore <ttcode>static</ttcode> assume un secondo significato se la variabile è definita al livello base del file (fuori da qualsiasi funzione).
In quel caso, oltre a indicare che la sua esistenza in memoria è valida per tutta l'esecuzione del programma, indica anche che la sua ''visibilità'' è ristretta all'interno del modulo (file).
Nessun altro modulo di programma potrà farvi riferimento con lo specificatore <ttcode>extern</ttcode>.
Questo permette di avere variabili con nomi uguali, specificate in moduli diversi, senza che possano avere conflitti fra loro: ciascuna sarà visibile solo nel proprio modulo.
==={{IndexItem|auto}}auto===
La classe di memorizzazione <ttcode>auto</ttcode> indica che una variabile può essere assegnata in memoria in modo automatico dal compilatore. Questo tipo di memorizzazione ha senso solo all'interno di una funzione.
Il suo uso è decaduto rapidamente nel tempo, in quanto è il tipo di memorizzazione predefinito all'interno delle funzioni, per cui non necessita di essere specificato.
==={{IndexItem|auto}}extern===
La classe di memorizzazione <ttcode>extern</ttcode> indica che una variabile è definita esternamente al modulo.
La definizione <ttcode>extern</ttcode> ha lo scopo d'informare il compilatore che ogni riferimento alla variabile dovrà essere predisposto e infine risolto solo nella fase finale di [[w:linking|linking]].
<source lang="C">
==={{IndexItem|register}}register===
Lo specificatore <ttcode>register</ttcode> indica che l'uso di una variabile è critico per il tempo di esecuzione del programma: il suo accesso dovrà quindi essere più veloce possibile, con la memorizzazione diretta in un registro della {{IndexItem|CPU}}[[w:CPU|CPU]] o tramite altri metodi in grado di velocizzarne l'accesso. Questo comando potrebbe essere ignorato dal compilatore se non vi sono registri liberi nella CPU (nel contesto di esecuzione in cui la variabile è visibile), oppure se i registri liberi non sono di dimensioni sufficienti a contenere il tipo di dato.
<source lang="c">
==={{IndexItem|long}}long===
Lo specificatore <ttcode>long</ttcode> può essere impiegato sia come modificatore di alcuni tipi base (aumentando lo spazio assegnato alla variabile), che direttamente come tipo di dati, applicandosi in modo predefinito al tipo <ttcode>int</ttcode>.
Ad esempio, con
long b;
</source>
le due variabili hanno le stesse dimensioni, come spazio di memorizzazione (fino al doppio delle dimensioni del tipo <ttcode>int</ttcode>, potendo rappresentare quindi una gamma di valori più ampia).
La relazione fra variabili <ttcode>int</ttcode> e <ttcode>long</ttcode> è in realtà dipendente dall'implementazione del compilatore: su sistemi a 8/16 bit si possono avere casi in cui <ttcode>int</ttcode> ha una rappresentazione a 16 bit e <ttcode>long</ttcode> a 32 bit, mentre su sistemi a 32 bit non è infrequente trovare sia <ttcode>int</ttcode> che <ttcode>long</ttcode> a 32 bit.
Alcune implementazioni permettono la doppia specificazione <ttcode>long</ttcode>, aumentando ancora la dimensione di alcuni tipi di dato, per esempio:
<source lang="C">
long long foo; /* Variabile a 64 bit */
==={{IndexItem|short}}short===
Lo specificatore <ttcode>short</ttcode> può essere impiegato sia come modificatore di alcuni tipi base (riducendo lo spazio assegnato alla variabile), che direttamente come tipo di dati, applicandosi in modo predefinito al tipo int.
Ad esempio, nel caso
short b;
</source>
le due variabili hanno le stesse dimensioni, in modo analogo alle considerazioni per lo specificatore <ttcode>long</ttcode>.
==={{IndexItem|signed}}signed===
Lo specificatore <ttcode>signed</ttcode> indica che una data variabile va trattata con segno positivo o negativo, nei calcoli aritmetici. Può essere impiegato sia come modificatore di alcuni tipi base, che direttamente come tipo di dati, applicandosi in modo predefinito al tipo <ttcode>int</ttcode>.
Ad esempio, nel caso
signed c;
</source>
le tre variabili hanno dimensioni e funzionalità equivalenti (il tipo <ttcode>int</ttcode> viene già trattato con segno aritmetico).
==={{IndexItem|unsigned}}unsigned===
Lo specificatore <ttcode>unsigned</ttcode> indica che una data variabile va trattata sempre con segno positivo, nei calcoli aritmetici. Può essere impiegato sia come modificatore di alcuni tipi base, che direttamente come tipo di dati, applicandosi in modo predefinito al tipo <ttcode>int</ttcode>.
Ad esempio, nel caso
le due variabili hanno dimensioni e funzionalità equivalenti.
Uno degli scopi più comuni del trattare variabili ''senza segno'' (ovvero sempre come valori positivi o zero) è quello di ampliare la gamma di valori nel campo positivo, per le quantità numeriche che non necessitano di rappresentazione negativa. Una variabile <ttcode>int</ttcode> a 32 bit può spaziare numericamente da -2147483648 a +2147483647, mentre se dichiarata <ttcode>unsigned int</ttcode> può andare da 0 a 4294967295.
[[Categoria:C|Variabili]]
| 