Estándar C++20 aprobado

Comité ISO de Normalización da Linguaxe C++ aprobado estándar internacional"C ++ 20". As capacidades presentadas na especificación, con excepción de casos illados, apoiado en compiladores GCC, berrar и Microsoft Visual C ++. No proxecto están implementadas bibliotecas estándar que admiten C++20 Impulsar.

Nos próximos dous meses, o prego aprobado estará na fase de elaboración do documento para a súa publicación, no que se traballará na corrección editorial de erros ortográficos e tipográficos. A principios de novembro, o documento resultante enviarase a ISO para a súa publicación baixo o nome formal ISO/IEC 14882:2020. Mentres tanto, o comité xa comezou a traballar no próximo estándar C++23 (C++2b) e considerará posibles opcións na súa próxima reunión virtual. innovacións.

O principal Características C ++ 20 (exemplos de código):

• Engadíronse "conceptos", extensións de modelo, que permiten definir un conxunto de requisitos de parámetros de modelo que, no momento da compilación, limitan o conxunto de argumentos que se poden aceptar como parámetros de modelo. Os conceptos pódense utilizar para evitar inconsistencias lóxicas entre as propiedades dos tipos de datos utilizados dentro do modelo e as propiedades dos tipos de datos dos parámetros de entrada.

  modelo
  concepto IgualdadeComparable = require(T a, T b) {
  { a == b } -> std::boolean;
  { a != b } -> std::boolean;
  };

• Aceptada ampliación para traballar con módulos que se poden usar en lugar de ficheiros de cabeceira. Os módulos proporcionan unha nova forma de organizar o código fonte baseado na definición dos límites dos compoñentes, sen incluír ficheiros de cabeceira mediante "#include".
• Macro __VA_OPT__ para a expansión adaptativa de macros variables dependendo da presenza de tokens no argumento da variable.
• Soporte para o operador "" para a comparación de tres vías.
• Soporte para inicializadores de elementos predeterminados para campos de bits.
• Capacidade para capturar expresións lambda "*this".

  struct int_value {
  int n = 0;
  auto getter_fn() {
  // MAL:
  // retorno [=]() { retorno n; };

  // BO:
  retorno [=, *este]() { retorno n; };
  }
  };

• Chamar elementos por punteiro (punteiro a membro), usando punteiros a obxectos temporais definidos mediante a expresión "const &".
• O operador de eliminación cun destrutor descrito no documento P0722R1.
• As clases poden usar parámetros de modelo sen un tipo.

  struct foo {
  foo() = predeterminado;
  constexpr foo(int) {}
  };

  modelo
  auto get_foo() {
  retorno f;
  }

  get_foo(); // usa o construtor implícito
  get_foo ();

• Expresións lambda non persistentes con constructor.
• Permitir a sintaxe do modelo para expresións lambda ("auto f = [] (std::vector v)").
• Capacidade de usar literais de cadea nos parámetros do modelo.
• Compatibilidade coa sintaxe de inicialización de estilo C: os campos que non aparecen explícitamente na lista de inicialización inícianse por defecto.

  estrutura A {
  intx;
  int y;
  int z = 123;
  };

  A a {.x = 1, .z = 2}; // ax == 1, ay == 0, az == 2

• Soporte para membros baleiros da estrutura de datos.
• Compatibilidade cos atributos probables e improbables para informar ao optimizador sobre a probabilidade de que se desencadee a construción condicional ("[[probable]] se (aleatoria > 0) {").
• Capacidade de usar intervalos para inicializar valores variables nun bucle "for".

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

• Cálculo automático do tamaño da matriz en novo ("new double[]{1,2,3}");
• O atributo “[[no_unique_address]]” no que as variables sen datos non ocupan espazo.
• Punteros atómicos (std::atomic > e std::atomic >).
• Capacidade para chamar funcións virtuais en expresións condicionais.
• Soporte para funcións inmediatas que só poden funcionar con constantes.

  consteval int sqr(int n) {
  retorno n * n;
  }

  constexpr int r = sqr(100); // OK
  int x = 100;
  int r2 = sqr(x); // ERRO: 'x' non se pode usar como constante

• Posibilidade de usar constexpr con funcións virtuais (“constexpr virtual int f() const { return 2; }”).
• Na biblioteca estándar:
  • Engadido soporte para o tipo char8_t para cadeas UTF-8.
  • Engadidos ficheiros de cabeceira bit (operacións de bits) e versión.
  • Agora é posible comprobar o prefixo e o sufixo das cadeas (comeza_con, remata_con).
  • Engadíronse os trazos std::remove_cvref, std::unwrap_reference, std::unwrap_decay_ref, std::is_nothrow_convertible e std::type_identity.
  • Engadiron funcións std::midpoint, std::lerp, std::bind_front, std::source_location, std::visit, std::is_constant_evaluated e std::assume_aligned.
  • Engadido soporte para matrices a std::make_shared.
  • Engadiuse a función std::to_array para converter obxectos tipo matriz en std::array.
• Sintaxe de enumeración máis conveniente:

  clase enumeración rgba_color_channel { vermello, verde, azul, alfa };

  std::string_view to_string(rgba_color_channel my_channel) {
  cambiar (meu_canle) {
  usando a enumeración rgba_color_channel;
  case vermello: devolve "vermello";
  caso verde: devolve "verde";
  caso azul: devolve "azul";
  case alpha: devolve "alfa";
  }
  }

• Nos índices, debido ao comportamento indefinido, está prohibido o uso da operación “,” (“a[b,c]”). O soporte para a maioría das operacións con variables declaradas coa palabra clave volátil foi descontinuada, incluídas as operacións "++" e "—" con tipos estándar.
• Reduciuse o número de situacións nas que se require "typename" para indicar a presenza dun tipo.

Fonte: opennet.ru