Clever Geek Handbook

Comitê ISO aprovado padrão "C ++ 20"





Recentemente, o Comitê ISO para Padronização da Linguagem C ++ (sim, existe um) aprovou o padrão internacional "C ++ 20". Os recursos apresentados na especificação são suportados pelos compiladores GCC, Clang e Microsoft Visual C ++. Além disso, bibliotecas padrão com suporte para "C ++ 20" são implementadas no projeto Boost.



A próxima etapa é preparar o documento para publicação. Em seguida, no início de novembro, a versão final será enviada para a ISO, após o que será publicada sob o nome formal ISO / IEC 14882: 2020. O comitê já está trabalhando no próximo padrão, C ++ 23 (C ++ 2b). Sob o corte - recursos de "C ++ 20" com exemplos de código.



O que há de novo?

O comitê adicionou "conceitos" , extensões de modelo que permitem definir um conjunto de requisitos para parâmetros de modelo. Em tempo de compilação, eles restringem o conjunto de argumentos que podem ser aceitos como parâmetros de modelo. Os conceitos permitem evitar inconsistências lógicas entre as propriedades dos tipos de dados que são usados ​​no modelo e as propriedades dos tipos de dados dos parâmetros de entrada. 



 template<typename T>
   concept EqualityComparable = requires(T a, T b) {
       { a == b } -> std::boolean;
       { a != b } -> std::boolean;
   };


Extensão aceita para trabalhar com os módulos. Eles podem ser usados ​​em vez de arquivos de cabeçalho. Os módulos fornecem uma nova maneira de organizar fontes com base na definição dos limites dos componentes, sem incluir arquivos de cabeçalho usando "#include".



Adicionada macro __VA_OPT__ para expansão adaptativa de macros variadicas dependendo da presença de tokens no argumento variadic.



Adicionado suporte para o operador <=> para comparação de três vias. São



suportados inicializadores de elemento padrão para campos de bits.



Adicionada a capacidade de capturar expressões lambda * this. 



   struct int_value {
     int n = 0;
     auto getter_fn() {
       // BAD:
       // return [=]() { return n; };
 
       // GOOD:
       return [=, *this]() { return n; };
     }
   };


As classes agora podem usar parâmetros de modelo sem tipo. 



   struct foo {
     foo() = default;
     constexpr foo(int) {}
   };
 
   template <foo f>
   auto get_foo() {
     return f; 
   }
 
   get_foo(); // uses implicit constructor
   get_foo<foo{123}>();


Agora você pode usar literais de string em parâmetros de modelo. A sintaxe de inicialização de estilo C é suportada. Aqueles que não estão explicitamente listados nas listas de inicialização de campo são inicializados por padrão. 



struct A {
     int x;
     int y;
     int z = 123;
   };
 
   A a {.x = 1, .z = 2}; // a.x == 1, a.y == 0, a.z == 2


Membros vazios de estruturas de dados são suportados.



Os atributos prováveis ​​e improváveis ​​são suportados para informar o otimizador sobre a probabilidade da construção condicional ser acionada ("[[provável]] se (aleatório> 0) {").



Agora você pode usar intervalos para inicializar valores de variáveis ​​em um loop for 



   for (auto v = std::vector{1, 2, 3}; auto& e : v) {


Funções imediatas são suportadas , que só podem funcionar com constantes. 



 consteval int sqr(int n) {
     return n * n;
   }
 
   constexpr int r = sqr(100); // OK
   int x = 100;
   int r2 = sqr(x); // ERROR:  'x'


Adicionado à biblioteca:

  • suporte para o tipo char8_t para strings UTF-8.
  • bit de cabeçalhos (operações de bit) e versão.
  • a capacidade de verificar o prefixo e o sufixo de strings (começa_com, termina_com).
  • traços std :: remove_cvref, std :: unfrap_reference, std :: unfrap_decay_ref, std :: is_nothrow_convertible e std :: type_identity.
  • as funções std :: midpoint, std :: lerp, std :: bind_front, std :: source_location, std :: visit, std :: is_constant_evaluated e std :: assume_aligned.
  • suporte para matrizes em std :: make_shared.
  • função std :: to_array para converter objetos do tipo array em std :: array.


A sintaxe de enumeração agora é mais conveniente: 

   enum class rgba_color_channel { red, green, blue, alpha };
 
   std::string_view to_string(rgba_color_channel my_channel) {
     switch (my_channel) {
       using enum rgba_color_channel;
       case red:   return "red";
       case green: return "green";
       case blue:  return "blue";
       case alpha: return "alpha";
    }
   }


É proibido usar as operações "," ("a [b, c]") em índices . A maioria das operações em variáveis ​​declaradas com a palavra-chave violate, incluindo as operações proibidas ++ e - com tipos padrão, não são suportadas.





More articles:


All Articles