C# vs C++: memória, desempenho, desenvolvimento de jogos e curva de aprendizado

C# e C++ compartilham uma letra e uma sintaxe com chaves, mas ficam em níveis diferentes. C++ (1985) compila diretamente para código de máquina e permite controlar exatamente onde cada objeto vive e quando ele morre. C# (2002) compila para uma linguagem intermediária que o runtime do .NET transforma em código de máquina em tempo de execução, e um garbage collector recupera a memória para você. Quase todas as diferenças abaixo vêm dessa única escolha.

Visão geral

Memória: garbage collector vs RAII

Em C++, um objeto com armazenamento automático é destruído quando sai de escopo, e o destrutor executa nesse exato momento. Objetos no heap pertencem a smart pointers (std::unique_ptr, std::shared_ptr) ou são gerenciados à mão com new e delete. Esse padrão, Resource Acquisition Is Initialization (RAII), dá uma limpeza determinística da memória e de todos os outros recursos.

// 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

Em C#, toda instância de classe vive no heap gerenciado e o garbage collector a libera em algum momento posterior, quando nada mais a referencia. Você nunca escreve delete e nunca consegue liberar algo que ainda está em uso. A memória está resolvida; o que o GC não trata na hora são os outros recursos: arquivos, sockets, conexões de banco de dados. Para esses, C# tem IDisposable e a instrução using, que chama Dispose no fim de um bloco, o mais perto de um destrutor:

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");
    }
}

Saída:

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

A diferença é que em C++ a limpeza está ligada ao escopo para todo objeto local e todo objeto que pertence a um smart pointer, enquanto em C# ela é automática para a memória e opcional (via using) para todo o resto. Mais sobre isso na página da instrução using.

Segurança: exceções em vez de comportamento indefinido

Ler além do fim de um array em C++ é comportamento indefinido: o programa pode imprimir lixo, quebrar ou continuar executando com a memória corrompida, e o resultado pode mudar entre builds. O mesmo erro em C# lança uma exceção na linha exata.

// 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");
        }
    }
}

Saída:

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

Toda a classe de bugs de corrupção de memória (buffer overflows, uso depois de liberar, liberação dupla, ponteiros pendentes) não existe em C# seguro. Isso explica boa parte de por que código C# é mais rápido de escrever e de revisar.

Ponteiros e código unsafe

C# tem ponteiros, mas só dentro de blocos unsafe, e o projeto precisa habilitá-los com <AllowUnsafeBlocks>true</AllowUnsafeBlocks>. Objetos no heap gerenciado podem se mover durante a coleta de lixo, então você os fixa com fixed antes de pegar o endereço:

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

Código unsafe é usado para interoperabilidade com bibliotecas nativas e em alguns laços críticos. A maior parte do C# de baixo nível hoje usa Span<T>, variáveis locais ref e stackalloc, que dão desempenho parecido com o de ponteiros mantendo a verificação de limites.

Desempenho

C++ entrega ao compilador o programa inteiro antecipadamente e não acrescenta nada em tempo de execução: sem garbage collector, sem JIT, sem verificação de limites a menos que você peça. Isso o torna a escolha onde cada microssegundo ou cada byte conta, e onde pausas são inaceitáveis.

C# paga pela segurança com um runtime, o aquecimento do JIT na inicialização e pausas ocasionais do GC. Em throughput, ele normalmente fica a um fator pequeno do C++, e a distância diminuiu a cada versão do .NET: JIT em camadas com otimização guiada por perfil, structs e Span<T> para evitar alocações, intrínsecos de hardware para SIMD e Native AOT para compilar antecipadamente em um único executável nativo. Em APIs web, ferramentas e lógica de negócio, o banco de dados e a rede dominam e a diferença entre as linguagens raramente aparece.

Desenvolvimento de jogos: Unity vs Unreal

É aqui que a maioria das pessoas encontra a pergunta. A Unity é programada em C#: código de gameplay, interface e ferramentas são classes C# ligadas aos objetos do jogo, enquanto o núcleo do motor é em C++. A Unreal Engine é escrita em C++, e o gameplay é C++ mais o sistema de script visual Blueprints. O Godot suporta GDScript e C#.

C# com Unity é mais rápido de aprender e de iterar, e é por isso que é tão comum em jogos indie e mobile. Unreal e C++ são o padrão em estúdios AAA, e programadores de motores em todo lugar trabalham em C++. Um caminho comum é começar na Unity e aprender C++ se você for para a Unreal ou para trabalho de motor.

Modelo de build

Um programa C++ é dividido em cabeçalhos (.h, declarações) e arquivos-fonte (.cpp, definições). O pré-processador cola os cabeçalhos em cada arquivo-fonte, cada arquivo é compilado separadamente e o linker junta os resultados. Os templates são instanciados em cada arquivo que os usa, um dos motivos de builds grandes em C++ serem lentos.

C# não tem nada disso. Um projeto é um conjunto de arquivos .cs compilados juntos em um assembly (.dll); a ordem das declarações e dos arquivos não importa, e um tipo em um arquivo pode usar um tipo em outro sem include. Bibliotecas vêm como pacotes NuGet. A diretiva using importa um namespace, não um arquivo.

Diferenças de sintaxe que você vai notar

• Objetos. auto p = std::make_unique<Player>(); e p->Jump(); em C++; var p = new Player(); e p.Jump(); em C#. C# usa . para tudo.
• Strings. std::string é um valor mutável; a string de C# é um tipo de referência imutável.
• Herança múltipla. C++ permite que uma classe herde de várias classes; C# permite uma classe base mais qualquer número de interfaces.
• Templates vs genéricos. Templates de C++ são geração de código em tempo de compilação e permitem metaprogramação; genéricos de C# são verificados uma vez, com restrições explícitas (where T : IComparable<T>).
• Biblioteca padrão. A de C# inclui HTTP, JSON, expressões regulares, I/O de arquivos, compressão e criptografia; em C++ muito disso vem de bibliotecas de terceiros.

Qual aprender

Aprenda C# se você quer construir aplicações, backends web, ferramentas ou jogos na Unity e ver resultados rápido. Aprenda C++ se o seu alvo são motores de jogos, gráficos, sistemas embarcados, sistemas operacionais, navegadores ou qualquer coisa em que o controle no nível do hardware e a latência previsível são o objetivo. C# é a primeira linguagem mais tranquila; C++ vale a pena como segunda, porque ensina o que o runtime de C# está fazendo por você.