Variabili e tipi di dato in C++

Una variabile è un'area di memoria a cui viene assegnato un nome e che può contenere un valore. In C++ ogni variabile possiede un tipo, ovvero un'indicazione precisa della natura del dato che può contenere e dello spazio che occupa in memoria. Il C++ è un linguaggio a tipizzazione statica: il tipo di ogni variabile viene determinato durante la compilazione e non può cambiare durante l'esecuzione del programma. Questa caratteristica permette al compilatore di individuare molti errori prima ancora che il programma venga eseguito.

I tipi fondamentali

Il linguaggio mette a disposizione un insieme di tipi fondamentali, detti anche tipi primitivi, che rappresentano i valori più elementari. I principali sono i numeri interi, i numeri in virgola mobile, i caratteri e i valori booleani.

#include <iostream>

int main() {
    int age = 30;              // Numero intero
    double price = 19.99;       // Numero in virgola mobile a doppia precisione
    char grade = 'A';          // Singolo carattere
    bool isActive = true;     // Valore booleano: vero o falso

    std::cout << age << " " << price << " " << grade << " " << isActive << std::endl;
    return 0;
}

Il tipo int rappresenta numeri interi con segno; double rappresenta numeri reali con parte decimale; char contiene un singolo carattere, racchiuso tra apici singoli; bool può assumere solo i valori true o false. Esistono anche varianti come short, long, unsigned e float, che modificano l'intervallo di valori rappresentabili o la precisione.

Dichiarazione e inizializzazione

Dichiarare una variabile significa comunicare al compilatore il suo nome e il suo tipo. Inizializzarla significa assegnarle un valore iniziale. È buona pratica inizializzare sempre le variabili al momento della dichiarazione, perché una variabile non inizializzata contiene un valore indefinito e leggerlo produce comportamenti imprevedibili.

Il C++ moderno offre più sintassi per l'inizializzazione. Oltre all'assegnamento con il segno di uguale, esiste l'inizializzazione con le parentesi graffe, detta inizializzazione uniforme, che ha il vantaggio di segnalare con un errore le conversioni che potrebbero causare perdita di dati.

int count = 10;        // Inizializzazione tradizionale
int total{42};        // Inizializzazione uniforme con parentesi graffe
int quantity(7);     // Inizializzazione con parentesi tonde

La parola chiave auto

In molti casi il compilatore è in grado di dedurre automaticamente il tipo di una variabile a partire dal valore con cui viene inizializzata. La parola chiave auto sfrutta questa capacità, rendendo il codice più conciso, soprattutto quando i tipi sono lunghi o complessi. È importante ricordare che auto richiede sempre un'inizializzazione, proprio perché il tipo viene dedotto dal valore.

auto temperature = 36.6;   // Dedotto come double
auto letter = 'B';          // Dedotto come char
auto enabled = false;       // Dedotto come bool

Costanti con const e constexpr

Quando un valore non deve cambiare durante l'esecuzione, lo si dichiara costante. La parola chiave const impedisce qualsiasi modifica successiva alla variabile: ogni tentativo di riassegnarla produce un errore di compilazione. La parola chiave constexpr, introdotta con gli standard più recenti, indica un valore costante calcolabile già durante la compilazione, utile per ottimizzazioni e per esprimere con chiarezza l'intento del programmatore.

const double PI = 3.14159;        // Valore costante a runtime
constexpr int MAX_USERS = 100;     // Costante nota a compile time

Conversioni tra tipi

Spesso è necessario convertire un valore da un tipo a un altro. Le conversioni implicite avvengono automaticamente quando il compilatore le ritiene sicure, ad esempio passando da un intero a un numero in virgola mobile. Le conversioni esplicite, invece, vengono richieste dal programmatore quando il rischio di perdita di informazioni è concreto e si vuole rendere evidente l'intenzione.

type">int wholePart = 7;
double result = wholePart / 2.0;          // Conversione implicita: result vale 3.5

double measurement = 9.81;
int truncated = static_cast<int>(measurement);  // Conversione esplicita: truncated vale 9

L'operatore static_cast è il modo idiomatico e sicuro di eseguire conversioni esplicite in C++, da preferire allo stile ereditato dal linguaggio C. Comprendere bene i tipi e le loro conversioni è essenziale, perché molti errori sottili nei programmi nascono proprio da conversioni inattese o da perdite di precisione non previste.