El Comité ISO aprobó el estándar "C ++ 20"

Recientemente, el Comité ISO para la Estandarización del Lenguaje C ++ (sí, hay uno) aprobó el estándar internacional "C ++ 20". Las características presentadas en la especificación son compatibles con los compiladores GCC, Clang y Microsoft Visual C ++. Además, las bibliotecas estándar con soporte para "C ++ 20" se implementan dentro del proyecto Boost.



El siguiente paso es preparar el documento para su publicación. Luego, a principios de noviembre, se enviará la versión final a ISO, luego de lo cual se publicará bajo el nombre formal ISO / IEC 14882: 2020. El comité ya está trabajando en el próximo estándar, C ++ 23 (C ++ 2b). Bajo el corte - características de "C ++ 20" con ejemplos de código.

¿Qué hay de nuevo?

El comité agregó "conceptos" , extensiones de plantilla que le permiten definir un conjunto de requisitos para los parámetros de la plantilla. En el momento de la compilación, restringen el conjunto de argumentos que pueden aceptarse como parámetros de plantilla. Los conceptos permiten evitar inconsistencias lógicas entre las propiedades de los tipos de datos que se utilizan dentro de la plantilla y las propiedades de los tipos de datos de los parámetros de entrada.

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

Ampliación aceptada para trabajar con los módulos. Se pueden utilizar en lugar de archivos de encabezado. Los módulos proporcionan una nueva forma de organizar las fuentes según la definición de los límites de los componentes, sin incluir archivos de encabezado utilizando "#include".



Se agregó la macro __VA_OPT__ para la expansión adaptativa de macros variadic dependiendo de la presencia de tokens en el argumento variadic.



Se agregó soporte para el operador <=> para la comparación de tres vías. Se



admiten los inicializadores de elementos predeterminados para campos de bits.



Se agregó la capacidad de capturar expresiones lambda * this.

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

Las clases ahora pueden usar parámetros de plantilla sin 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}>();

Ahora puede usar cadenas literales en parámetros de plantilla. Se admite la sintaxis de inicialización de estilo C. Aquellos que no se enumeran explícitamente en las listas de inicialización de campo se inicializan de forma predeterminada.

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

Se admiten miembros vacíos de estructuras de datos.



Se admiten los atributos probables e improbables para informar al optimizador sobre la probabilidad de que se active la construcción condicional ("[[probable]] si (aleatorio> 0) {").



Ahora puede usar rangos para inicializar valores de variables en un bucle for

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

Se admiten funciones inmediatas , que solo pueden funcionar con constantes.

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

Agregado a la biblioteca:

• soporte para el tipo char8_t para cadenas UTF-8.
• bits de encabezados (operaciones de bits) y versión.
• la capacidad de verificar el prefijo y sufijo de cadenas (comienza_con, termina_con).
• rasgos std :: remove_cvref, std :: unsrap_reference, std :: unsrap_decay_ref, std :: is_nothrow_convertible y std :: type_identity.
• las funciones std :: midpoint, std :: lerp, std :: bind_front, std :: source_location, std :: visit, std :: is_constant_evaluate y std :: ass_aligned.
• soporte para matrices en std :: make_shared.
• std :: to_array función para convertir objetos tipo matriz en std :: matriz.

La sintaxis de enumeración ahora es más 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";
    }
   }

Está prohibido utilizar las operaciones "," ("a [b, c]") en los índices . La mayoría de las operaciones en variables declaradas con la palabra clave violar, incluidas las operaciones prohibidas ++ y - en tipos estándar, no son compatibles.