Características de C++ 20

C++ tiene la tradición de introducir nuevas mejoras y funciones cada 3 años en forma de estándar. Dado que el último estándar se lanzó en 2017 como C++ 17, C++ 20 será el último estándar. A continuación, se muestran algunas de las características principales de C++ 20:

• Biblioteca de conceptos de C++
• comparaciones de 3 vías
• El mapa contiene
• Bucle for basado en rango
• Nuevos identificadores (importación, módulo)
• Biblioteca de calendarios y zonas horarias
• std::funciones de string
• Arreglo acotado/ilimitado
• std::to_arreglo
• Atributos probables e improbables

Biblioteca de conceptos de C++ :

La biblioteca de conceptos proporciona definiciones de los conceptos fundamentales de la biblioteca que se pueden usar para realizar la validación en tiempo de compilación de los argumentos de la plantilla y realizar el envío de funciones en función de las propiedades de los tipos. Estos conceptos proporcionan una base para el razonamiento educativo en los programas.

Esta sección tiene alrededor de 15 conceptos que deberían explicarse por sí mismos. Estos conceptos expresan relaciones entre tipos, clasificaciones de tipos y propiedades fundamentales de tipos.

Defined in header <concepts>
Defined in namespace std

• integral : especifica que un tipo es un tipo integral.
• firm_integral : especifica que un tipo es un tipo integral que está firmado.
• unsigned_integral : especifica que un tipo es un tipo integral que no está firmado.
• punto_flotante : especifica que un tipo es un tipo de punto flotante.
• same_as : especifica que un tipo es igual a otro tipo.
• derivado_de : especifica que un tipo se deriva de otro tipo.
• convertible_to : especifica que un tipo es implícitamente convertible a otro tipo.
• common_with : especifica que dos tipos comparten un tipo común.

Sintaxis:

plantilla<clase T>
concepto integral = is_integral_v<T>;

plantilla<clase T>
concepto integral_firmada = integral<T> && is_signed_v<T>;

plantilla<clase T>
concepto unsigned_integral = integral<T> && !signed_integral<T>;

plantilla<clase T>
concepto punto_flotante = is_punto_flotante_v<T>;
 

Comparaciones de 3 vías :

Las expresiones del operador de comparación de tres vías tienen la forma:

lhs <=> rhs 

El operador de la nave espacial se parece a <=> y ​​su nombre oficial en C++ es el operador de comparación de 3 vías . Se llama así porque se usa comparando dos objetos y luego comparando ese resultado con 0:

(x <=> y) < 0 is true if x < y
(x <=> y) > 0 is true if x > y
(x <=> y) == 0 is true if x and y are equal/equivalent.

El operador de comparación de 3 vías no solo permite expresar ordenamientos e igualdad entre objetos sino también las características de las relaciones. El operador de la nave espacial es una adición muy bienvenida a C++. Nos da más expresividad en cómo definir nuestras relaciones, nos permite escribir menos código para definirlas y evita algunos problemas de rendimiento de implementar manualmente algunos operadores de comparación en términos de otros.

Programa 1:

// C++ program to illustrate the
// above concepts
#include <bits/stdc++.h>
#include <compare>
using namespace std;
  
// Driver Code
int main()
{
    int a = 91, b = 110;
    auto ans1 = a <= > b;
  
    if (ans1 < 0) {
        cout << "a < b\n";
    }
    else if (ans1 == 0) {
        cout << "a == b\n";
    }
    else if (ans1 > 0) {
        cout << "a > b\n";
    }
  
    vector<int> v1{ 3, 6, 9 };
    vector<int> v2{ 3, 6, 9 };
    auto ans2 = v1 <= > v2;
  
    if (ans2 < 0) {
        cout << "v1 < v2\n";
    }
    else if (ans2 == 0) {
  
        cout << "v1 == v2\n";
    }
    else if (ans2 > 0) {
  
        cout << "v1 > v2\n";
    }
  
    cout << endl;
}

Producción:

Mapa/Conjunto contiene :

Sintaxis:

std::map<Clave, T, Comparar, Asignador>::contiene

std::set<T>::contiene

Brinda una forma mucho más fácil de verificar si una clave está presente en el contenedor asociativo (conjunto o mapa) en C++ 20. Reemplaza la función incorporada de búsqueda .

Programa 2:

// C++ program to illustrate the
// above concepts
#include <iostream>
#include <map>
  
// Driver Code
int main()
{
    // Map
    std::map<int, char> M = { { 1, 'a' },
                              { 2, 'b' } };
  
    // Check if M has key 2
    if (M.contains(2)) {
        std::cout << "Found\n";
    }
    else {
        std::cout << "Not found\n";
    }
    return 0;
}

Producción:

Bucle for basado en rango con inicialización :

El bucle for basado en rango cambió en C++17 para permitir que las expresiones begin() y end() sean de diferentes tipos y en C++20, se introdujo una instrucción init para inicializar las variables en el alcance del bucle. . Nos permite inicializar el contenedor que deseamos recorrer en la propia declaración de rango.

Sintaxis:

for (init-statement(opcional) range_declaration : range_expression)  
{
 
         /* cuerpo del ciclo */

}

Programa 3:

// C++ program to illustrate the
// above concepts
#include <iostream>
using namespace std;
  
// Driver Code
int main()
{
  
    for (std::vector v{ 1, 2, 3 }; auto& e : v) {
        std::cout << e;
    }
}

Producción:

Nuevos identificadores (importación, módulo) :

