Les coroutines c'est trop bien !!!!!!!
Et mais faite je viens de me rendre compte les coroutines ça déchire du feu de dieux ! 8O 8O 8O 8O
Comment cela se fait-il que tous les languages n'ont pas ce "composant" d'implémenter ? Ça a l'air tellement pratique sur des models MVC ou MVVM pour dissocier l'affichage du reste ! Je vois déjà tellement bien comment l'intégrer à mon code existant, j'ai trop hâte de C++20 sorte !!!
1 pièce(s) jointe(s)
Le comité ISO C++ a finalisé la nouvelle version du langage C++ 20
Le comité ISO C++ a proposé une feuille de route pour C++ 23 et finalisé la nouvelle version du langage C++ 20,
la norme devrait être publiée dans les mois à venir
La dernière réunion du comité ISO C++ s’est tenue à Prague, en République tchèque. Durant cette réunion, le comité a fait des ajouts au brouillon de C++ 20 et a opté pour l'envoyer au Draft International Standard (DIS) pour approbation finale et publication. Sur le plan de la procédure, il est possible que le DIS soit rejeté, mais en raison des procédures et processus du comité, il est très peu probable que cela se produise. Cela signifie que le développement de C++ 20 est terminé, et dans quelques mois la norme sera publiée.
Lors de la réunion, les modifications et ajouts suivants au projet C ++ 20 :
- Amélioration de la reconnaissance contextuelle du « module » et de « l'importation » pour permettre aux outils non compilateurs tels que les systèmes de génération de déterminer plus facilement les dépendances de génération.
- Ajout de plusieurs nouveaux algorithmes de classement.
- Ajout de ranges::ssize.
- Affinage de la signification de static et inline dans les interfaces de module (P1779 et P1815).
- Résolution de nombreux problèmes de langage et de bibliothèque de base et amélioration substantielle des spécifications.
Les éléments suivants sont des fonctionnalités clés dans C++20 :
- Les Modules.
- Les Coroutines.
- Les Concepts.
- Les Ranges.
- Les constexprification: constinit, consteval, std::is_constant_evaluated, constexpr allocation, constexpr std::vector, constexpr std::string, constexpr union, constexpr try and catch, constexpr dynamic_cast and typeid.
- std::format("For C++{}", 20)
- operator<=>
- Macros de test de fonctionnalités.
- std::span
- std::source_location.
- std::atomic_ref.
- std::atomic::wait, std::atomic::notify, std::latch, std::barrier, std::counting_semaphore, etc.
- std::jthread and std::stop_*.
Comme l’explique Herb Sutter, président du comité de normalisation ISO C++, les Modules constituent une nouvelle alternative aux fichiers d’entê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. Il existait jusque-là trois fonctionnalités de ce type qui permettent aux développeurs 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 à elles, 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. 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éressante. 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.
std::format
std::format ajoute la prise en charge des chaînes de format à la bibliothèque standard C++, y compris pour les paramètres de type sécurisé et de position. Si vous connaissez les chaînes au format Boost.Format ou POSIX, ou même simplement printf, vous saurez exactement de quoi il s'agit. Selon lui, std::format donne le meilleur de printf (commodité) et le meilleur de iostreams (sécurité et extensibilité des iostreams), mais il ne se limite pas à iostreams. Il vous permet également de formater n’importe quelle chaîne. « Cela fait longtemps que j'attends cela, de sorte que je n'aurai plus jamais à utiliser l’entête iomanip », a-t-il déclaré à propos.
Les conteneurs constexpr
Les conteneurs constexpr suivants ont été ajoutés à la norme C++ 20 : constexpr INVOKE, constexpr std::vector et constexpr std::string. Selon Sutter, cela signifie que beaucoup de code C++ ordinaire peut être exécuté à la compilation, y compris même les conteneurs std::vector et chaînes dynamiques standard. « C’était quelque chose qui aurait été difficile à imaginer il y a quelques années à peine, mais cela montre de plus en plus que nous sommes sur un chemin où nous pouvons exécuter du code C ++ simple au moment de la compilation au lieu d’essayer d’exprimer ces calculs sous forme de métaprogrammes de modèle », a-t-il précisé à propos de ces ajouts et constexpr std::string.
Au cours de cette réunion, le comité a également adopté un plan pour C ++ 23, qui inclut la hiérarchisation d'une bibliothèque standard modulaire, le support de bibliothèque pour les coroutines, les exécuteurs et la mise en réseau. Elle est prévue à Varna (en Bulgarie).
Évolution du langage
Evolution Working Group Incubator (EWGI) Progress
L'incubateur EWG s'est réuni pendant trois jours à Prague et a examiné et commenté 22 articles pour C ++ 23. 10 de ces documents ont été transmis à Evolution, éventuellement avec quelques révisions demandées. Notamment:
- Élision de copie garantie pour les objets de retour nommés
- Déclaration et utilisation généralisées de pack
- Modèles de membres pour les classes locales
Plusieurs articles ont reçu beaucoup de commentaires et reviendront à l'incubateur, probablement à Varna:
- Un opérateur pipeline-rewrite
- Des paramètres template universels
- Captures lambda partiellement mutables
- C ++ devrait prendre en charge la compilation just-in-time
Concernant les paramètres template universels, imaginez-vous essayer d'écrire une métafonction pour apply :
Code:
1
2
3
4
5
| template <template <class...> class F, typename... Args>
using apply = F<Args...>;
template <typename X>
class G { using type = X; };
static_assert(std::is_same<apply<G, int>, G<int>>{});// OK |
Dès que G essaie de prendre n'importe quel type de NTTP (paramètre de template non-type) ou un paramètre de template-template, apply devient impossible à écrire; nous devons fournir des types de paramètres analogues pour chaque combinaison de paramètres possible:
Code:
1
2
3
| template <template <class> class F>
using H = F<int>;
apply<H, G>// error, can't pass H as arg1 of apply, and G as arg2 |
La solution proposée ? Un moyen de spécifier un paramètre template vraiment universel qui peut se lier à tout ce qui peut être utilisé comme argument template. Appelons le template auto. « La syntaxe est la meilleure que nous puissions trouver; mais il existe de nombreuses façons inexplorées d'orthographier un tel paramètre template ». Par exemple :
Code:
1
2
3
4
5
| template <template <template auto...>
class F, template auto... Args>
using apply = F<Args...>;
apply<G, int>;// OK, G<int>
apply<H, G>;// OK, G<int> |
Le nouveau paramètre template universel introduit des généralisations similaires à l'universel auto NTTP ; afin de permettre le pattern-matching sur le paramètre, les classes template doivent également pouvoir être spécialisées sur le type de paramètre:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| template <template auto>
struct X;
template <typename T>
struct X<T> {
// T is a type
using type = T;
};
template <auto val>
struct X<val> : std::integral_constant<decltype(val), val> {
// val is an NTTP
};
template <template <class> F>
struct X<C> {
// C is a unary metafunction
template <typename T>
using func = F<T>;
}; |
Source : Rapport du comité C++
c+20 un nouveau pas très important mais incomplet
Bonjour,
Pour moi, après avoir travaillé avec des langage multiples (java, c#, Rust, Basic, Pyhton, ... plus de 40), c++ reste à une place particulière :
- c'est seule langage qui n'impose pas de limite entre les concepts hard et les abstractions de hauts niveaux, mais cela peut avoir un coût élevé (formation, investissement) => Il existe énormément de paradigmes de programmation c++, deux programmeurs c++ peuvent ne pas se comprendre.
- Bien qu’il soit possible d’intégrer des programmeurs de langages managés dans un projets c++, il est nécessaire de leur fixer un cadre strict (par exemple interdiction du new et delete)
- Beaucoup des langages qui ont limité les concepts pour simplifier la programmation, ils sont aujourd’hui engagés dans des impasses évolutives, par exemple : java . Ce n’est pas le cas du c++, ce qui lui permet d’évoluer vers la simplification sans coût supplémentaire.
Conclusion :
Il reste encore beaucoup de chose à faire en c++, il n’a pas atteint ces limites et reste un langage d’avenir pour manipuler notre monde. Il n’a pas d’équivalence.
1 pièce(s) jointe(s)
C++ 20 est publié avec de nouvelles fonctionnalités pour le langage et la bibliothèque
C++ 20 est publié avec de nouvelles fonctionnalités pour le langage et la bibliothèque
de nouveaux mots clés et rend obsolètes certaines anciennes fonctionnalités
C++20 est le nom de la révision de la norme ISO/IEC pour le langage de programmation C++ après C++ 17. La norme a été techniquement finalisée par le GT21 lors de la réunion de Prague en février 2020, approuvée le 4 septembre 2020, et publiée par l'ISO au cours de ce mois. Notons que la norme ISO/CEI est un standard de sécurité de l'information publié conjointement par l'Organisation internationale de normalisation (ISO) et la Commission électrotechnique internationale (CEI, ou IEC en anglais). La nouvelle norme ISO C++ est officiellement connue sous le nom de norme internationale "ISO/IEC 14882:2020 - Langage de programmation C++".
Le C++ 20 ajoute plus de nouvelles fonctionnalités majeures que le C++ 14 ou le C++ 17. Les changements qui ont été acceptés ou dont l'inclusion dans le C++ 20 a été discutée sont les suivants :
Langage : nouvelles fonctionnalités linguistiques
- concepts ;
- modules ;
- les initialisateurs désignés (basés sur la caractéristique C99, et l'extension G++ commune) ;
- [=, this] comme une capture lambda ;
- template de listes de paramètres sur les lambdas ;
- opérateur de comparaison à 3 voies "<=>" également appelé "opérateur spaceship" ;
- l'initialisation d'une variable supplémentaire dans une instruction for basée sur une plage ;
- les lambdas dans des contextes non évalués ;
- les lambdas apatrides constructibles et cessibles par défaut ;
- permettre l'extension des paquets dans les captures lambda init ;
- des littéraux de chaîne comme paramètres de template ;
- suppression de l'obligation d'utiliser typename afin de lever l'ambiguïté des types dans de nombreux contextes ;
- nouveaux attributs standard : [[no_unique_address]], [[likely]] et [[unlikely]] ;
- "explicit" conditionnel : il permet au modificateur explicite d'être conditionnel à une expression booléenne ;
- "constexpr" étendu : fonctions virtuelles, union, try and catch, dynamic_cast et typeid, [85] std::pointer_traits ;
- fonctions immédiates utilisant le nouveau mot-clé "consteval" ;
- les entiers signés sont maintenant définis pour être représentés en utilisant le complément à deux (le dépassement des entiers signés reste un comportement non défini) ;
- un template de mémoire révisé ;
- diverses améliorations des liaisons structurées (interaction avec les captures lambda, durée de stockage statique et thread_local) ;
- coroutines ;
- ajout du mot-clé "constinit".
nouvelles fonctionnalités de la bibliothèque
Nouveaux en-têtes
- <concepts> ;
- <coroutine> ;
- <compare> ;
- <version>
- <source_location> ;
- <format> ;
- <span> ;
- <ranges> ;
- <bit> ;
- <numbers> ;
- <syncstream>.
Dans la bibliothèque de support Thread :
- <stop_token> ;
- <semaphore> ;
- <latch> ;
- <barrier>.
Nouvelles fonctionnalités de la bibliothèque
- macros de test des fonctionnalités de la bibliothèque ;
- bibliothèque de formatage ;
- bibliothèque du calendrier et du fuseau horaire ;
- std::source_location ;
- std::span ;
- std::endian ;
- prise en charge des tableaux pour std::make_shared ;
- std::remove_cvref ;
- std::to_address ;
- virgule flottante atomique , shared_ptr atomique ;
- classes de coordination des threads : std::barrier, std::latch, et std::counting_semaphore ;
- std::jthread et classes d'annulation de threads : std::stop_token, std::stop_source, et std::stop_callback ;
- std::osyncstream ;
- std::u8string et autres utilisations de char8_t ;
- constexpr pour <algorithm>, <utility>, <complex> ;
- std::string::starts_with / ends_with et std::string_view::starts_with / ends_with ;
- std::assume_aligned ;
- std::bind_front ;
- std::c8rtomb/std::mbrtoc8 ;
- std::make_obj_using_allocator etc ;
- std::make_shared_for_overwrite/std::make_unique_for_overwrite ;
- recherche hétérogène dans des conteneurs associatifs non ordonnés ;
- std::pmr::polymorphic_allocator avec des fonctions membres supplémentaires et std::byte comme argument de template par défaut ;
- std::execution::unseq ;
- std::midpoint et std::lerp ;
- std::ssize ;
- std::is_bounded_array, std::is_unbounded_array ;
- Ranges ;
- effacement uniforme des conteneurs : std::erase/std::erase_if, par exemple std::erase(std::list) ou std::erase_if(std::map), etc. ;
- constantes mathématiques dans <numbers>.
Mots-clés nouveaux et modifiés
De nombreux nouveaux mots-clés ont été ajoutés (et le nouveau "spaceship operator", opérateur <=>), tels que concept, constinit, consteval, co_await, co_return, co_yield, requires (plus un changement de sens pour l'exportation), et char8_t. En outre, "explicit" peut prendre une expression depuis C++20. La plupart des utilisations du mot-clé "volatile" ont été dépréciées. Outre les mots-clés, il existe des identificateurs ayant une signification particulière, notamment les nouveaux modules et importations.
Publié sous forme de spécifications techniques
- Parallélisme TS v2 (y compris les blocs de tâches) ;
- Mise en réseau TS v1 ;
- Reflection TS v1.
Reporté à une norme ultérieure
- les contrats : un nouveau groupe d'étude (SG21) a été formé pour travailler sur une nouvelle proposition ;
- la réflexion ;
- les métaclasses ;
- les exécuteurs testamentaires ;
- les extensions de réseau, y compris async, les services d'E/S de base, les timers, les tampons et les flux orientés vers les tampons, les sockets et les protocoles Internet (bloqués par les exécuteurs).
Fonctionnalités supprimées et dépréciation
Le C++20 a également supprimé certaines fonctionnalités, notamment :
- les en-têtes dérivés du C <ccomplex>, <ciso646>, <cstdalign>, <cstdbool> et <ctgmath> ont été supprimés, car ils ne servent à rien en C++. (Les en-têtes <*.h> correspondants restent, pour des raisons de compatibilité avec le C.) ;
- l'utilisation de throw() comme spécification d'exception a été supprimée ;
- certaines fonctionnalités de la bibliothèque, auparavant obsolètes, ont été supprimées, notamment std::uncaught_exception, std::raw_storage_iterator, std::is_literal_type, std::is_literal_type_v, std::result_of et std::result_of_t.
Les fonctionnalités dépréciées incluent :
- l'utilisation de l'opérateur virgule dans les expressions en indice a été dépréciée ;
- (la plupart des) "volatile" a été dépréciée.
Prise en charge du compilateur
Les développeurs des principaux compilateurs se sont préparés à la norme C++ 20 en mettant en place un support expérimental pour diverses fonctionnalités des versions préliminaires du C++ 20.
- Clang dispose d'une prise en charge partielle du C++ 20 qui peut être activée avec l'option -std=c++20 (version 10 et ultérieure) ou -std=c++2a (version 9 et antérieure) ;
- EDG eccp a commencé à mettre en œuvre les fonctionnalités du C++20 dans la version 5.0 et, à partir de la version 6.1, prend en charge la plupart des fonctionnalités du langage de base du C++ 20 ;
- GCC a ajouté un support partiel et expérimental du C++ 20 en 2017 dans la version 8 grâce à l'option -std=c++2a. Comme Clang, GCC a remplacé cette option par -std=c++20 dans la version 10. Il dispose également d'une option permettant d'activer les extensions GNU en plus du support C++ 20 expérimental, -std=gnu++20 ;
- Microsoft Visual Studio prend en charge certaines fonctionnalités du C++ 20 grâce à son option std:c++latest. Une option /std:c++20 permettant d'activer le mode C++ 20 est prévue dès que le compilateur aura terminé la fonctionnalité C++ 20.
Sources : Cppreference, ISO/CEI 14882:2020
Et vous ?
:fleche: Que pensez-vous de la nouvelle norme du langage C++ 20 ?
:fleche: Quelles fonctionnalités du C++ 20 attisent le plus votre curiosité ? Pourquoi ?
Voir aussi
:fleche: Le comité ISO C++ a proposé une feuille de route pour C++ 23 et finalisé la nouvelle version du langage C++ 20, la norme devrait être publiée dans les mois à venir
:fleche: 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
:fleche: 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
