C# vs C++: memoria, prestazioni, videogiochi e curva di apprendimento

C# e C++ condividono una lettera e una sintassi con le parentesi graffe, ma si collocano a livelli diversi. C++ (1985) compila direttamente in codice macchina e ti permette di controllare esattamente dove vive ogni oggetto e quando muore. C# (2002) compila in un linguaggio intermedio che il runtime .NET trasforma in codice macchina durante l'esecuzione, e un garbage collector recupera la memoria per te. Quasi tutte le differenze che seguono derivano da questa sola scelta.

In sintesi

Memoria: garbage collector vs RAII

In C++, un oggetto con allocazione automatica viene distrutto quando esce dall'ambito, e il suo distruttore viene eseguito in quel preciso momento. Gli oggetti sull'heap sono posseduti da smart pointer (std::unique_ptr, std::shared_ptr) oppure gestiti a mano con new e delete. Questo pattern, Resource Acquisition Is Initialization (RAII), garantisce una pulizia deterministica della memoria e di ogni altra risorsa.

// C++
#include <memory>
#include <fstream>

void save() {
    std::ofstream file("log.txt");          // opened here
    auto buffer = std::make_unique<char[]>(4096);
    file << "saved\n";
}   // file closed and buffer freed here, in reverse order

In C#, ogni istanza di classe vive nell'heap gestito e il garbage collector la libera in un momento successivo, quando più nulla vi fa riferimento. Non scrivi mai delete e non puoi mai liberare qualcosa ancora in uso. La memoria è gestita; ciò che il GC non gestisce tempestivamente sono le altre risorse: file, socket, connessioni a database. Per quelle, C# ha IDisposable e l'istruzione using, che chiama Dispose alla fine di un blocco, la cosa più vicina a un distruttore:

using System;

class Connection : IDisposable
{
    private readonly string name;
    public Connection(string name) { this.name = name; Console.WriteLine($"open {name}"); }
    public void Send(string msg) { Console.WriteLine($"{name} <- {msg}"); }
    public void Dispose() { Console.WriteLine($"close {name}"); }
}

class Program
{
    static void Main()
    {
        using (var db = new Connection("db"))
        using (var cache = new Connection("cache"))
        {
            db.Send("SELECT 1");
            cache.Send("PING");
        }   // Dispose runs here, in reverse order, even if an exception is thrown
        Console.WriteLine("done");
    }
}

Output:

open db
open cache
db <- SELECT 1
cache <- PING
close cache
close db
done

La differenza è che in C++ la pulizia è legata all'ambito per ogni oggetto locale e ogni oggetto posseduto da uno smart pointer, mentre in C# è automatica per la memoria e su richiesta (tramite using) per tutto il resto. Trovi di più nella pagina sull'istruzione using.

Sicurezza: eccezioni invece di comportamento indefinito

Leggere oltre la fine di un array in C++ è comportamento indefinito: il programma può stampare dati senza senso, andare in crash o continuare a girare con la memoria corrotta, e il risultato può cambiare da una build all'altra. Lo stesso errore in C# lancia un'eccezione esattamente in quella riga.

// C++: compiles, and the behavior is undefined
int scores[3] = {90, 85, 77};
int x = scores[5];   // reads whatever is in memory there

using System;

class Program
{
    static void Main()
    {
        int[] scores = { 90, 85, 77 };
        try
        {
            int x = scores[5];
            Console.WriteLine(x);
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("Index 5 is outside an array of length " + scores.Length);
        }

        string name = null;
        try
        {
            Console.WriteLine(name.Length);
        }
        catch (NullReferenceException)
        {
            Console.WriteLine("name was null");
        }
    }
}

Output:

Index 5 is outside an array of length 3
name was null

L'intera categoria dei bug di corruzione della memoria (buffer overflow, use after free, double free, puntatori pendenti) non esiste nel C# sicuro. È una buona parte del motivo per cui il codice C# è più rapido da scrivere e da revisionare.

Puntatori e codice unsafe

C# ha i puntatori, ma solo dentro blocchi unsafe, e il progetto deve abilitarli con <AllowUnsafeBlocks>true</AllowUnsafeBlocks>. Gli oggetti nell'heap gestito possono spostarsi durante la garbage collection, quindi li fissi con fixed prima di prenderne l'indirizzo:

