La conception de C++ 20 est achevée et le premier brouillon sera publié en juillet 2019,
Les Modules et les Coroutines y sont présents

Le , par Bill Fassinou

189PARTAGES

20  0 
La toute dernière réunion du comité ISO C++ pour approuver les nouvelles fonctionnalités à venir dans C++ 20 s’est tenu la semaine passée à Kona, à Hawaii. À l’issu de cette réunion, le comité a annoncé que les fonctionnalités du prochain standard international (SI) du langage de programmation C++, le C++ 20 sont maintenant finalisées. Il a également indiqué qu’une prochaine réunion, prévue pour juillet prochain, mettra fin à la spécification et verra la publication d’un brouillon pour examen. Le président du comité de normalisation ISO C++, Herb Sutter, (également auteur, conférencier et architecte logiciel chez Microsoft) a déclaré ce qui suit : « Nous connaissons ainsi la plupart des fonctionnalités finales de C++ 20 ! Lors de notre prochaine réunion en juillet, nous prévoyons d’adopter officiellement quelques fonctionnalités supplémentaires qui ont été approuvées par la conception lors de cette réunion, mais qui n’ont pas encore été révisées dans leur intégralité. À la fin de la réunion de juillet, nous lancerons ensuite le premier bulletin de commentaires pour C++ 20 pour d’examen ».

Parmi les nombreuses nouvelles fonctionnalités approuvées pour le C++ 20, deux fonctionnalités majeures sont à noter. Il s’agit des fonctionnalités dénommées Modules et celles dénommées Coroutines. Comme l’explique Herb Sutter, les Modules constituent une nouvelle alternative aux fichiers d’en-tête et apportent un certain nombre d’améliorations clés notamment en isolant les effets des macros et en permettant des générations évolutives. Cette fonctionnalité permet aux utilisateurs du langage de définir une limite d’encapsulation nommée, une première depuis ses 35 ans d’âge selon Sutter. Il existait jusque-là trois fonctionnalités de ce type qui permettent aux programmeurs de créer leurs propres mots de pouvoir en (a) donnant un nom défini par l'utilisateur en (b) quelque chose dont l'implémentation est cachée, explique Sutter. Ce sont : la variable (qui encapsule la valeur actuelle), la fonction (qui encapsule le code et le comportement) et la classe (qui encapsule les deux pour délivrer un ensemble d’états et de fonctions).

Même des fonctionnalités majeures telles que les Modèles constituent des moyens de décorer ou de paramétrer ces trois fonctionnalités fondamentales. À ces trois, est ajoutée maintenant une quatrième, les Modules qui encapsulent les trois pour en livrer un ensemble. Les Coroutines quant à eux, sont des fonctions qui peuvent suspendre et reprendre leur exécution tout en conservant leur état. L'évolution en C++ 20 va encore plus loin. Le terme Coroutines est inventé par Melvin Conway, un informaticien. Il l'a utilisé dans sa publication pour la construction d'un compilateur en 1963. Cette fonctionnalité existe également dans les langages comme Python. L'implémentation spécifique de Coroutines en C++ est un peu intéressant. Au niveau le plus élémentaire, il ajoute quelques mots-clés à C++ comme co_return, co_await, co_yield ainsi que des types de bibliothèques qui fonctionnent avec eux. Une fonction devient une coroutine en ayant une de ces fonctions dans son corps.


