Clever Geek Handbook

Norme "C ++ 20" approuvée par le Comité ISO





Récemment, le Comité ISO pour la normalisation du langage C ++ (oui, il y en a un) a approuvé la norme internationale "C ++ 20". Les fonctionnalités présentées dans la spécification sont prises en charge par les compilateurs GCC, Clang et Microsoft Visual C ++. De plus, des bibliothèques standard prenant en charge "C ++ 20" sont implémentées dans le projet Boost.



La prochaine étape consiste à préparer le document en vue de sa publication. Ensuite, début novembre, la version finale sera envoyée à l'ISO, après quoi elle sera publiée sous le nom officiel ISO / CEI 14882: 2020. Le comité travaille déjà sur le prochain standard, C ++ 23 (C ++ 2b). Sous la coupe - fonctionnalités de "C ++ 20" avec des exemples de code.



Quoi de neuf?

Le comité a ajouté des «concepts» , des extensions de modèle qui vous permettent de définir un ensemble d'exigences pour les paramètres de modèle. Au moment de la compilation, ils contraignent l'ensemble des arguments qui peuvent être acceptés comme paramètres de modèle. Les concepts permettent d'éviter les incohérences logiques entre les propriétés des types de données utilisées à l'intérieur du modèle et les propriétés des types de données des paramètres d'entrée. 



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


Extension acceptée pour travailler avec les modules. Ils peuvent être utilisés à la place des fichiers d'en-tête. Les modules fournissent une nouvelle façon d'organiser les sources en fonction de la définition des limites des composants, sans inclure les fichiers d'en-tête à l'aide de "#include".



Ajout de la macro __VA_OPT__ pour l'expansion adaptative des macros variadiques en fonction de la présence de jetons dans l'argument variadique.



Ajout de la prise en charge de l'opérateur <=> pour la comparaison à trois. Les



initialiseurs d' élément par défaut pour les champs de bits sont pris en charge .



Ajout de la possibilité de capturer les expressions lambda * this. 



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


Les classes peuvent désormais utiliser des paramètres de modèle sans type. 



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


Vous pouvez maintenant utiliser des chaînes littérales dans les paramètres de modèle. La syntaxe d'initialisation de style C est prise en charge. Celles qui ne sont pas explicitement répertoriées dans les listes d'initialisation des champs sont initialisées par défaut. 



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


Les membres vides des structures de données sont pris en charge.



Les attributs probables et improbables sont pris en charge pour informer l'optimiseur de la probabilité que l'instruction conditionnelle soit déclenchée ("[[probable]] if (random> 0) {").



Vous pouvez maintenant utiliser des plages pour initialiser les valeurs des variables dans une boucle for 



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


Les fonctions immédiates sont prises en charge , qui ne peuvent fonctionner qu'avec des constantes. 



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


Ajouté à la bibliothèque:

  • prise en charge du type char8_t pour les chaînes UTF-8.
  • en-têtes bit (opérations sur bits) et version.
  • la possibilité de vérifier le préfixe et le suffixe des chaînes (begin_with, ends_with).
  • traits std :: remove_cvref, std :: unwrap_reference, std :: unwrap_decay_ref, std :: is_nothrow_convertible et std :: type_identity.
  • fonctions std :: midpoint, std :: lerp, std :: bind_front, std :: source_location, std :: visit, std :: is_constant_evaluated et std :: assume_aligned.
  • prise en charge des tableaux dans std :: make_shared.
  • Fonction std :: to_array pour convertir des objets de type tableau en std :: array.


La syntaxe d'énumération est désormais plus pratique: 

   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";
    }
   }


Il est interdit d' utiliser les opérations "," ("a [b, c]") dans les index . La plupart des opérations sur les variables déclarées avec le mot clé violate, y compris les opérations interdites ++ et - avec les types standard, ne sont pas prises en charge.





More articles:


All Articles