C++ 20 traz Modules, Coroutines e Concepts; Contracts ficou de fora

O comitê ISO C++ fechou a lista de recursos para o próximo C++ padrão, apelidado de C++ 20, agendado para ser publicado em fevereiro de 2020. O C++ 20 será uma revisão significativa do C++, trazendo modules, coroutines e concepts, entre seus principais novos recursos.

Em sua última reunião em Colônia, o comitê ISO C++ concordou com as últimas alterações no rascunho do C++ 20 antes de submetê-la a todos os órgãos responsáveis para obter feedback. Entre as adições mais recentes estão std:: Format, a biblioteca de sincronização do C++ 20. Contracts, pelo contrário, foi removido do projeto e adiado para o C++ 23/C++ 26.

O C++ 20 apresentará uma nova API de formatação de texto, std:: Format, com o objetivo de ser tão flexível quanto a família de funções printf, com seu estilo de chamada mais natural e separação de mensagens e argumentos, e tão seguro e extensível como iostreams. O std:: Format tornará possível escrever:

string message = format("A resposta é {}.", 42);

O C++ 20 também melhorará a sincronização e a coordenação de thread, incluindo suporte de espera eficiente atomic e semáforos, travas, barreiras, tipos integrais lockfree e muito mais.

Em reuniões anteriores, o comitê já havia concordado com a inclusão de algumas características importantes que prometem mudar radicalmente a maneira como os desenvolvedores usam a linguagem, incluindo modules, coroutines e concepts.

O suporte ao Modules será ortogonal para namespaces e permitirá a estruturação de grandes bases de código em partes lógicas sem exigir a separação de arquivos de cabeçalho e de origem. É assim que você pode definir um módulo simples exportando uma função e seu uso em um arquivo diferente:

// math.cppm
export module mod1;

export int identity(int arg) {
    return arg;
}

// main.cpp

import mod1;

int main() {
  identity(100);
}

Coroutines são funções que podem ser interrompidas e retomadas. Eles são stack-less, o que significa que eles retornam para o chamador quando suspenso. Coroutines suporta três novos operadores: co_await para suspender a execução sem retornar um valor para o chamador; co_yield para suspender ao retornar um valor; co_return para finalizar a execução e retornar um valor. Esses três operadores permitem a criação de tarefas assíncronas, geradores e funções lentas. O seguinte é um exemplo de gerador:

generator<int> iota(int n = 0) {
  while(true)
    co_yield n++;
}

Outra funcionalidade importante no C++ 20 será o Concepts, que fornecem a base para o raciocínio equacional. Por exemplo, os concepts podem ser usados para executar a validação de tempo de compilação de argumentos de modelo e executar a função dispatch com base nas propriedades dos tipos.

Além de concepts, o C++ 20 não incluirá uma série de funcionalidades principais adicionais que foram adiadas para C++ 23/C++ 26, incluindo metaclasses de reflexão, executores, propriedades e outros.

Claro que teremos muito mais para o C++ 20 que pode ser abordado em um post curto, por isso certifique-se de ler o relatório completo para maiores detalhes.