C++20

Qt 6.7 supporte C++20

Soumis par fredericmazue le

Le projet Qt vient de publier la version 6.7 de cette fameuse librairie. Il s'agit d'une version riche au niveau des graphiques 2D, 3D et vectoriels. Ces nouveautés sont décrites dans la vidéo ci-dessous. Nous remarquons aussi que Qt 6.7 supporte C++20.

Qt et C++20

Le projet Qt fait remarquer que C++20  n'est pas exigé pour construire ou utiliser Qt. D'autant plus que C++20 reste optionnel et expérimental pour de nombreuses chaînes d'outils de compilateur. Toutefois il est désormais possible d'utiliser Qt avec C++20.

Pour les développeurs de Qt, Un ajout utile au langage C++20 est la comparaison à trois voies operator<=>(), également connue sous le nom d'opérateur « soucoupe ». Lors de l'implémentation de cet opérateur, les types doivent spécifier leur catégorie de classement. Dans Qt 6.7, les développeurs ont ajouté les classes Qt::{strong,weak,partial}_ordering comme implémentations compatibles avec C++17 des types std::*_ordering respectifs. Pour les auteurs de types, Qt 6.7 fournit des macros d'assistance qui peuvent être utilisées pour implémenter des opérateurs relationnels. Ces macros sont étendues dans le code C++20 et se ramènent (fallback) aux six opérateurs dans le code C++17.

Pour les développeurs de Qt, un autre ajout utile de C++20 est sdt:span. Ils l'utilisent eux-mêmes et ils otn souhaité le rendre disponible aux utilisateurs de Qt grâce à QSpan. En tant que représentation non propriétaire d'une séquence contiguë d'objets, un span est peu coûteux à construire et à passer par des appels de fonction, et avec QSpan il y a maintenant une implémentation C++17 de ce type.