• Los módulos ayudan a dividir grandes cantidades de código en partes lógicas. Los módulos prometen tiempos de compilación más rápidos, aislamiento de macros y hacen que los archivos de encabezado sean redundantes.
• Expresan la estructura lógica del código y ayudan a deshacerse de la fea solución de macro. Los módulos son ortogonales a los espacios de nombres. No importa en qué orden importe un módulo.
• Los módulos le permiten expresar la estructura lógica de su código. Puede especificar explícitamente los nombres que deben exportarse o no. Además, puede agrupar algunos módulos en un módulo más grande y puede proporcionarlos como un paquete lógico.
• Con los módulos, ahora no hay necesidad de separar su código fuente en una interfaz y una parte de implementación.

Programa 4:

// C++ program to illustrate the
// above concepts
// helloworld.cpp module declaration
export module helloworld;
  
// Import declaration
import<iostream>;
  
// Export declaration
export void hello()
{
    std::cout << "Hello world!\n";
}

// main.cpp import declaration
import helloworld;
  
// Driver Code
int main()
{
    hello();
}

Producción:

Biblioteca de calendario y zona horaria :

La biblioteca crono de C++ 11/14 se amplió con una función de calendario y zona horaria. El calendario consta de tipos, que representan un año, un mes, un día de un día de la semana o el n-ésimo día de la semana de un mes. Estos tipos elementales se pueden combinar con tipos complejos como, por ejemplo , año_mes , año_mes_día , año_mes_día_último , años_mes_día_semana y año_mes_día_semana_último . El operador «/» está sobrecargado para la especificación conveniente de puntos de tiempo. Además, obtendremos con C++20 nuevos literales: d para un día e y para un año.

Debido a la biblioteca crono extendida , las siguientes funciones son fáciles de implementar:

• Obtener el último día de un mes.
• Obtener el número de días entre dos fechas.
• Impresión de la hora actual en varias zonas horarias.

Sintaxis:

Defined in header <chrono>
Defined in namespace std::chrono

Ejemplo:

auto date1 = 2020y/sep/8;
auto date2 = 21d/oct/2018;
auto date3 = jan/27/2019;

std::funciones de string :

termina_con (“sufijo”): Comprueba si la string termina con el sufijo dado.
comienza_con («prefijo»): Comprueba si la vista de string comienza con el prefijo dado.

Programa 5:

// C++ program to illustrate the
// above concepts
#include <iostream>
using namespace std;
  
// Driver Code
int main()
{
    std::string str = "GeeksforGeeks";
  
    // Check string str starts_with Geeks
    if (str.starts_with("Geeks")) {
        std::cout << "true" << endl;
    }
    else {
        std::cout << "false" << endl;
    }
  
    // Check string str ends_with Geeks
    if (str.ends_with("for")) {
  
        std::cout << "true" << endl;
    }
    else {
  
        std::cout << "false" << endl;
    }
}

Producción:

Array acotado/ilimitado :

• Comprueba si T es un tipo de array de límite desconocido y proporciona el valor constante del miembro que es igual a true , si T es un tipo de array de límite desconocido. De lo contrario, el valor es igual a false .
• Comprueba si T es un tipo de array de límite conocido y proporciona el valor constante del miembro que es igual a true , si T es un tipo de array de límite conocido. De lo contrario, el valor es igual a false .

Programa 6:

// C++ program to illustrate the
// above concepts
#include <iostream>
#include <type_traits>
  
// Class A
class A {
};
  
// Driver Code
int main()
{
  
    std::cout << std::is_unbounded_array_v<A> << '\n';
    std::cout << std::is_unbounded_array_v<A[3]> << '\n';
    std::cout << std::is_unbounded_array_v<int[]> << '\n';
    std::cout << std::is_unbounded_array_v<int> << '\n';
    std::cout << std::is_bounded_array_v<A> << '\n';
    std::cout << std::is_bounded_array_v<A[3]> << '\n';
    std::cout << std::is_bounded_array_v<float> << '\n';
    std::cout << std::is_bounded_array_v<int> << '\n';
}

Producción:

std::to_arreglo :

Convierte el objeto array/”similar a una array” dado en un std::array . Crea un std::array a partir del arreglo integrado unidimensional a . Los elementos de std::array se copian inicializados desde el elemento correspondiente de un archivo . No se admite la copia o el movimiento de una array integrada multidimensional.

Programa 7:

// C++ program to illustrate the
// above concepts
#include <iostream>
using namespace std;
  
// Driver Code
int main()
{
    // Returns std::array<char, 5>
    std::to_array("Geeks");
  
    std::to_array<int>(
        { 1, 2, 3 });
  
    int a[] = { 1, 2, 3 };
  
    // Returns std::array<int, 3>`
    std::to_array(a);
}

Atributos probables e improbables :

Proporciona una pista al Optimizador de que es probable o poco probable que se ejecute el cuerpo de la declaración etiquetada. Ambos atributos permiten dar una pista al Optimizer, ya sea que la ruta de ejecución sea más o menos probable.

Programa 8:

// C++ program to illustrate the
// above concepts
#include <iostream>
using namespace std;
  
// Driver Code
int main()
{
    int n = 40;
    [[likely]] if (n < 100) { cout << n * 2; }
  
    [[unlikely]] while (n > 100)
    {
        n = n / 2;
        cout << n << endl;
    }
  
    n = 500;
    [[likely]] if (n < 100) { cout << n * 2; }
  
    [[unlikely]] while (n > 100)
    {
        n = n / 2;
        cout << n << endl;
    }
    return 0;
}

Producción:

Referencias : C++ 20 , Referencia CPP .