Variabili in C++: dichiarazione, inizializzazione e scope

Cos'è una variabile

Una variabile è un pezzo di memoria con un nome che contiene un valore. In C++ ogni variabile ha un tipo fisso, scelto quando la dichiari, e quel tipo non cambia mai. È questo che rende il C++ tipizzato staticamente: il compilatore conosce il tipo di ogni variabile prima che il programma venga eseguito e si rifiuta di compilare codice che memorizza il tipo di valore sbagliato.

Una dichiarazione ha tre parti: il tipo, il nome e (quasi sempre) un valore iniziale.

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 30;
    string name = "Ada";
    bool isActive = true;

    cout << name << " is " << age << ", active: " << isActive << "\n";
    return 0;
}

Leggi int age = 30; come "crea un int chiamato age e mettici dentro 30". Il punto e virgola chiude l'istruzione, proprio come la pagina sui commenti ha mostrato che fa ogni istruzione. Nota che isActive viene stampato come 1: di default bool si mostra come 1/0, un aspetto che la pagina sui tipi di dato approfondisce.

Inizializzazione e assegnazione

Si somigliano ma sono operazioni diverse, e la differenza è una delle idee più importanti di questa pagina.

L'inizializzazione dà a una variabile il suo primo valore come parte della dichiarazione. L'assegnazione cambia il valore di una variabile che esiste già.

#include <iostream>
using namespace std;

int main() {
    int score = 95;   // inizializzazione: primo valore, dato nella dichiarazione
    score = 100;      // assegnazione: cambia una variabile esistente
    score = score + 5;

    cout << score << "\n";
    return 0;
}

Puoi dichiarare senza inizializzare e assegnare in seguito, ma fai attenzione:

#include <iostream>
using namespace std;

int main() {
    int score;     // dichiarata, ma per ora contiene spazzatura
    score = 95;    // ora ha un valore reale
    cout << score << "\n";
    return 0;
}

Funziona perché abbiamo assegnato score prima di leggerla. La versione pericolosa è leggerla per prima, come vediamo adesso.

L'insidia della variabile non inizializzata

Questa è la classica trappola del C++ che in molti altri linguaggi non esiste. Leggere una variabile locale dichiarata ma a cui non è mai stato dato un valore è undefined behavior: la variabile contiene i byte che si trovavano per caso in quella memoria.

int score;             // non inizializzata
std::cout << score;    // undefined behavior: stampa spazzatura, oppure "funziona", oppure crasha

Il compilatore lo compilerà senza problemi. Potrebbe stampare 0, potrebbe stampare 32766, e potrebbe comportarsi diversamente a ogni esecuzione o su ogni macchina, il che rende questi bug un incubo da rintracciare. Due difese:

• Inizializza sempre nella dichiarazione. int score = 0; non costa nulla ed elimina del tutto il problema.
• Attiva gli avvisi. Compilare con -Wall -Wextra fa sì che il compilatore segnali molte letture non inizializzate prima che ti creino problemi.

Preferisci la prima opzione per ogni variabile locale: dalle un valore iniziale sensato nel momento in cui la crei.

Stili di inizializzazione: =, () e {}

Il C++ ti offre alcuni modi per scrivere un valore iniziale. Per lo più fanno la stessa cosa, ma l'inizializzazione con le graffe ha una protezione in più che vale la pena conoscere.

#include <iostream>
using namespace std;

int main() {
    int a = 5;     // inizializzazione per copia
    int b(5);      // inizializzazione diretta
    int c{5};      // inizializzazione con graffe (uniforme): da C++11 in poi

    cout << a << " " << b << " " << c << "\n";
    return 0;
}

Il motivo per preferire {} è che rifiuta le conversioni narrowing, cioè le assegnazioni che perderebbero dati in silenzio. Con =, un valore decimale viene troncato senza dire nulla; con {}, il compilatore ti ferma:

int x = 3.9;    // compila: x diventa 3 in silenzio (lo .9 viene scartato)
int y{3.9};     // errore di compilazione: il narrowing da double a int non è permesso

Scoprirlo in fase di compilazione è esattamente ciò che vuoi. Un'abitudine moderna diffusa è usare {} di default per quel controllo in più, tornando a = solo quando l'inizializzazione per copia si legge in modo più naturale.

Regole e convenzioni per i nomi

Il C++ impone alcune regole rigide, poi tutti ci aggiungono sopra delle convenzioni. Le regole: un nome può contenere lettere, cifre e _; non può iniziare con una cifra; non può essere una parola chiave riservata (come int o return); ed è sensibile alle maiuscole (age e Age sono due variabili diverse). Evita i nomi che iniziano con un underscore seguito da una maiuscola, o che contengono due underscore di fila: sono riservati all'implementazione.

Le convenzioni seguite dalla maggior parte del codice C++:

• Le variabili usano snake_case o camelCase: scegline uno e resta coerente, item_count oppure itemCount.
• I nomi devono descrivere il valore: count, non c; user_email, non x.

#include <iostream>
using namespace std;

int main() {
    int item_count = 3;
    double price_per_item = 4.50;
    double total_price = item_count * price_per_item;

    cout << "Total: " << total_price << "\n";
    return 0;
}

I nomi chiari non sono decorazione: sono il modo in cui il te stesso del futuro leggerà il codice. total_price = item_count * price_per_item si spiega da solo in un modo in cui t = c * p non lo farà mai.

Lo scope delle variabili

Una variabile esiste solo dentro il blocco, le { ... }, in cui è dichiarata, e viene distrutta alla graffa di chiusura. Questo è il suo scope (ambito di visibilità). Una variabile dichiarata dentro un ciclo o un blocco if è invisibile all'esterno:

#include <iostream>
using namespace std;

int main() {
    int total = 0;

    for (int i = 1; i <= 3; i++) {
        int square = i * i;   // 'square' vive solo dentro il corpo di questo ciclo
        total += square;
    }

    cout << "Total: " << total << "\n";
    // cout << square;   // errore: qui 'square' è fuori dal suo scope
    return 0;
}

Sia i sia square appartengono al ciclo e spariscono quando termina; total è dichiarata nel blocco esterno, quindi sopravvive. Un blocco interno può anche oscurare (shadowing) un nome di un blocco esterno: una nuova variabile con lo stesso nome nasconde temporaneamente quella esterna finché il blocco interno non si chiude. È una fonte frequente di confusione, quindi evita di riutilizzare i nomi tra scope annidati.

In pratica: dichiara ogni variabile nel blocco più piccolo che ne ha bisogno, e inizializzala lì. Uno scope ristretto significa meno nomi che competono per la tua attenzione e meno occasioni di leggere un valore lontano da dove è stato impostato.

Prossimo: tipi di dato

Ogni variabile di questa pagina è partita da un tipo: int, double, string, bool. La prossima pagina analizza nel dettaglio i tipi di dato del C++: i tipi fondamentali e le loro dimensioni, interi con e senza segno, float e double, char, e come scegliere il tipo giusto per ogni compito.