[video:https://www.youtube.com/watch?v=pCtAzdvT3FY autoplay:0]

Le standard C++20 est publié !

Soumis par fredericmazue le

Annoncée pour la fin de l'année en septembre dernier, la publication du standard C++20 est aujourd'hui effective.

La liste des évolutions apportées par C++20 est longue, tant au niveau du langage lui-même que des bibliothèques. Celle liste complète peut-être consultée ici.

De l'avis général, les deux nouveautés les plus marquantes sont les modules et les coroutines.

Les modules constituent une nouvelle alternative aux fichiers d’en-tête qui apporte un certain nombre d’améliorations clés, notamment en isolant les effets des macros et en permettant des compilations évolutives. A ce sujet, Herb Sutter, gourou du C++, souligne qu'en 35 ans c'est première fois que C ++ ajoute une nouvelle fonctionnalité permettant aux utilisateurs de définir une limite d’encapsulation nommée.

Une coroutine est une unité de traitement qui s'apparente à une fonction (ou routine) avec cette différence que si une sortie du corps d'une fonction met fin à l'exécution de celle-ci, la sortie de la coroutine suspend seulement le traitement qui peut ensuite reprendre, l'état du traitement à la sortie étant conservée. 

Le standard C++20, la bible pour un programmeur C++, peut est acheté sur le site de l'ISO, l'Organisation internationale de normalisation, dont le rôle est d'établir et de publier les normes internationales. Pour C++20, c'est ici.

Le standard C++20 sera publié d'ici la fin de l'année

Soumis par fredericmazue le

Le mois de février 2020 a vu la fin des travaux du comité de normalisation du langage C++ sur la mouture C++. Un billet de Herb Sutter, gourou du C++ nous apprend qu'un vote du comité a approuvé à l'unanimité le DIS, pour Draft International Standard.

Cette approbation technique finale transforme le DIS en standard ISO C++20. La publication officielle du document est prévue pour la fin 2020. Le comité de normalisation se consacre désormais à C++23.

La liste des évolutions apportées par C++20 est longue...

Aux yeux d'Herb Sutter, qui nous a annoncé la publication prochaine de C++20, les améliorations les plus marquantes sont les modules et les coroutines.

Les modules constituent une nouvelle alternative aux fichiers d’en-tête qui apporte un certain nombre d’améliorations clés, notamment en isolant les effets des macros et en permettant des compilations évolutives. A ce sujet, Herb Sutter souligne qu'en 35 ans c'est première fois que C ++ ajoute une nouvelle fonctionnalité permettant aux utilisateurs de définir une limite d’encapsulation nommée.

Une coroutine est une unité de traitement qui s'apparente à une fonction (ou routine) avec cette différence que si une sortie du corps d'une fonction met fin à l'exécution de celle-ci, la sortie de la coroutine suspend seulement le traitement qui peut ensuite reprendre, l'état du traitement à la sortie étant conservée. 

C++20 est terminé, C++23 est en préparation

Soumis par fredericmazue le

Un an après que le Comité ISO C++ a figé les fonctionnalités de C++20, une dernière réunion de ce comité, qui s'est tenue du 10 au 15 février 2020 à Prague, a officiellement terminé le projet. Autrement dit la norme va sortir dans quelques mois. Pour l'occasion le comité aime à rappeler que C++20 est la révision la plus percutante de C ++ depuis une décennie.

Les nouveautés de C++20 sont très nombreuses. En attendant la publication de la norme, un billet du Comité sur Reddit les rappelle. 

La nouveauté la plus marquante de C++20 est peut être l'apparition des Coroutines. Une coroutine est une unité de traitement qui s'apparente à une fonction (ou routine) avec cette différence que si une sortie du corps d'une fonction met fin à l'exécution de celle-ci, la sortie de la coroutine suspend seulement le traitement qui peut ensuite reprendre, l'état du traitement à la sortie étant conservée. 

C++20 ne sera pas la dernière évolution du langage, bien loin de là, et le billet mentionné plus haut nous informe que le Comité est déjà au travail pour C++23.

Un plan de travail a été adopté pour C++23. Ce plan nous apprend que les apports principaux de la nouvelle mouture seront l'arrivée d'une librairie pour les coroutines, une librairie standard modulaire, les exécuteurs et le réseau. Mais des avancées seront également faites en ce qui concerne des fonctionnalités de réflexion et d'injection de code, la correspondance de motif et les contrats.

Le billet indique encore une feuille de route. La première réunion consacrée à C++23 se tiendra dans le courant de l'été cette année. Les fonctionnalités les plus importantes seront ensuite définies lors de 4 étapes. La dernière, en automne 2021, verra le gel des nouvelles fonctionnalités de C++23, et le langage devrait être déclaré complètement spécifié au cours du printemps 2022. Au cours de l'été 2023 se tiendra la première réunion consacrée à ... C++26.

[video:https://www.youtube.com/watch?v=AvPiGstxV_g autoplay:0]

Visual Studio 2019 16.3 supporte les Concepts de C++20

Soumis par fredericmazue le

Microsoft annonce que les Concepts du standard C++20 sont supportés pour la première fois dans Visual Studio 2019 16.3 Preview 2.

Ce support concerne à la fois le compilateur et la bibliothèque standard. En revanche les Concepts ne sont pas encore supportés par Intellisense. Microsoft précise que la fonctionnalité peut être activée par le mode /std:c++. Lorsque toutes les fonctionnalités de C++20 seront implémentées, un mode /std:c++20 sera fourni.

Les Concepts de C++ sont des prédicats permettant d'exprimer les attentes d'un algorithme générique sur des arguments de templates. Ils permettent de documenter formellement les contraintes sur les templates et de les faire appliquer par le compilateur. Les concepts permettent d'écrire un code plus concis et dont la compilation est plus rapide. Vous pouvez en apprendre plus sur les Concepts par exemple en lisant ce billet de Bjarne Strousrtup.

Microsoft donne cet exemple de code pour illustrer le support des Concepts dans Visual Studio 2019 16.3 Preview 2 :

#include <concepts>

// This concept tests whether 'T::type' is a valid type
template<typename T>
concept has_type_member = requires { typename T::type; };

struct S1 {};
struct S2 { using type = int; };

static_assert(!has_type_member<S1>);
static_assert(has_type_member<S2>);
// Currently, MSVC doesn't support requires-expressions everywhere; they only work in concept definitions and in requires-clauses

//template <class T> constexpr bool has_type_member_f(T) { return requires{ typename T::type; }; }
template <class T> constexpr bool has_type_member_f(T) { return has_type_member<T>; }

static_assert(!has_type_member_f(S1{}));
static_assert(has_type_member_f(S2{}));

// This concept tests whether 'T::value' is a valid expression which can be implicitly converted to bool
// 'std::convertible_to' is a concept defined in <concepts>
template<typename T>
concept has_bool_value_member = requires { { T::value } -> std::convertible_to<bool>; };

struct S3 {};
struct S4 { static constexpr bool value = true; };
struct S5 { static constexpr S3 value{}; };

static_assert(!has_bool_value_member<S3>);
static_assert(has_bool_value_member<S4>);
static_assert(!has_bool_value_member<S5>);

// The function is only a viable candidate if 'T::value' is a valid expression which can be implicitly converted to bool
template<has_bool_value_member T>
bool get_value()
{
  return T::value;
}

// This concept tests whether 't + u' is a valid expression
template<typename T, typename U>
concept can_add = requires(T t, U u) { t + u; };

// The function is only a viable candidate if 't + u' is a valid expression
template<typename T, typename U> requires can_add<T, U>
auto add(T t, U u)
{
  return t + u;
}

Microsoft travaille en ce moment au support de Range, qui fournit des composants permettant de traiter des plages d'éléments et qui a une relation étroite avec Concept.

Commentaire actu

Anonyme (non vérifié)

Si C++ a des qualités indéniables, tenter d'y introduire des concepts déjà présents depuis longtemps dans les langages managés et notament C# qui est de loin le plus avancé en la matière, me parait un peu illusoire.

Le C++ est un très bon langage! Alors pitié Mr Strousrtup, ne tentez pas d'égaler le C# sur la généricitié, les fonctions lambda linq et toutes les belles avancés que nous a fait vivre ce langage.!
C++ n'est pas adapté à cela. D'autant que la syntaxe proposé est d'une complexité allucinante et est à des années lumière de celle du C#.

mer, 18 Sep 2019 - 17:29 Permalien

Les fonctionnalités de C++20 sont définies

Soumis par fredericmazue le

Après une réunion parmi les plus grandes en 29 ans d'histoire, le comité ISO C++ a figé les fonctionnalités de C++20 nous apprend un billet d'Herb Sutter, gourou du C++.

Selon Herb Sutter, les deux fonctionnalités les plus importantes du standard C++20 sont les modules et les coroutines. Les modules constituent une nouvelle alternative aux fichiers d’en-tête qui apporte un certain nombre d’améliorations clés, notamment en isolant les effets des macros et en permettant des compilations évolutives, explique Herb qui ajoute qu'en 35 ans c'est première fois que C ++ ajoute une nouvelle fonctionnalité permettant aux utilisateurs de définir une limite d’encapsulation nommée.

Les coroutines sont elles aussi une fonctionnalité à remarquer. Une coroutine est une unité de traitement qui s'apparente à une fonction (ou routine) avec cette différence que si une sortie du corps d'une fonction met fin à l'exécution de celle-ci, la sortie de la coroutine suspend seulement son traitement qui peut ensuite reprendre, l'état du traitement à la sortie étant conservée. Une coroutine peut être vue comme un morceau de programme qui conserve son état, mais qui n'a pas de thread d'exécution. Les coroutines peuvent notamment être utilisées pour des itérateurs et des générateurs.

Par exemple, soit une coroutine en pseudo code :

function Generator() {
  for (i = 0 to 100)
    produce i
} 

Cette coroutine peut être implémentée et utilisée comme ceci en C++20

#include <iostream>

template <typename T>
generator<int> range(T first, T last)
{
  while (first != last)
  {
    co_yield first++;
  }
}


int main()
{
  for (int i : range(0, 100))
  {
    std::cout << i << std::endl;
  }
  return 0;
}

Les coroutines ne se résument pas à un simple générateur. Il est possible d'attendre une coroutine dans une coroutine avec l'instruction co_yield, ce qui permet de définir une logique entre plusieurs coroutines.

Le premier brouillon (draft) de la spécification C++20 doit être publié en juillet 2019. GCC à partir de sa version 8.1 et Visual Studio 2019 propose déjà un premier support expérimental de C++20.