Lorsqu'un de ces trois mots-clés est utilisé dans un corps de fonction, un examen standard obligatoire du type de retour et des arguments est produit et la fonction est transformée en une coroutine. Cet examen indique au compilateur où stocker l'état de la fonction lorsque celle-ci est suspendue. La spécification s’est portée également sur d’autres fonctionnalités et modifications telles que :

  • l’extension des liaisons structurées et la capture de référence des liaisons structurées qui permettent à un nom introduit en tant que liaison structurée d'être utilisé de manière supplémentaire, par exemple d’être capturé par référence dans des lambdas ;
  • &#8660;! === qui ajoute une meilleure prise en charge linguistique pour la composabilité lors de l'écriture <=> pour les types pouvant écrire un == plus efficace que d'utiliser l'opérateur <=> seul. Par exemple, le vecteur <T> peut court-circuiter la comparaison == en vérifiant d’abord si les deux vecteurs ont la même taille ;
  • changer span pour utiliser une taille non signée et ajouter des fonctions ssize() pour obtenir les tailles signées. Cette fonctionnalité rend std::span plus pratique à utiliser avec les types STL existants, tout en permettant l’utilisation de tailles et d’index signés via ssize( ) pour bénéficier des avantages de la signature ;
  • le polymorphic allocator. Il permet à pmr::memory_resource d'être utilisée partout où des allocateurs peuvent être utilisés dans la bibliothèque standard ;
  • etc.

Le comité à travers le reportage de Sutter, a indiqué que les processus tels que les exécuteurs et la mise en réseau continuent de progresser, les deux étant étroitement liés. « Nous espérions qu'une partie des exécuteurs serait prête pour le C++ 20, mais ils n'ont pas réussi la coupe. Ils sont tous deux sur la bonne voie pour bientôt, post C++ 20 (c'est-à-dire au début de la phase C++ 23) », a expliqué Herb Sutter, le président du comité. Beaucoup félicitent l’effort mis en œuvre par le comité pour offrir ces nouvelles fonctionnalités à la communauté C++ et l’encouragent à faire encore plus pour la prochaine standardisation du langage (C++ 23).

Cependant, certains expriment leur mécontentement par rapport au fait que la mise en réseau soit encore laissée de côté comme il a été le cas plusieurs fois déjà. Néanmoins, pour l’effort qui est fait, plusieurs y voient une expérience très excitante et encouragent à une adoption à grande échelle du C++ 20. Les autres fonctionnalités telles que les Concepts, les Ranges, les Contrats qui avaient été introduites dans C++ 20 avant cette réunion sont présentées et expliquées sur le site de l’ISO C++. Vous y retrouverez également d’autres annonces ainsi que le calendrier des autres événements à venir pour livrer complètement le C++ 20.

Source : Billet de blog

Et vous ?

Que pensez-vous de ces nouveautés de C++ 20 ?

Voir aussi

De C++14 à C++17, qu'est-ce qui a changé avec la nouvelle version du langage C++ : un document de la Standard C++ Foundation

La spécification de la nouvelle version du langage C++ (C++17) est finalisée quelles sont les nouveautés introduites ?

Le premier brouillon de la prochaine révision du standard C, le C2x, est publié et met l'accent sur la compatibilité du langage

Internet aurait de sérieux problèmes à cause de langages comme C et C++ favorisant la survenue de failles mais peu de développeurs s'en soucieraient

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de ParseCoder
Membre averti https://www.developpez.com
Le 26/02/2019 à 0:12
C'est une version bien pleine, très intéressante et ça promet du boulot pour maîtriser tout ça. Voilà la liste des nouveautés dans le post de Herb Sutter (en plus il précise "modulo any additional features in July":

modules
coroutines
concepts
contracts
<=> spaceship
“lots more constexpr”: broad use of normal C++ for direct compile-time programming, without resorting to template metaprogramming (see last trip report)
ranges
calendars and time zones
span
and lots more

Il a raison de dire:
Citation Envoyé par Herb Sutter
We understand that’s exciting, but we also understand that’s a lot for the community to absorb
7  0 
Avatar de Pyramidev
Expert confirmé https://www.developpez.com
Le 26/02/2019 à 13:59
Enfin les modules !!!
5  0 
Avatar de Mingolito
Membre extrêmement actif https://www.developpez.com
Le 26/02/2019 à 19:27
C'est pas mal, mais bon le C++ est très en retard est encore très loin de pouvoir rattraper l'énorme avance du C# qui est bien plus moderne et surtout bien mieux foutu, le C++ reste un langage désuet et ringard.

D'ailleurs l'avenir c'est clairement le langage Julia qui n'a que des avantages, C++ est en train de se Coboliser, mais bon cela restera une bonne source de revenus pour la maintenance de l'existant pour ceux qui aiment les langages antiques compliqués ...
1  14 
Avatar de Pyramidev
Expert confirmé https://www.developpez.com
Le 26/02/2019 à 20:18
Citation Envoyé par Mingolito Voir le message
C'est pas mal, mais bon le C++ est très en retard est encore très loin de pouvoir rattraper l'énorme avance du C# qui est bien plus moderne et surtout bien mieux foutu, le C++ reste un langage désuet et ringard.

D'ailleurs l'avenir c'est clairement le langage Julia qui n'a que des avantages
Comparé aux autres langages connus de haut niveau comme Java et C#, C++ est en retard sur certains points, mais il est en avance sur d'autres, surtout quand on a besoin d'avoir de bonnes performances.

Du côté des langages émergents, peut-être que Julia s'imposera dans les applis qui n'auront pas besoin de performances aussi élevées qu'avec du C++ optimisé. Mais, tant que Julia nécessitera d'utiliser un ramasse-miettes, il ne sera pas un vrai concurrent du C++. Le futur concurrent le plus sérieux du C++ me semble être Rust.
9  0 
Avatar de JolyLoic
Rédacteur/Modérateur https://www.developpez.com
Le 26/02/2019 à 20:28
il y a eu de gros débats houleux sur les modules, les coroutines, les contrats, mais pour l'intant, les 3 sont dedans ! Et il n'y a je crois aucun mort à déplorer pendant cette réunion
4  0 
Avatar de G_EREMY
Futur Membre du Club https://www.developpez.com
Le 26/02/2019 à 22:54
Je suis pas d'accord avec le fait que C++ est en retard par rapport aux autres langages comme C# ou Julia sachant que C++ est complètement à part par rapport à ces langages. Déjà C++ permet de faire pas mal de choses que les autres langages ne permettent pas (alors que l'inverse n'existe pas, c'est juste que ça peut être compliqué à faire ). Surtout que maintenant avec la standardisation de C++ et la librairie STL qui va avec, c'est un langage qui est puissant, sophistiqué, et surtout performant. Après même si Julia à l'air plutôt sympa, et même avoir des performances proche de C++, je pense pas que l'on puisse envisager de migrer des projet de C++ vers Julia. Et je ne pense pas non plus que les gens vont lâcher C++ au profit de Julia ou de C# (surtout pour le C# qui est plus un concurrent pour Java). D'ailleurs, l'argument comme quoi Julia a des performances proche de C++, je pense qu'on peut assez vite s'en éloigner si on arrive sur des projets qui commence à être complexe (à condition d'utiliser correctement les mécanisme du C++ visant à optimiser son programme, et on peut aller encore plus loin si on décide d'être vraiment bas niveau, et donc d'éviter au maximum d'utiliser la librairie STL). De plus, sur certaines applications, le garbage collector ça pose vite des problèmes pour les performances. Par contre Julia sera surtout un concurrent pour Python, ce qui est une très bonne chose. D'ailleurs tu remarqueras aussi que pour faire de la programmation système C et C++ n'ont pas vraiment de concurrent

