Le basi del C++: guida completa per il liceo

Il C++ è uno dei linguaggi più usati per imparare a programmare, ed è spesso il primo che si incontra al liceo. È un linguaggio compilato, veloce e rigoroso: ti obbliga a ragionare su come i dati vengono memorizzati e gestiti, e proprio per questo è un'ottima palestra. In questa guida vediamo tutte le basi, una alla volta, con esempi concreti che puoi provare subito.

Ogni programma C++ parte da una funzione speciale chiamata main: è il punto da cui inizia l'esecuzione. Ecco lo scheletro minimo che useremo come riferimento.

#include <iostream>
using namespace std;

int main() {
    cout << "Ciao, mondo!" << endl;
    return 0;
}

La riga #include <iostream> serve a usare l'input/output (cout per scrivere, cin per leggere). using namespace std evita di dover scrivere ogni volta std:: davanti ai comandi. Tutto ciò che scriveremo d'ora in poi va dentro il main, salvo le funzioni che definiremo a parte.

Variabili#

Una variabile è uno spazio in memoria con un nome, in cui possiamo salvare un valore che può cambiare durante il programma. Per crearla (dichiararla) si indica prima il tipo, poi il nome; possiamo anche assegnarle subito un valore iniziale.

int eta = 17;          // numero intero
double altezza = 1.75; // numero con la virgola
char voto = 'A';       // un singolo carattere
bool maggiorenne = false;

eta = 18;              // il valore può cambiare
maggiorenne = true;

Il nome di una variabile deve iniziare con una lettera, non può contenere spazi e non può essere una parola riservata del linguaggio. Conviene usare nomi chiari (eta, altezza) invece di lettere a caso: il codice diventa molto più leggibile.

Costanti#

Una costante è come una variabile, ma il suo valore non può più essere modificato dopo l'assegnazione iniziale. Si usa la parola chiave const. Sono utili per valori che non devono cambiare, come Pi greco o l'IVA, ed evitano modifiche accidentali.

const double PI = 3.14159;
const int GIORNI_SETTIMANA = 7;

// PI = 4;   // ERRORE: non si può modificare una costante

Tipi di variabili#

Ogni variabile ha un tipo, che stabilisce quali valori può contenere e quanta memoria occupa. Questi sono i tipi fondamentali che userai più spesso:

