Vettori in C++ — Lezione Interattiva

01

Che cos'è un vettore?

Un vettore (o array) è una struttura dati che permette di memorizzare N elementi dello stesso tipo in posizioni di memoria contigue. È come una fila di cassetti numerati: ogni cassetto ha un indice (da 0 a N−1) e contiene un valore dello stesso tipo degli altri.

Tutti gli elementi occupano celle adiacenti in memoria: se arr[0] è all'indirizzo 1000, per un array di int (4 byte) arr[1] sarà a 1004, arr[2] a 1008, ecc.

Sintassi

tipo nome[dim];

Accesso

nome[indice]

Primo elemento

nome[0]

Ultimo elemento

nome[N-1]

Dimensione fissa

nota a compile-time

Complessità accesso

O(1) — diretto

visualizzazione — array int arr[6] = {12, 7, 3, 9, 5, 11}

// clicca una cella per evidenziarla

02

Dichiarazione e inizializzazione

In C++ un array si dichiara specificando il tipo degli elementi e la dimensione (che deve essere nota a compile-time, o almeno costante). La dimensione non può essere modificata in seguito: se serve ridimensionamento dinamico si usa std::vector.

C++ — forme di dichiarazione🔒 protetto

// ① Dichiarazione senza inizializzazione (valori indeterminati)
int arr[5];

// ② Dichiarazione + inizializzazione con lista
int arr[5] = {8, 6, 9, 7, 5};

// ③ Dimensione dedotta automaticamente dal compilatore
int arr[] = {8, 6, 9, 7, 5};  // dim = 5

// ④ Inizializzazione a zero (primo=0, resto azzerato)
int arr[5] = {0};           // {0,0,0,0,0}

// ⑤ Con costante per la dimensione (buona pratica!)
const int N = 5;
int arr[N];

// ⑥ Array di float, char, double...
float temperature[12] = {0.0f};
char lettere[] = {'a', 'b', 'c'};

Attenzione: in C++ (a differenza di Java), accedere a arr[5] su un array di 5 elementi (arr[0..4]) non genera un errore a runtime — produce un comportamento indefinito (undefined behavior). Controllare sempre gli indici!

03

Popolamento da tastiera e stampa

Il modo più comune per riempire un array a runtime è usare un ciclo for che itera da 0 a N-1, leggendo ogni elemento con cin. La stessa struttura si usa per la stampa con cout.

C++ — input/output con ciclo for🔒 protetto

#include <iostream>
using namespace std;

int main() {
    const int N = 5;
    int arr[N];

    // Popolamento: leggo N valori da tastiera
    for (int i = 0; i < N; i++) {
        cout << "Inserisci elemento [" << i << "]: ";
        cin  >> arr[i];
    }

    // Stampa tutti gli elementi
    cout << "Array: ";
    for (int i = 0; i < N; i++)
        cout << arr[i] << " ";
    cout << endl;

    // Ricerca del massimo
    int max = arr[0];
    for (int i = 1; i < N; i++)
        if (arr[i] > max) max = arr[i];
    cout << "Massimo: " << max << endl;

    return 0;
}

prova interattiva — inserisci 5 valori (o genera casuale)

valori del vettore

vettore caricato

04

Bubble Sort — algoritmo

Il Bubble Sort (ordinamento a bolle) confronta ripetutamente coppie di elementi adiacenti e li scambia se sono nell'ordine sbagliato. Ad ogni passata completa, l'elemento più grande "galleggia" verso destra come una bolla. Dopo N-1 passate l'array è ordinato.

Complessità: O(n²) nel caso medio e peggiore — inefficiente per grandi dati, ma ottimo per capire i fondamentali dell'ordinamento.

C++ — funzione bubbleSort completa🔒 protetto

#include <iostream>
using namespace std;

// Funzione che ordina arr[] di n elementi (crescente)
void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        // Dopo la passata i, gli ultimi i elementi sono già a posto
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Scambio con variabile temporanea
                int tmp      = arr[j];
                arr[j]     = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22};
    int n   = sizeof(arr) / sizeof(arr[0]);

    bubbleSort(arr, n);

    cout << "Ordinato: ";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

Perché j < n−i−1? Dopo la i-esima passata, gli ultimi i elementi sono già nel posto giusto — non serve confrontarli di nuovo. Questo riduce il numero di confronti inutili.

Lo scambio: per scambiare due variabili serve sempre una variabile temporanea tmp. Senza tmp uno dei due valori andrebbe perso.

05

Simulazione passo-passo

vettore di lavoro — usa i valori inseriti nella sezione 03

normale

confronto

scambio

ordinato

passata i

—

posizione j

—

confronti

0

scambi

0

stato

pronto

Velocità auto: 700ms

// qui appariranno i log di ogni passo...

06

Tutti i passaggi — tabella completa

Qui puoi vedere ogni singolo confronto eseguito dal Bubble Sort, con l'array dopo ogni operazione. La tabella viene generata automaticamente quando esegui la simulazione (sezione 05) oppure premendo il bottone qui sotto.

// premi un bottone sopra per generare la tabella

07

Quiz di verifica

1. Dato int arr[5], qual è l'indice dell'ultimo elemento?

2. Quante comparazioni totali esegue il Bubble Sort nel caso peggiore su N=5?

3. Nel Bubble Sort, perché il ciclo interno va fino a n−i−1 invece di n−1?

4. Per scambiare arr[j] e arr[j+1] ho scritto:
arr[j] = arr[j+1]; arr[j+1] = arr[j];
Cosa succede?