Da Python a C++: Perché il divario sembra così grande

Ogni programmatore Python che tocca C++ per la prima volta ha la stessa reazione: perché stampare "hello world" richiede tutta questa cerimonia? Il salto non è solo sintassi. È uno spostamento in come sei tenuto a pensare alla memoria, ai tipi, e cosa il computer sta effettivamente facendo mentre il tuo programma funziona.

Cosa Python ti stava nascondendo

Python gira su un interprete (CPython, nella maggior parte dei casi) che gestisce l'allocazione della memoria, la garbage collection e il controllo dei tipi dietro le quinte. Quando scrivi x = 5 e poi x = "hello", Python semplicemente riassegna il nome. Nessuna protesta, nessuna pulizia richiesta da parte tua.

C++ non lo fa per te. Quando scrivi int x = 5;, hai riservato un blocco fisso di memoria dimensionato per un intero. Non puoi buttarci una stringa dentro più tardi. E quando allochi memoria dinamicamente con new, sei responsabile di rilasciarla con delete — se dimentichi, hai una memory leak. Dimentica di controllare se un puntatore è null prima di dereferenziarlo, e hai un segfault. Python scambia performance per reti di sicurezza. C++ ti dà le forbici e si fida che non corri.

La tipizzazione statica cambia come scrivi codice, non solo come dichiari variabili

In Python, le firme delle funzioni sono suggerimenti. In C++, sono contratti applicati al momento della compilazione:

int add(int a, int b) {
    return a + b;
}

Chiama add(3, "four") e il compilatore ti ferma prima che il programma giri mai. Python ti lascerebbe felicemente scrivere def add(a, b): return a + b, poi andrebbe in crash al runtime nel momento in cui qualcuno passa tipi incompatibili. Non è un inconveniente minore — è una filosofia diversa su quando gli errori dovrebbero emergere. C++ vuole che tu catturi i bug al momento della compilazione. Python sta bene a catturarli in produzione se non hai scritto test.

La gestione della memoria è il vero curriculum

Il salto concettuale più grande è capire lo stack rispetto all'heap. Le variabili locali e i parametri delle funzioni di solito vivono nello stack, e si ripuliscono automaticamente quando una funzione ritorna. Qualsiasi cosa creata con new vive sull'heap, e rimane lì finché non la esplicita delete o non la racchiudi in uno smart pointer.

C++ moderno (C++11 in poi) ti dà std::unique_ptr e std::shared_ptr precisamente così non devi gestire i puntatori grezzi a mano così spesso:

std::unique_ptr<int> ptr = std::make_unique<int>(42);

Questo oggetto si distrugge quando esce dallo scope — nessun delete manuale necessario. Se stai imparando C++ nel 2024, vai dritto agli smart pointer e ai pattern RAII (Resource Acquisition Is Initialization) piuttosto che molire attraverso esercizi di aritmetica di puntatori grezzi destinati a un curriculum del 1998. Avrai ancora bisogno di capire i puntatori concettualmente, ma non hai bisogno di scrivere codice malloc/free per provarlo.

La compilazione è un ciclo di feedback diverso

Python ti dà feedback istantaneo: esegui lo script, vedi l'errore, correggilo, esegui di nuovo. C++ inserisce un passo di compilazione in mezzo, e quel passo cattura un'intera categoria di bug che Python rinvia al runtime. Compilare con g++ -Wall -Wextra program.cpp -o program e prestare attenzione a ogni avviso ti farà risparmiare ore di debugging confuso dopo. I mismatch di tipo, le variabili non inizializzate, e i problemi di confronto signed/unsigned appaiono tutti qui invece che come comportamento misterioso al runtime. Il compromesso è la velocità di iterazione: il tuo ciclo edit-compile-run è più lento di quello edit-run di Python, specialmente su basi di codice più grandi dove una ricompilazione completa può richiedere minuti. Ecco perché strumenti come ccache e build incrementali via CMake importano una volta che i tuoi progetti crescono oltre pochi file.

Dove questo effettivamente importa nella pratica

Non impari C++ per scrivere gli stessi programmi che hai scritto in Python, più veloce. Lo impari perché alcuni problemi lo richiedono: motori di gioco con budget di frame rigidi, sistemi embedded con kilobyte di RAM, sistemi di trading ad alta frequenza dove i microsecondi costano denaro, o componenti del sistema operativo che si trovano al di sotto dell'interprete Python stesso. Se stai facendo lavoro di sicurezza, capire il modello di memoria di C++ spiega anche direttamente come i buffer overflow e le vulnerabilità use-after-free accadono a livello binario — conoscenza che le astrazioni di Python attivamente ti nascondono.

Il consiglio onesto: non cercare di rendere C++ simile a Python. Lascia che sia scomodo per un po'. Lo scomodo è il punto — ti sta insegnando cosa il tuo interprete Python ha fatto per te l'intero tempo.

Se questo tipo di confronto tra linguaggi è utile, Korra Studio ha segmenti correlati sulla memory safety, i fondamenti della programmazione di sistemi, e il reverse engineering che si costruiscono proprio su questi concetti.