// C#, requires AllowUnsafeBlocks
unsafe
{
    int[] data = { 1, 2, 3 };
    fixed (int* p = data)
    {
        *(p + 1) = 20;   // data is now { 1, 20, 3 }
    }
}

Il codice unsafe si usa per l'interoperabilità con librerie native e per pochi cicli critici. Oggi la maggior parte del C# a basso livello usa invece Span<T>, variabili locali ref e stackalloc, che offrono prestazioni simili ai puntatori mantenendo il controllo dei limiti.

Prestazioni

C++ fornisce al compilatore l'intero programma in anticipo e non aggiunge nulla a runtime: niente garbage collector, niente JIT, niente controllo dei limiti a meno che tu non lo chieda. Questo lo rende la scelta giusta quando conta ogni microsecondo o ogni byte, e quando le pause non sono accettabili.

C# paga la sua sicurezza con un runtime, il riscaldamento del JIT all'avvio e pause occasionali del GC. In throughput di solito resta entro un piccolo fattore rispetto a C++, e la distanza si è ridotta a ogni versione di .NET: JIT a livelli con ottimizzazione guidata dal profilo, struct e Span<T> per evitare allocazioni, intrinseci hardware per SIMD e Native AOT per compilare in anticipo in un singolo eseguibile nativo. Per API web, strumenti e logica di business, database e rete dominano e la differenza di linguaggio raramente si nota.

Sviluppo di videogiochi: Unity vs Unreal

È qui che la maggior parte delle persone si pone la domanda. Unity si programma in C#: codice di gameplay, UI e strumenti sono classi C# collegate agli oggetti di gioco, mentre il nucleo del motore è in C++. Unreal Engine è scritto in C++ e il gameplay è C++ più il sistema di scripting visuale Blueprints. Godot supporta sia GDScript sia C#.

C# con Unity è più rapido da imparare e da iterare, ed è per questo che è così diffuso nei giochi indie e mobile. Unreal e C++ sono lo standard negli studi AAA, e chi programma motori di gioco lavora ovunque in C++. Un percorso comune è iniziare con Unity, poi imparare C++ se passi a Unreal o al lavoro sui motori.

Modello di build

Un programma C++ è diviso in header (.h, dichiarazioni) e file sorgente (.cpp, definizioni). Il preprocessore incolla gli header in ogni file sorgente, ogni file viene compilato separatamente e il linker unisce i risultati. I template vengono istanziati in ogni file che li usa, uno dei motivi per cui le build C++ grandi sono lente.

C# non ha nulla di tutto questo. Un progetto è un insieme di file .cs compilati insieme in un assembly (.dll); l'ordine delle dichiarazioni e dei file non conta, e un tipo in un file può usare un tipo in un altro senza alcun include. Le librerie arrivano come pacchetti NuGet. La direttiva using importa un namespace, non un file.

Differenze di sintassi che noterai

• Oggetti. auto p = std::make_unique<Player>(); e p->Jump(); in C++; var p = new Player(); e p.Jump(); in C#. C# usa . per tutto.
• Stringhe. std::string è un valore modificabile; string di C# è un tipo riferimento immutabile.
• Ereditarietà multipla. C++ permette a una classe di ereditare da più classi; C# permette una classe base più un numero qualsiasi di interfacce.
• Template vs generics. I template di C++ sono generazione di codice in fase di compilazione e permettono la metaprogrammazione; i generics di C# vengono verificati una volta con vincoli espliciti (where T : IComparable<T>).
• Libreria standard. Quella di C# include HTTP, JSON, espressioni regolari, I/O su file, compressione e crittografia; in C++ gran parte di queste cose arriva da librerie di terze parti.

Quale imparare

Impara C# se vuoi creare applicazioni, backend web, strumenti o giochi con Unity e vedere risultati in fretta. Impara C++ se punti a motori di gioco, grafica, sistemi embedded, sistemi operativi, browser o qualsiasi ambito in cui il controllo a livello hardware e la latenza prevedibile sono il punto. C# è il primo linguaggio più accessibile; C++ vale la pena impararlo come secondo, perché ti insegna cosa fa per te il runtime di C#.