Sinon, je voulais savoir, est ce que c'est dans C++20 qu'ils ont prévu de pouvoir restreindre les types génériques (comme en Java par exemple) ?
Et est ce que c'est prévu qu'ils règlent le problème où l'ont doit inclure le fichier source dans le header quand on fait de la généricité ? C'est le côté moche du C++ je trouve Surtout que du coup on ne peut pas faire du using namespace dans le fichier source au quel cas cela va se répercuter dans les autres fichiers sources.
2  0 
Avatar de dourouc05
Responsable Qt & Livres https://www.developpez.com
Le 26/02/2019 à 23:32
Citation Envoyé par G_EREMY Voir le message
Déjà C++ permet de faire pas mal de choses que les autres langages ne permettent pas (alors que l'inverse n'existe pas, c'est juste que ça peut être compliqué à faire ).
Quoi, par exemple ? Je n'ai en tête que des syntaxes spécifiques que C++ autorise (merci les templates), mais pas de fonctionnalité qu'un autre langage ne saurait pas implémenter (peut-être pas avec la même performance, mais le C++ ne gagne pas non plus à tous les coups).
4  0 
Avatar de G_EREMY
Futur Membre du Club https://www.developpez.com
Le 27/02/2019 à 0:15
Citation Envoyé par dourouc05 Voir le message
Quoi, par exemple ? Je n'ai en tête que des syntaxes spécifiques que C++ autorise (merci les templates), mais pas de fonctionnalité qu'un autre langage ne saurait pas implémenter (peut-être pas avec la même performance, mais le C++ ne gagne pas non plus à tous les coups).
Bah déjà l'héritage multiple, l'héritage par spécialisation, le multi-thread, le multi-processus, et tout ce qui concerne le système. Après effectivement il n'y a pas de choses que C++ permet de "calculer" mais qui n'est pas calculable dans C#, Julia, etc...
0  2 
Avatar de Aurelien.Regat-Barrel
Expert éminent sénior https://www.developpez.com
Le 27/02/2019 à 1:27
Citation Envoyé par Mingolito Voir le message
l'avenir c'est clairement le langage xxx qui n'a que des avantages
https://blog.daftcode.pl/hype-driven...t-3469fc2e9b22
5  0 
Avatar de jo_link_noir
Membre émérite https://www.developpez.com
Le 27/02/2019 à 1:38
Citation Envoyé par G_EREMY Voir le message
Bah déjà (1) l'héritage multiple, (2) l'héritage par spécialisation, (3) le multi-thread, le multi-processus, et tout ce qui concerne le système.
1) La plupart supportent l'héritage multiple d'interface et l’injection de trait (directement à l'intérieur d'une classe ou de manière externe).
2) Du CRTP ? C'est vrai que de manière générale les autres langages sont plus limitants au niveau du fonctionnement des templates.
3) Ce n'est pas du ressort du C++, mais des bibliothèques. Après, pour les quelques mots clefs comme thread_local, je pense qu'on peut trouver des équivalents.