• ›int — numeri interi (es. -5, 0, 42).
• ›double (o float) — numeri con la virgola (es. 3.14, -0.5).
• ›char — un singolo carattere racchiuso tra apici singoli (es. 'A', '7').
• ›bool — valore logico, può essere solo true (vero) o false (falso).
• ›string — una sequenza di caratteri, cioè del testo (richiede #include <string>).

#include <string>

int numeroStudenti = 25;
double media = 7.8;
char sezione = 'B';
bool promosso = true;
string nome = "Simone";

Attenzione alla divisione tra interi: 7 / 2 dà 3 (la parte decimale viene tagliata), mentre 7.0 / 2 dà 3.5. Se ti serve il risultato con la virgola, almeno uno dei due numeri deve essere un double.

if ed else#

L'istruzione if permette di eseguire un blocco di codice solo se una condizione è vera. Con else indichiamo cosa fare quando invece è falsa. Le condizioni si costruiscono con gli operatori di confronto (==, !=, <, >, <=, >=) e logici (&& cioè E, || cioè O, ! cioè NON).

int voto = 6;

if (voto >= 6) {
    cout << "Promosso!" << endl;
} else {
    cout << "Insufficiente." << endl;
}

Nota la differenza tra = (assegnazione: metti un valore in una variabile) e == (confronto: chiedi se due valori sono uguali). Confonderli è uno degli errori più comuni quando si inizia.

else if: più condizioni in sequenza#

Quando i casi possibili sono più di due, possiamo concatenare più controlli con else if. Le condizioni vengono valutate dall'alto verso il basso e si ferma alla prima vera.

int voto = 8;

if (voto >= 9) {
    cout << "Ottimo" << endl;
} else if (voto >= 7) {
    cout << "Buono" << endl;
} else if (voto >= 6) {
    cout << "Sufficiente" << endl;
} else {
    cout << "Insufficiente" << endl;
}

Switch#

Quando dobbiamo confrontare una stessa variabile con molti valori precisi, lo switch è più ordinato di tanti else if. Ogni case rappresenta un valore; break serve a uscire dallo switch ed è importante non dimenticarlo, altrimenti l'esecuzione "scivola" nei case successivi. default gestisce tutti i casi non previsti.

int giorno = 3;

switch (giorno) {
    case 1:
        cout << "Lunedi" << endl;
        break;
    case 2:
        cout << "Martedi" << endl;
        break;
    case 3:
        cout << "Mercoledi" << endl;
        break;
    default:
        cout << "Altro giorno" << endl;
}

Lo switch funziona solo con tipi interi o char, non con i double o le string. Per condizioni più complesse (intervalli, confronti) restano necessari gli if.

I cicli: while, do-while e for#

I cicli (o loop) servono a ripetere un blocco di istruzioni più volte, senza riscriverlo. C++ ne offre tre, utili in situazioni diverse.

While#

Ripete il blocco finché la condizione resta vera. La condizione viene controllata prima di ogni ripetizione: se è già falsa all'inizio, il blocco non viene eseguito nemmeno una volta.

int i = 1;

while (i <= 5) {
    cout << i << " ";
    i++;            // incrementa i di 1; senza questo il ciclo non finisce mai
}
// Stampa: 1 2 3 4 5

Do-while#

Simile al while, ma la condizione viene controllata alla fine. Questo garantisce che il blocco venga eseguito almeno una volta: è perfetto, ad esempio, per i menu che devono comparire prima di chiedere una scelta all'utente.

int numero;

do {
    cout << "Inserisci un numero positivo: ";
    cin >> numero;
} while (numero <= 0);

For#

È il ciclo ideale quando sappiamo quante volte ripetere. Raccoglie in un'unica riga tre parti: l'inizializzazione del contatore, la condizione di continuazione e l'aggiornamento del contatore.

for (int i = 0; i < 5; i++) {
    cout << i << " ";
}
// Stampa: 0 1 2 3 4

Si legge così: parti da i = 0; continua finché i < 5; dopo ogni giro aumenta i di 1. Le parole chiave break (esce subito dal ciclo) e continue (salta al giro successivo) funzionano in tutti e tre i tipi di ciclo.

Array (vettori)#

Un array, chiamato anche vettore, è una sequenza di valori dello stesso tipo, memorizzati uno dopo l'altro e identificati da un indice. L'indice parte sempre da 0: in un array di 5 elementi le posizioni valide vanno da 0 a 4.

int voti[5] = {7, 8, 6, 9, 10};

cout << voti[0];   // primo elemento: 7
cout << voti[4];   // ultimo elemento: 10

voti[2] = 5;       // modifica il terzo elemento

Gli array si usano quasi sempre insieme a un ciclo for, che permette di scorrere tutte le posizioni con il contatore come indice. Ecco come calcolare la somma e la media dei voti.

int voti[5] = {7, 8, 6, 9, 10};
int somma = 0;

for (int i = 0; i < 5; i++) {
    somma += voti[i];     // somma = somma + voti[i]
}

double media = somma / 5.0;
cout << "Media: " << media << endl;

Attenzione a non uscire dai limiti dell'array: accedere a voti[5] o voti[-1] è un errore che il C++ non segnala sempre, ma che può causare comportamenti imprevedibili.

Matrici#

Una matrice è un array a due dimensioni: possiamo immaginarla come una tabella con righe e colonne. Per accedere a un elemento servono due indici: il primo per la riga, il secondo per la colonna.

int tabella[2][3] = {
    {1, 2, 3},   // riga 0
    {4, 5, 6}    // riga 1
};

cout << tabella[0][2];   // riga 0, colonna 2 -> 3
cout << tabella[1][0];   // riga 1, colonna 0 -> 4

Per scorrere una matrice si usano due cicli for annidati: quello esterno percorre le righe, quello interno le colonne.

for (int r = 0; r < 2; r++) {
    for (int c = 0; c < 3; c++) {
        cout << tabella[r][c] << " ";
    }
    cout << endl;   // a capo dopo ogni riga
}

Funzioni#

Una funzione è un blocco di codice con un nome, che possiamo richiamare quando serve. Servono a evitare ripetizioni e a dividere un problema grande in pezzi piccoli e ordinati. Una funzione ha un tipo di ritorno (il tipo del valore che restituisce, o void se non restituisce nulla), un nome e dei parametri tra parentesi.

// Funzione che riceve due interi e restituisce la loro somma
int somma(int a, int b) {
    return a + b;
}

int main() {
    int risultato = somma(3, 4);   // risultato = 7
    cout << risultato << endl;
    return 0;
}

I valori che passiamo alla funzione quando la richiamiamo (3 e 4) si chiamano argomenti; i nomi usati nella definizione (a e b) si chiamano parametri. Una funzione void esegue azioni ma non restituisce un valore con return.

void saluta(string nome) {
    cout << "Ciao " << nome << "!" << endl;
}

// uso: saluta("Marco");

Passaggio dei parametri#

Quando passiamo un valore a una funzione, possiamo farlo in modi diversi. Capire la differenza è fondamentale, perché cambia se le modifiche fatte dentro la funzione si vedono anche fuori.

Passaggio per valore#

È il modo predefinito: la funzione riceve una copia del valore. Qualsiasi modifica avviene sulla copia, quindi la variabile originale resta invariata.

void raddoppia(int n) {
    n = n * 2;          // modifica solo la copia locale
}

int main() {
    int x = 5;
    raddoppia(x);
    cout << x;          // stampa ancora 5
}

Passaggio per riferimento#

Aggiungendo & prima del nome del parametro, la funzione lavora direttamente sulla variabile originale, non su una copia. Così le modifiche restano anche dopo la chiamata. È utile quando vogliamo che la funzione cambi davvero il valore, o per restituire più risultati.

void raddoppia(int &n) {
    n = n * 2;          // modifica l'originale
}

int main() {
    int x = 5;
    raddoppia(x);
    cout << x;          // stampa 10
}

Esiste anche il passaggio per riferimento costante (const int &n): la funzione può leggere il valore senza copiarlo, ma non può modificarlo. Si usa con dati grandi (come le string o gli array) per non sprecare memoria nelle copie. Gli array, in particolare, vengono sempre passati per riferimento in modo automatico: una funzione che li modifica cambia i dati originali.

In sintesi#

Abbiamo visto i mattoni fondamentali del C++: come memorizzare i dati (variabili, costanti, tipi), come prendere decisioni (if, else if, switch), come ripetere istruzioni (while, do-while, for), come gestire collezioni di dati (array e matrici) e come organizzare il codice in funzioni, scegliendo il giusto tipo di passaggio dei parametri.

Il modo migliore per fissare questi concetti è scrivere codice: prova a modificare gli esempi, combinali tra loro e crea piccoli programmi (una calcolatrice, la media dei voti, una tabellina). Sbagliare e correggere è parte del percorso — ed è così che si impara davvero a programmare.