L'introduzione dei tipi e delle enumerazioni implica l'uso di identificatori per distinguere le varie entità cui facciamo riferimento nel nostro codice.
Un identificatore è un nome associato univocamente ad una sola entità in un determinato ambito di visibilità.
Questa definizione può sembrare fumosa per via dell'uso di termini generici quali "entità" e "ambito". Per lo scopo di questa lezione è sufficiente considerare le variabili come entità e un blocco di parentesi graffe {...} come ambito di visibilità.
Sebbene lo spazio dei nomi disponibili sia immenso, esistono delle regole di nomenclatura che ne limitano l'estensione.
Un identificatore valido è costituito da una qualsiasi sequenza di simboli appartenente all'insieme di lettere maiuscole, minuscole ed il carattere di sottolineatura (_), seguito da altre lettere e/o numberi, e ancora il carattere _.
Seguendo questa regola, x, _prova2, _2prove, La_mia_variabile sono identificativi perfettamente validi, mentre 1test, =prova o a!b non lo sono.
Inoltre poichè il C++ è case-sensitive, x e X sono due identificatori distinti.
Generalmente il numero massimo di caratteri per un identificatore è limitato. Tuttavia lo standard non prescrive un limite preciso, e poichè una fase del processo di compilazione consiste nel "decorare" gli identificatori scelti dal programmatore, esso è spesso dipendente dal compilatore utilizzato, ma è generalmente piuttosto elevato (1024 caratteri o più) o in certi casi illimitato.
Infine, le norme di buona programmazione impongono di scegliere accuratamente il nome delle variabili in base al loro significato nel contesto di utilizzo.
Ad esempio, "media" o "somma" possono essere nomi più espressivi di "x" e caratterizzare meglio la loro funzione in una porzione di codice. La lunghezza dei nomi scelti non influenza le performance dell'eseguibile, pertanto si possono usare parole complesse a piacimento. Il limite è costituito dalla leggibilità, dal buon senso e dal riferimento semantico associato all'identificatore scelto.
Le parole riservate
Le parole chiave del linguaggio sono particolari identificatori il cui uso è riservato, appunto, per la definizione dei costrutti sintattici. Alcuni esempi sono int, enum e return.
Sono tuttavia ammissibili identificatori in cui le parole chiave appaiono come sottosequenze, ad esempio int_x o return0.
L'elenco completo delle parole chiave del linguaggio varia in base allo standard adottato, generalmente aumentando via via che vengono introdotti nuovi costrutti sintattici. Non lo riportiamo interamente per brevità, considerando anche che l'uso di qualsiasi IDE ci aiuta ad identificare le parole riservate grazie alle funzionalità di evidenziazione automatica; tuttavia una tabella riepilogativa è disponibile a questo link.
Convenzioni di nomenclatura
Un altro aspetto da considerare nella scelta degli identificatori è quello relativo alla scelta di una particolare convenzione per la selezione dei nomi.
È infatti una buona norma quella di applicare una certa logica nell'uso degli identificatori, che in questo contesto non ha implicazioni con la "semantica", ma con la leggibilità e l'uniformità del codice. Questo aspetto è particolarmente importante quando si lavora in team, o si partecipa ad un progetto di sviluppo già avviato.
Ad esempio, si può stabilire che particolari identificatori comincino con la lettera maiiscola, ad esempio il nome delle classi, e i membri di classe inizino sempre con la minuscola.
Tali scelte non sono dettate da esigenze meramente stilistiche, ma dall'esigenza di rendere quanto più rapida la lettura e la comprensione di un listato, nonchè la funzione di ogni entità presente.
Se si usano particolari framework, ad esempio di elementi grafici per l'interfaccia, è possibile uniformarsi alla convenzione applicata, per evitare di spezzare lo stile dei listati prodotti.
Esistono già degli stili predefiniti ampiamente diffusi. Uno di questi è noto come snake_case ed è lo stile di riferimento per le librerie che fanno parte dello standard C++.
Lo stile è molto semplice e minimale: tutti gli identificatori sono costituiti da lettere minuscole, intervallate dal simbolo _ per i nomi composti. Di seguito sono riportati alcuni esempi.
// Convenzione snake_case
int sum; // nome semplice
float degree_to_radiants; // nome composto
string s; // la classe std::string
void do_something(); // il nome di una funzioneRientra in questo stile anche l'uso di particolari suffissi, come _t per le dichiarazioni di tipi, ampiamente diffuso in C, e _m per alcuni membri di classe.
Altri stili ampiamente diffusi sono noti come Camel Case e Pascal Case, in cui l'uso del simbolo _ è sostituito dall'alternanza di lettere maiuscole e minuscole per i nomi composti.
// Convenzione Camel Case
int sum; // nome semplice
float degreeToRadiants; // nome composto
void doSomething(); // il nome di una funzione
// Convenzione Pascal Case
int Sum; // nome semplice
float DegreeToRadiants; // nome composto
void DoSomething(); // il nome di una funzioneIn realtà non è importante aderire ad uno stile in particolare, quanto il fatto di aderire ad uno stile, meglio se minimale e di semplice decodifica, nonchè privo decorazioni non funzionali.