C++ em 2025: novos recursos e exemplos de código na prática

C++ em 2025: o que há de novo na prática?

2025 é um ano marcante para a comunidade C++. O padrão C++26 está sendo ativamente finalizado, e muitos recursos que ontem pareciam experimentais estão se tornando disponíveis nos compiladores. Neste artigo, não vamos apenas listar as novidades, mas mostrar como elas mudam o desenvolvimento diário na prática. Não vamos nos aprofundar nos rascunhos do comitê, mas focar no que já pode (ou quase pode) ser usado em projetos reais.

1. Pattern Matching: a era do "switch" de nova geração

Um dos recursos mais esperados é o pattern matching. Embora a sintaxe ainda esteja sendo estabilizada, em 2025 vemos como ele simplifica o trabalho com estruturas de dados complexas. Em vez de longas cadeias de if-else ou std::visit, surge uma sintaxe concisa.

Exemplo: Suponha que temos um std::variant para representar o estado de um pedido.

#include <variant>#include <iostream>#include <string>

enum class Status { Pending, Shipped, Delivered };struct Order {    int id;    std::variant<Status, std::string> state; // Ou status, ou mensagem de erro};

void process_order(const Order& o) {    // Em C++26 (sintaxe hipotética)    inspect (o.state) {        as Status::Pending => std::cout << "Pedido " << o.id << " aguardando processamento";        as Status::Shipped => std::cout << "Pedido " << o.id << " enviado";        as Status::Delivered => std::cout << "Pedido " << o.id << " entregue";        as std::string err => std::cerr << "Erro: " << err << " para o pedido " << o.id << "";    }}

Na prática, isso significa que o código se torna mais legível e seguro. O compilador pode verificar se você tratou todas as opções possíveis, reduzindo o número de bugs.

2. Reflexão (Reflection): o compilador como seu assistente

Reflexão estática não é mágica, mas a capacidade de obter informações sobre tipos e membros de classes em tempo de compilação. Em 2025, isso deixa de ser exótico. Bibliotecas e frameworks começam a usá-la para serialização automática, geração de código e logging.

Exemplo: Serialização automática para JSON sem macros ou ferramentas externas.

#include <reflection> // Arquivo de cabeçalho hipotético para C++26#include <iostream>#include <string>

struct User {    std::string name;    int age;    std::string email;};

// Função que usa reflexão para percorrer os campostemplate<typename T>void to_json(const T& obj) {    std::cout << "{ ";    // constexpr for — loop em tempo de compilação    for constexpr (auto& member : members_of<T>()) {        std::cout << "\\"" << member.name << "\\": \\"" << member.get(obj) << "\\", ";    }    std::cout << "}";}

int main() {    User u{"Alice", 30, "alice@example.com"};    to_json(u); // Saída: { "name": "Alice", "age": "30", "email": "alice@example.com", }    return 0;}

Na prática, a reflexão elimina a necessidade de escrever código boilerplate. O desenvolvedor não precisa atualizar manualmente as funções de serialização ao adicionar um novo campo — o compilador faz isso por ele.

3. Corrotinas (Coroutines) aprimoradas e std::execution

As corrotinas em C++20 eram uma ferramenta poderosa, mas complexa. Em 2025, a situação muda: surgem wrappers e bibliotecas de mais alto nível, como std::execution. Agora, o código assíncrono se torna não apenas eficiente, mas também legível.

Exemplo: Carregamento assíncrono de dados de várias fontes usando std::execution::async_scope (API hipotética