utiliser correctement les mécanismes du C++ visant à optimiser son programme, et on peut aller encore plus loin si on décide d'être vraiment bas niveau, et donc d'éviter au maximum d'utiliser la librairie STL)
La STL est optimisation/bas niveau n'est pas incompatible. Il y a certaines parties qui peuvent être problématique, mais une bonne partie est censé être performant. Si ce n'est pas le cas, la meilleure chose à faire est de patcher les implémentations pour que tous le monde en profite.

est-ce prévu de pouvoir restreindre les types génériques (comme en Java par exemple) ?
Les concepts devraient permettre cela. Actuellement on peut le faire avec std::enable_if/SFINAE ou des static_assert.

Et est ce que c'est prévu qu'ils règlent le problème où l'on doit inclure le fichier source dans le header quand on fait de la généricité ?
Ce n'est pas possible pour plusieurs raisons:

- Le prototype peut dépendre de l'implémentation, par exemple avec une fonction qui retourne auto.
- Les instances de fonction template n'existe qu'au moment de leur utilisation. Pour les mettre dans un .cpp, il faudrait alors instancier les mêmes fonctions dans le cpp pour ne pas avoir des erreurs de link. On peut utiliser des instanciations explicite et extern(?), mais cela cause d'autre soucis pour une classe: toutes les fonctions doivent compiler, même si elles ne sont jamais utilisées.

Pour la séparation, le plus commun reste de mettre les implémentations dans un .tpl, tcc, .inl, .whatever et de l'inclure en fin du fichier d'en-tête.

C'est le côté moche du C++ je trouve Surtout que du coup on ne peut pas faire du using namespace dans le fichier source auquel cas cela va se répercuter dans les autres fichiers sources.
Il doit bien y avoir moyen de le faire en jouant avec les namespaces

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
namespace malib {
  namespace impl {
    using namespace std;
    namespace v1 {
      // ...
    }
  }
  using namespace impl::v1;
}


Après perso, je préfère écrire le namespace ou mettre un alias dessus.
5  0 
Contacter le responsable de la rubrique Accueil

Partenaire : Hébergement Web