Évolution de C++ – quelques liens

De manière générale, si vous souhaitez obtenir la plus récente version d'un document, vous pouvez utiliser l'adresse raccourcie wg21.link à titre d'URL. Par exemple, pour un hypothétique document p0123, allez à l'adresse wg21.link/p0123 à l'aide d'un fureteur de votre choix.

Pour une révision particulière, ajoutez ce numéro à votre adresse raccourcie (p. ex. : wg21.link/p0123r4 pour la révision 4 de cet hypothétique document)

Depuis l'avènement de C++ 11, le comité de standardisation de C++ avance à toute vapeur. Cette page suit (quand j'en ai le temps) les derniers développements et les dernières discussions sur le sujet.

Les discussions sont déjà en cours pour déterminer ce que contiendra le prochain standard du langage, probablement C++ 17.

Au moment d'écrire ces lignes, le standard de C++ est C++ 14, une révision technique de C++ 11. Le prochain standard majeur attendu devrait être C++ 17.

Quelques raccourcis dans le présent document :

Généralités

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Raffinement des formulations pour certaines conversions contextuelles Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3323.pdf 2012Plusieurs petits éclaircissements au standard Adopté
Simplifications des règles ADL Peter Gottschling et associés http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3595.pdf 2013  
static_if Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3322.pdf 2013Le langage D offre quelque chose de semblable 
static_if Bjarne Stroustrup, Gabriel Dos Reis et Andrew Sutton http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3613.pdf 2013Selon eux, il serait catastrophique de poursuivre cette avenue Rejeté
Résurrection de static_if dans une version restreinte Ville Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4461.html 2015  
Ajouter constexpr_if Ville Voutilainen http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0128r0.html 2015  
Ajouter constexpr if Ville Voutilainen et Daveed Vandevoorde http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0128r1.html 2016On passe d'un nouveau mot clé à une combinaison du mot if et de la mention constexpr  
Ajouter if constexpr Jens Maurer 2016Ajustement syntaxique aux propositions antérieures sur le sujet, pour atteindre le même objectif mais de manière moins laborieuse quand la situation se complique Adopté
Réaliser une sélective efficace sur la base de types Yuriy Solodkyy, Gabriel Dos Reis et Bjarne Stroustrup http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3449.pdf 2012  
Changer le type de l'opérateur « adresse de »David Rodriguez http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3772.pdf2013 La surcharge de cet opérateur est une chose périlleuse, mais contraindre avec précision le comportement attendu est une chose subtile, en particulier pour ce qui est de saisir l'adresse d'un membre d'instance 
Ajouter des éléments au langage pour définir un métalangage statique distinctNémeth Péter http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3883.html 2014 Proposition quand même radicale, mais intrigante. Elle dépend fortement de constexpr et de liens avec les structures intermédiaires du compilateur 
Enrichier les assert pour couvrir des cas que les assert classiques ne couvrent pasOlaf van der Spek http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3500.htm 2013   
Améliorer static_assert Walter E. Brown 2014 L'idée serait de générer un littéral explicatif par défaut lorsqu'un static_assert échoue 
Accroître la flexibilité des messages d'un static_assert Michael Price http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4433.html 2015   
Supprimer les trigraphes du langage Richard Smith 2014 Révision mineureAdopté
À propos des conséquences d'une suppression des trigraphes du langage Michael Wong et plusieurs autres http://isocpp.org/files/papers/N4210.pdf 2014 Dans le marché très vaste d'IBM, la suppression des trigraphes du langage entraîne beaucoup de conséquences déplaisantes. Cette « proposition » discute des impacts en question 
Tester les nouvelles particularités du langage Clark Nelson 2014, 2015, 2016 Initialement, une macro par caractéristique, puis une macro représentant un prédicat statique, soit __has_includeAdopté
Supprimer le mot clé register, déjà déprécié, du standard Alisdair Meredith 2015 Le mot demeure réservé pour usage futurAdopté
Réflexions sur ce que devrait être C++ 17 Bjarne Stroustrup http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4492.pdf 2015   
Le texte de C++ 17 devrait faire référence à C11, pas à C99 Hans Boehm et Clark Nelson 2015, 2016 Voir http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3631.pdf par Thomas Plum pour des détails sur les impacts de ce changement Adopté
Le texte de C++ 17 devrait faire référence à ISO/IEC 10646 2014 plutôt que 1994 Beman Dawes 2016 Ce standard réfère à la transformation des caractères multibytes 
Supprimer les dépendances envers le langage C du texte sur la gestion de signaux Hans Boehm 2016   
Ajuster les passages qui chevauchent ceux du standard C Thomas Köppe et Richard Smith 2016  Adopté
Déprécier plusieurs outils quelque peu dépassés de la bibliothèque standard Alisdair Meredith 2016 Cette proposition vise std::iterator, quelques membres redondants des allocateurs, la spécialisation partielle vector<bool> (un bon type mal nommé), etc. Adopté
Standardiser un système de paquetageGuy Somberg et Brian Fitzgerald http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0235r0.pdf 2016   
Permettre une déclaration a priori d'une classe imbriquée dans une classe dont on n'a pas vu la définitionMatt Austern http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0289r0.pdf 2016 Permettre d'écrire ceci :
class A;
class A::B;
 
À propos du bon usage du terme Literal Type dans la bibliothèque standard Erich Keane http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0503r0.html 2016   
Clarifier l'ordre d'initialisation des membres d'un type non-classe Jens Maurer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0507r0.html 2016   

Annotations

Une annotation (en anglais : attribute) est une indication donnée au compilateur pour guider la génération du code, mais avec la restriction que sa présence ou son absence ne peut affecter le bon comportement du programme.

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajout d'une annotation [[deprecated]]Alberto Ganesh Barbati http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3760.html2013  
Ajout d'une annotation [[pure]] Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3744.pdf2013 Le langage D offre quelque chose de semblable
Ajout d'une annotation [[pure]] (suivi) Karl-Étienne Perron http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0078r0.pdf2015   
Permettre d'appliquer une annotation telle que [[deprecated]] aux espaces nommés et aux énumérations Richard Smith http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4196.html 2014   
Appliquer l'annotation [[noreturn]] pour indiquer qu'on ne souhaite pas que les destructeurs des objets globaux soient appelés Diego Diaz, Emanuel Bringas, Jens Maurer et Daniel Gutson http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4226.pdf2014 La subtilité est que main() est int, alors que [[noreturn]] se limite traditionnellement aux fonctions void Rejeté (semble qu'il aurait fallu tordre certains éditeurs de liens pour arriver à en profiter)
Permettre d'ajouter l'annotation [[noexit]] à main() Jens Maurer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4357.html2015 Corrigerai l'irritant relié à n4226
Appliquer des annotations aux énumérations et aux espaces nommés Richard Smith http://isocpp.org/files/papers/n4266.html 2014  Adopté
Ajouter des annotations pour spécifier des préconditions contractuelles Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4435.pdf 2015 Permettrait par exemple d'exprimer [[pre:is_sorted(deb,fin)]] si un algorithme comme std::unique() n'a de sens que sur une séquence triée a priori 
Permettre de tester la présence ou l'absence d'annotations sur une entité à l'aide du préprocesseur Clark Nelson et Richard Smith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4535.html 2015 On écrirait par exemple #if __has(pure) pour détecter [[pure]] 
Faciliter l'utilisation d'annotations non-standardsJ. Daniel Garcia, Luis M. Sanchez, Massimo Torquati, Marco Danelutto et Peter Sommerlad 2015, 2016  
Faciliter l'utilisation d'annotations non-standardsJ. Daniel Garcia et Daveed Vandevoorde 2016 Travail d'ordre terminologiqueAdopté
À propos des annotations standards, non-standards et de leur interaction avec les espaces nommés J. Daniel Garcia 2016  Adopté
À propos des annotations standards, non-standards et de leur interaction avec les espaces nommés J. Daniel Garcia 2016 Nouvelle version proposée du fait que la version précédente fut rejetée  
Ajout des annotations [[fallthrough]], [[nodiscard]] et [[unused]] Andrew Tomazos http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0068r0.pdf 2015 Le [[fallthrough]] permettrait au compilateur de savoir que l'omission d'un break; dans une sélective est volontaire. Le [[unused]] permettrait de savoir que la non-utilisation d'une variable est volontaire. Le [[nodiscard]] permettrait d'informer le compilateur que la valeur retournée par une fonction ne devrait pas être négligée. Ce sont donc des mécanismes qui se veulent portables pour intervenir dans le processus d'avertissements du compilateur 
Texte pour l'annotation [[fallthrough]] Andrew Tomazos 2016  Adopté
Texte pour l'annotation [[nodiscard]] Andrew Tomazos 2016  Adopté
Texte pour l'annotation [[maybe_unused]] Andrew Tomazos 2016  Adopté
Ajout d'un attribut [[visible]]Antony Polukhin http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0276r0.html 2016 Vise à remplacer les manoeuvres reposant habituellement sur des macros et permettant de contrôler la visibilité des éléments exportés (ou non) d'une bibliothèque à liens dynamiques  
Ajout d'un attribut [[exhaustive]] David Sankel http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0375r0.html 2016 Vise à indiquer que les valeurs correctes pour un type énuméré se limitent à celles listées dans l'énumération (ce qui n'est pas toujours vrai en pratique, par exemple dans les cas où des valeurs énumérées représentent les bornes d'un intervalle) 
Ajout d'attributs [[likely]] et [[unlikely]] Clay Trychta http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0479r0.html 2016 Inspirés de likely(x) et unlikely(x) comme les implémente gcc. Ceci serait une première étape dans un effort de clarification des intensions d'optimisation mené par SG14 

Modules

Les modules sont un élément important pour le futur de C++. Sur la table depuis au moins C++ 11, l'idée et de modifier le modèle traditionnel d'inclusions lexicales de fichiers d'en-tête, hérité du langage C, par un système de composants compilés exposant leurs interfaces d'une manière plus efficiente. Par cela, nous souhaitons collectivement en arriver à des temps de compilation plus courts.

Proposeur(s) URLAnnéeRemarquesVerdict?
Daveed Vandevoorde 2007, 2012  
Douglas Gregor http://llvm.org/devmtg/2012-11/Gregor-Modules.pdf 2012Présentation du concept 
Gabriel Dos Reis, Mark Hall et Gor Nishanov 2014, 2015, 2016Approche basée sur le point de vue qu'ont les programmeuses et les programmeurs des modules. Le document est soutenu par une analytique très riche du problème du modèle traditionnel de compilation du langage C lorsqu'il est appliqué à des programmes C++ contemporains 
Gabriel Dos Reis 2015Analyse de la pertinence des modules, et indications pour une éventuelle transition du modèle d'inclusion lexicale vers ce nouveau modèle 
Gabriel Dos Reis 2015, 2016Questions de terminologie 
Richard Smith, Chandler Carruth et David Jones 2016Propositions de changement à la proposition sur la table, en se basant sur de l'expérience concrète. Explique entre autres choses l'intérêt d'exposer des macros à travers les frontières des modules 
Gabriel Dos Reis et Pavel Curtis http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0141r0.pdf 2016Analyse des décisions de design qu'implique un système de modules. Concrètement, ce document présente une perspective sur les points divisifs des deux principales implémentations des modules en compétition 
Gabriel Dos Reis http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0500r0.pdf 2016Résolution proposée pour quelques irritant soulevés à propos de la spécification technique sur les modules 
Richard Smith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0529r0.pdf 2016Proposition de raffinements terminologiques, incluant les mots implementation et partition 

Multiprogrammation

Plusieurs sous-catégories. Notez que deux groupes de travail ont été formés pour adresser ces questions de manière plus globale, soit un sur le parallélisme et l'autre sur la concurrence. Leurs rapports sont disponibles ci-dessous (le plus récent est la la fin).

Spécification technique, extensions pour le parallélisme Spécification technique, extensions pour la concurrence

Il existe d'autres documents, mais ceux-ci ne sont pas tous exposés au grand public. Les spécifications techniques sur le parallélisme sont principalement sous la responsabilité de Jared Hoberock. Les spécifications techniques sur la concurrence sont principalement sous la responsabilité d'Artur Laksberg.

Généralités

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Cas d'utilisation pour la mémoire locale aux threads Paul E. McKenney 2014, 2015 Il existe des irritants dans la jonction entre ce type de mémoire et la programmation de GPU par exemple 
Cas d'utilisation pour la mémoire locale aux threads (suivi) Paul E. McKenney, JF Bastien, Pablo Halpern, Michael Wong, Thomas Richard William et Robert Geva http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0097r0.html2015   
Une formalisation du vocabulaire associé à la multiprogrammation Torvald Riegel http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4231.pdf 2014  
Une critique du modèle mémoire de C++ Mark Batty, Kayvan Memarian, Kyndylan Nienhuis, Jean Pichon et Peter Sewell http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4136.pdf 2014  
Le modèle mémoire de Linux Paul E. McKenney 2014, 2015  
Le modèle mémoire de Linux (suivi) Paul E. McKenney et Ulrich Weigand http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0124r0.html 2015  
Le modèle mémoire de Linux (suivi) Paul E. McKenney, Ulrich Weigand et Andrea Parri http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0124r1.html 2016  
Le modèle mémoire de Linux (suivi) Paul E. McKenney, Ulrich Weigand, Andrea Parri et Boqun Feng http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0124r2.html 2016  
Le Read-Copy-Update (RCU) pour C++ Paul E. McKenney 2015, 2016  
Proposition d'API en vue d'un support du Read-Copy-Update (RCU) pour C++ Paul E. McKenney, Maged Michael, Michael Wong, Isabella Muerte et Arthur O'Dwyer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0461r0.pdf 2016  
Il est temps de standardiser la spécification technique sur le parallélisme Jared Hoberock 2015, 2016 Adopté
Des threads qui font un join() sur destruction lorsqu'ils sont encore joinable() Ville Voutilainen 2016Ajout d'un type joining_thread  
Le type joining_thread est une mauvaise idée Detlef Vollmann http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0379r0.html 2016Il y a un risque d'interblocage si une exception est levée  
Intégrer HPX au standard pour le parallélisme massif hétérogène Michael Wong, Hartmut Kaiser et Thomas Heller http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0234r0.pdf 2016Fruit des travaux de SG14 
Intégrer OpenCL SYCL au standard pour le support à la programmation d'appareils hétérogènes Michael Wong, Andrew Richards, Maria Rovatsou et Ruyman Reyes http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0236r0.pdf 2016Fruit des travaux de SG14 
Raffiner le texte décrivant l'initialisation des threads Hans Boehm 2016Vise surtout la clarification des règles portant sur l'ordonnancement des opérations. Plusieurs questions sont en suspens, par exemple le droit (ou non) d'une implémentation à exécuter les constructeurs des variables globales en parallèle 
Définitions de base pour décrire le progrès (Forward Progress) d'un algorithme parallèle Torvald Riegel 2016Surtout utile dans le cas d'exécutions sans verrous Adopté
Garanties offertes par la bibliothèque standard quant au progrès (Forward Progress) d'un algorithme parallèle Torvald Riegel 2016 Adopté
Contrôler les caractéristiques des threads à la construction, le type thread::attributesVicente J. Botet Escribá 2016Touche aux préoccupations de SG14 
Enrichir un éventuel type thread::attributes d'une fonction de fabrication make_thread() Patrice Roy, Billy Baker et Arthur O'Dwyer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0484r0.pdf 2016 L'idée est de permettre au code client de savoir à quel point ses requêtes ont été desservies, même dans le cas où celui-ci n'a pas recours aux exceptions 
Une classe std::accessor pour contrôler les modalités d'accès à un objetRonan Keryell et Joël Falcou http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0367r0.pdf 2016L'idée est de mieux utiliser les capacités d'architectures atypiques 
Problèmes avec le modèle mémoire existant en lien avec la conception de structures de données concurrentes Hans Boehm http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0387r0.html 2016Réflexion née de la difficulté de concevoir certaines structures de données concurrentes standards (compteurs concurrents, file concurrente) dans le contexte du modèle mémoire de C++ 14  
Faire en sorte que la levée d'une exception lors de l'exécution d'un algorithme parallèle entraîne un appel à std::terminate()JF Bastien et Bryce Adelstein Lelbach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0394r4.html 2016  Adopté
Préparer la gestion des exceptions dans les algorithmes parallèles en vue du futurBryce Adelstein Lelbach et Alisdair Meredith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0451r0.html 2016Pour ouvrir la porte à des alternatives à std::terminate() lors d'une levée d'exception, l'idée serait d'insérer un point de personnalisation, probablement dans les exécuteurs  
Comment bien faire se terminer un algorithme parallèle échouant dû à une levée d'exception?JF Bastien, Bryce Adelstein Lelbach et H. Carter Edwards http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0502r0.html 2016   
Comment spécifier les garanties en lien avec la concurrence pour une structure de données concurrente Lawrence Crowl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0495r0.html 2016Document de nature exploratoire, qui pose des questions  

Algorithmes

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Working Draft spécifiant les extensions prévues pour le parallélisme avec C++ Jared Hoberock http://isocpp.org/files/papers/n3850.pdf2014   
Un std::exchange() pour standardiser et rendre plus génériques certaines opérations sur des types atomiques Jeffrey Yasskin 2013  
Enrichir la STL par des versions parallèles de la plupart des algorithmes standards (simple mais brillant)Collectif d'auteurs http://isocpp.org/files/papers/n3554.pdf 2013  
Enrichir la STL par des versions parallèles de la plupart des algorithmes standards (raffinement)Plusieurs personnes (d'Intel, de NVidia et de Microsoft), incluant Herb Sutter http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3724.pdf 2013  
Bibliothèque d'algorithmes de type Fork-Join inspirée de CilkPablo Halpern http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3557.pdf 2013  
Standardiser les algorithmes Map/ ReduceChris Mysen, Lawrence Crowl et Adam Berkan http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3563.pdf 2013  
Ajouter un algorithme Transform ReduceGrant Mercer, Agustín Bergé et Hartmut Kaiser http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4167.pdf 2014  
Ajout d'algorithmes fusionnels à la spécification technique de parallélismeJared Hoberock https://isocpp.org/files/papers/n4276.pdf 2014On parle des algorithmes transform_reduce(), transform_exclusive_scan() et transform_inclusive_scan()Adopté
Les algorithmes parallèles ont besoin d'un exécuteurJared Hoberock, Michael Garland et Olivier Girioux 2015, 2016  
Psoposition unifiée d'exécuteursJared Hoberock, Michael Garland, Chris Kohlhoff, Chris Mysen et Carter Edwards, avec beaucoup d'autres contributeurs http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0443r0.html 2016  
Les compilateurs optimisent-ils les atomiques? Semble que oui... J.F. Bastien http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4455.html 2015  
Quand un compilateur pourrait-il avoir le droit d'optimiser une atomique? Hans Boehm avec plusieurs collaborateurs 2015, 2016  
Copier une atomique devrait-il être trivial? Semble que non... Ville Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4460.html 2015  
Appliquer la syntaxe du π-calcul aux exécuteurs Cleiton Santoia Silva http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4464.pdf 2015  
Ajouter un type atomic_view H. Carter Edwards et plusieurs autres 2015, 2016Pour faciliter le recours aux opérations atomiques sur des types non-atomiques (pas sur n'importe quel type cependant : la proposition vise des types T pour lesquels atomic<T> est viable)  
Ajouter des types atomiques pour des nombres à virgule flottante H. Carter Edwards et plusieurs autres 2015, 2016  
Un atomic_view pour nombres à virgule flottante H. Carter Edwards et plusieurs autres 2016Joindre les propositions P0019 et P0020 
Une bibliothèque générique pour des répétitives à base d'indices Arch D. Robison, Pablo Halpern, Robert Geva et Clark Nelson 2015, 2016  
Ajout de nouvelles politiques d'exécution parallèleArch D. Robison, Pablo Halpern, Robert Geva et Clark Nelson http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0076r0.pdf 2015  
Ajout de nouvelles politiques d'exécution parallèle (suivi)Arch D. Robison, Pablo Halpern, Robert Geva, Clark Nelson et Jens Maurer 2016  
Mieux nommer les politiques d'exécution parallèlePablo Halpern 2016 Adopté
Mettre à jour les noms des politiques d'exécution parallèle dans le TS sur le parallélismePablo Halpern 2016Il se trouve que malgré l'adoption de P0366, les noms dans la spécification demeurent inchangées dû aux règles des processus de standardisation ISO 
Raffiner la gestion d'exceptions dans les algorithmes parallèlesBryce Adelstein Lelbach http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0333r0.html 2016Entre autres, on n'a pas nécessairement à appeler std::terminate() dans plusieurs cas 
Des Context Tokens pour les algorithmes parallèles Pablo Halpern http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0335r0.pdf 2016Mécanisme novateur pour informer, de manière optionnelle, une fonction du contexte algortihmique de son exécution. C'est très joli 
Enrichir les algorithmes parallèles d'implémentations standards de techniques reposant sur des flux de données J. Daniel Garcia et plusieurs autres http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0374r0.pdf 2016  
Préciser le concept de force relative des modalités d'opération sur les atomiques JF Bastien et Hans Boehm 2016  
L'algorithme parallèle manquant, transform_reduce() Bryce Adelstein Lelbach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0452r0.html 2016Une unification des algorithmes inner_product() et transform_reduce()  
Préoccupations envers les itérateurs dans les algorithmes parallèles Alisdair Meredith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0467r0.html 2016Les spécifications existantes semblent insuffisantes, en particulier pour ce qui a trait aux catégories d'itérateurs  
Offrir une version atomique de min() et de max()Al Grant et Bronek Kozicki http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0493r0.pdf 2016   
Enrichir std::atomic_flag pour permettre d'attendre sur une variable de ce typeOlivier Giroux http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0514r0.pdf 2016   
Clarifier la complexité algorithmique d'algorithmes parallèlesDetlef Vollmann http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0523r0.html 2016   
Interaction entre atomiques de bits de paddingJF Bastien et Michael Spencer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0528r0.html 2016Les bits qui ne participent pas à la représentation d'un objet ne sont pas préservés par un Copy-and-Swap  

Asynchronisme

Notez que les textes sur les coroutines, de même que ceux sur les fonctions « résumbles », ont été logés dans un document à part entière : ../Sujets/Parallelisme/coroutine.html

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Regroupements de threads Chris Mysen et Niklas Gustafsson http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3731.pdf 2013Exécuteurs 
Agents légersTorvald Riegel 2014, 2015, 2016  
Ajouter des fibres à C++ Oliver Kowalke et Nat Godspeed http://isocpp.org/files/papers/n4024.pdf 2014  
Threads mutables (donc non immuables), capables d'exécuter plus d'une fonctionChris Mysen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3356.html 2012  
Paire de propositions touchant directement la standardisation des pratiques en lien avec les futures, au sens d'appels asynchrones, et de la capacité d'interrompre puis de reprendre un traitementNiklas Gustafsson et Artur Laksberg http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3327.pdf
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3328.pdf		 2012  
Raffinements proposés pour les futuresVicente J. Botet Escribá 2014  
Ajouter des fonctions d'emplacement à promise<T> et à future<T>Vicente J. Botet Escribá http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0319r0.pdf 2016  
Standardiser la représentation des opérations asynchronesNiklas Gustafsson, Artur Laksberg, Herb Sutter et Sana Mithani 2013, 2014Raffinement non-bloquant aux std::future  
La question des destructeurs des std::future et des std::thread associés à des std::async() Herb Sutter http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3630.pdf 2013En particulier, devraient-ils bloquer par défaut jusqu'à la complétion du thread sous-jacent? Les avis sont partagés  
Le destructeur de std::thread Herb Sutter http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3636.pdf 2013   
Le destructeur de std::future Herb Sutter, Chandler Carruth et Niklas Gustafsson 2013   
Le destructeur de std::future Hans Boehm http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3679.html 2013  
Le destructeur de std::future (mise à jour) Herb Sutter http://isocpp.org/files/papers/N3776.pdf2013  Adopté
Déprécier std::async() serait la pire de toutes les options Nicolai M. Josuttis http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3780.pdf 2013  
Nouvelles politiques de lancement pour les std::async() Peter Dimov http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3632.html 2013  
Réflexion sur un modèle général d'asynchronismeChristopher Kohlhoff http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3747.pdf 2013  
Proposition de bibliothèque pour opérations asynchrones Christopher Kohlhoff 2014Sorte de plaidoyer pour les fonctions de rappel, ou Callbacks, et de critique des futures 
Réflexion sur le parallélisme de type fork/ join Arch Robinson http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3872.pdf 2014  
Critique partielle d'un modèle reposant sur des executeurs et des continuations, tel que préconisé par le groupe de travail sur la multiprogrammation Anthony Williams http://isocpp.org/files/papers/n4032.html 2014Fruit de tests empiriques réalisés par l'auteur 
Des std::promise trop attachées (à leur état partagé)Agustín K.-Ballo Bergé et Hartmut Kaiser http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4445.html 2015  
Ajout de politiques pour faciliter l'invocation asynchrone d'algorithmes Hartmut Kaiser, Thomas Heller et Michael Wong http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0361r0.pdf 2016  
Ajout de politiques pour faciliter l'invocation asynchrone d'algorithmes Hartmut Kaiser, Thomas Heller, Bryce Adelstein Lelbach, John Biddiscombe et Michael Wong http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0361r1.pdf 2016  
Clarifier les règles quant aux préconditions des shared_futureBryce Adelstein Lelbach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0516r0.html 2016  
Ajouter un constructeur à future_errorBryce Adelstein Lelbach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0517r0.html 2016A priori, ce contructeur est marqué « pour exposition seulement », mais l'auteur est d'avis que cela ne suffise pas  

Calculs à haute performance

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Améliorer l'intégration avec OpenMPDarryl Gove, Nawal Copty et Michael Wong http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3530.pdf 2013  
Réflexion sur les données Thread-Local dans un algorithme X-Parallèle, ou parallèle sur plusieurs types de processeursPablo Halpern et Charles E. Leiserson http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3556.pdf 2013  
Algorithmes vectorielsRobert Geva et Clark Nelson http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3561.pdf 2013  
Algorithmes SIMDPierre Estérie, Mathias Gaunard et Joel Falcou http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3571.pdf 2013  
Types vectoriels pour calculs SIMD Matthias Kretz 2013, 2014  
Types « masques »pour calculs SIMD Matthias Kretz http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4185.pdf 2014  
Types vectoriels pour calculs SIMD, considérations pour l'ABI Matthias Kretz 2015, 2016  
À propos de la taille des datapar dans les calculs SIMD Matthias Kretz http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0349r0.pdf 2016  
Intégration des datapar avec les algorithmes parallèles et les exécuteurs Matthias Kretz http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0350r0.pdf 2016  
Présentation sur la programmation vectorielleRobert Geva http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3734.pdf 2013  
Distinguer répétitives vectorielles et répétitives parallèles Robert Geva http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3735.pdf 2013  
Proposition d'extensions au langage pour tenir compte du calcul vectoriel Robert Geva et Clark Nelson 2014  
Proposition d'extensions au langage pour tenir compte du calcul vectoriel (suite) Arch D. Robison, Pablo Halpern et Robert Geva http://isocpp.org/files/papers/n4008.pdf 2014  
Modifications à vector_execution_policy Pablo Halpern http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n4060.pdf 2014En lien avec les calculs vectoriels; certains cas d'utilisation pertinents permettent de croire que des ajustements au standard proposé seraient avantageux. En particulier, met en relief l'importance de distinguer « calcul vectoriel » et « calcul parallèle » pour tirer le maximum de chacun  
Un modèle abstrait de calcul vectoriel Pablo Halpern http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4238.pdf 2014Plus un document de réflexion qu'une proposition formelle  
Début d'approche pour la mémoire Thread-Local Paul E. McKenney et JF Bastien 2015, 2016   
État des travaux sur la vectorisation en C++ JF Bastien et Hans Boehm 2016   
À propos du design de vecteur SIMD portables Matthias Gaunard http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0203r0.html 2016   

Mémoire transactionnelle

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Mémoire transactionnelle Hans Boehm et plusieurs autres 2012, 2013  
Mémoire transactionnelle (sémantique d'une annulation de transaction) Hans Boehm et plusieurs autres http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3591.pdf 2013  
Mémoire transactionnelle (sémantique alternative pour annulation de transaction)Torvald Riegel http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3592.html 2013  
Mémoire transactionnelle (mise à jour)Victor Luchangco, Jens Maurer, Mark Moir et plusieurs autres http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3718.pdf 2013  
Mémoire transactionnelle (mise à jour) Hans Boehm et plusieurs autres http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3859.pdf 2014  
Mémoire transactionnelle (description du modèle préconisé)Plusieurs personnes (Michael Wong est leur répondant) http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3725.pdf 2013  
Cas d'espèce d'une liste (std::list) qui soit Transaction-Safe Un grand groupe de personnes http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3862.pdf 2014  
Formalisme de l'énoncé en vue du standatrd pour une liste (std::list) qui soit Transaction-Safe Plusieurs personnes (Michael Wong est leur répondant) http://isocpp.org/files/papers/n4000.pdf 2014  
Mémoire transactionnelle (mise à jour) Victor Luchangco, Jens Maurer, Mark Moir et plusieurs autres http://isocpp.org/files/papers/N3919.pdf 2014  
Mémoire transactionnelle (formulation) Victor Luchangco, Jens Maurer, Michael Wong et plusieurs autres http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3999.pdf 2014  
Mémoire transactionnelle (Working Draft) Michael Wong 2014, 2015  
Mémoire transactionnelle (formulation) Jens Maurer, Hans Boehm, Justin Gottschlich et plusieurs autres http://isocpp.org/files/papers/n4265.html 2014  
Mémoire transactionnelle, suivi Michael Wong, Victor Luchangco, Hans Boehm et plusieurs autres http://isocpp.org/files/papers/n4180.pdf 2014  
Mémoire transactionnelle, spécifications techniques des extensions au langage Michael Wong (je pense) http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4302.pdf 2014  
Opérations atomiques sur un très gros tableau Carter Edwards http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4142.pdf 2014L'auteur propose un type atomic_array<T> approprié pour des calculs « à haute performance » 
Opérations atomiques sur un très gros tableau (suivi) Carter Edwards et Hans Boehm http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4373.pdf 2015  
Expérience concrète Brett Hall http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4438.pdf 2015  
Élargir la spécification technique pour tenir compte des actions commitVictor Luchangco, Michael Spear, Michael Wong et plusieurs autres http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0231r0.pdf 2016  
La mémoire transactionnelle n'est pas proposée pour C++ 17 Michael Wong et plusieurs autres http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0265r0.pdf 2016Une spécification technique serait plus appropriée à ce stade  
Élargir la spécification technique pour ajouter un énoncé in_transaction Victor Luchangco, Michael Spear, Michael Wong et plusieurs autres http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0366r0.pdf 2016L'idée est de permettre au code de distinguer le comportement à prendre selon le contexte (suis-je dans une transaction ou non?)  

Parallélisme par tâches

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Objets exécuteursMatt Austern, Lawrence Crowl, Chandler Carruth, Niklas Gustafsson, Chris Mysen et Jeffrey Yasskin http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3562.pdf 2013  
Objets exécuteurs (suivi)Chris Mysen, Niklas Gustafsson, Matt Austern et Jeffrey Yasskin http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3785.pdf 2013  
Objets exécuteurs (suivi)Chris Mysen 2014, 2015  
Objets exécuteurs (suivi)Christopher Kohlhoff 2014, 2015  
Unifier les objets exécuteurs à travers des points de personnalisationChristopher Kohlhoff http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0285r0.html 2016  
Groupes de tâches, ou task_group (suivi) Artur Laksberg et Herb Sutter http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3711.pdf2013   
Groupes de tâches, ou task_group (suivi) Pablo Halpern, Arch Robison, Hong Hong, Artur Laksberg, Gor Nishanov et Herb Sutter 2014   
Ajout d'un task_regionPablo Halpern, Arch Robison, Hong Hong, Artur Laksberg, Gor Nishanov et Herb Sutter http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n4088.pdf 2014 Enrichissement du concept de task_group 
Ajout d'un task_block en remplacement d'une task_region (suivi)Pablo Halpern, Arch Robison, Hong Hong, Artur Laksberg, Gor Nishanov et Herb Sutter 2015  Adopté
Déterminer un exécuteur par défautAdam Berkan, Chris Mysen et Hans Boehm http://isocpp.org/files/papers/n4039.html2014 Texte qui présente des options et disserte sur leurs forces et leurs faiblesses, sans statuer 

Synchronisation, communication et conteneurs

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Flux synchronisés à l'aide de mutex spéciaux Lawrence Crowl 2012, 2013  
Proposition d'un ostream_buffer Lawrence Crowl 2013, 2014Suite à un consensus du comité de standardisation à l'effet que le recours explicite à des tampons serait préférable 
Proposition d'un ostream_buffer (suivi) Lawrence Crowl et Peter Sommerlad 2014   
Proposition d'un ostream_buffer (suivi), qui devient un <syncstream> Lawrence Crowl, Peter Sommerlad et Nicolai M. Josuttis 2015, 2016   
Files sécurisées lors d'accès concurrents Lawrence Crowl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3353.html 2012  
Files sécurisées lors d'accès concurrents (raffinements) Lawrence Crowl et Chris Mysen http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3533.html 2013  
Conteneurs concurrents non-ordonnancés avec interface orientée valeurs Arch D. Robison, Anton Potapov et Anton Malakhov http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3732.pdf 2013  
Politiques de destruction pour conteneurs concurrentsArch D. Robison http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3712.pdf 2013  
Synchronisation par mutex partagés, permettant par exemple une lecture concurrente sur un objet protégé par synchronisation Howard E. Hinnant http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3568.html 2013  
Synchronisation par mutex partagés, permettant par exemple une lecture concurrente sur un objet protégé par synchronisation (raffinements) Howard E. Hinnant, Detlef Vollmann et Hans Boehm http://isocpp.org/files/papers/N3659.html2013  Adopté
Synchronisation par mutex partagés, permettant par exemple une lecture concurrente sur un objet protégé par synchronisation (ajustements de nomenclature) Gor Nishanov et Herb Sutter http://isocpp.org/files/papers/N3891.htm2014 Le nom shared_mutex a été remplacé par shared_timed_mutexAdopté
Synchronisation par mutex partagés, permettant par exemple une lecture concurrente sur un objet protégé par synchronisation Gor Nishanov 2014, 2015 Un shared_mutex, version untimed du shared_timed_mutexAdopté
Multiprogrammation et passage d'information par pipelineAdam Berkan et Alasdair Mackintosh http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3534.html 2013  
Compteurs répartis, optimisés pour l'écriture (en particulier pour l'incrémentation) tout en acceptant une pénalité lors de la consultation Lawrence Crowl 2012, 2013, 2016  
Que peut-on faire lors du traitement d'un signal? (suivi) Hans Boehm 2013, 2014 Adopté
Proposition d'un type latch, objet à usage unique synchronisant plusieurs threads jusqu'à ce qu'une opération ait été réalisée, et d'un type barrier, objet réutilisable à l'effet analogue à celui du type latchAlasdair Mackintosh 2013  
Proposition d'un type latch, objet à usage unique synchronisant plusieurs threads jusqu'à ce qu'une opération ait été réalisée, et d'un type barrier, objet réutilisable à l'effet analogue à celui du type latch (suivi)Alasdair Mackintosh et Olivier Giroux 2014, 2015  
Complément au type latchAlasdair Mackintosh et Adam Berkan http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4224.html 2014  
Nouvelles primitives pour variables atomiquesBronek Kozicki http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3696.htm 2013Proposition de priority_update(), fetch_min() et fetch_max() 
Resserrer le comportement des atomiques « relaxées » Hans Boehm http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3710.html 2013  
Resserrer le comportement des atomiques « relaxées » (suivi) Hans Boehm http://isocpp.org/files/papers/n3786.htm 2013 Adopté
Clarification du concept d'être « sans verrous » Lawrence Crowl http://isocpp.org/files/papers/n3927.html 2014 Adopté
Mutex partagé sans minuterie Gor Nishanov http://isocpp.org/files/papers/N3961.htm 2014  
Ajout d'un type synchronized_value<T>, pour synchroniser les accès à une donnée d'un type T, quel que soit ce type Anthony Williams http://isocpp.org/files/papers/n4033.html 2014Repose sur un mécanisme intéressant de classe interne RAII (un update_guard<T>). Voir ../Sujets/Parallelisme/synchronized_value.html pour des détails 
Fonction apply() pour un synchronized_value<T> Anthony Williams 2016La fonction apply() serait variadique et permettrait d'appliquer en bloc une séquence d'opération de manière synchronisée sur le T dont l'accès est contrôlé par le synchronized_value<T> auquel est associé un update_guard<T> donné 
Offrir des opérations atomiques sur des données qui ne le sont pas Hans Boehm http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4013.html 2014  
Un algorithme pour déplacer des données de manière atomique d'un arbre à l'autre Paul E. McKenney http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4037.pdf 2014Texte proposé en réponse à un défi du comité de standardisation  
Des pointeurs intelligent atomiques Herb Sutter 2014   
Offrir un comportement portable pour la définition d'un atomic<T> par défaut J.F. Bastien et Olivier Giroux http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4130.pdf 2014Avec C++ 11, le constructeur par défaut d'un atomic<T> n'est pas supposé initialiser le T dans le cas où T est un POD, pour fins de compatibilité avec C, mais ceci crée des problèmes de portabilité, surtout si la structure interne de T n'est pas compacte  
Offrir des garanties plus claires à la compilation sur le caractère « sans verrou » ou non des types atomiques J.F. Bastien et Olivier Giroux http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4509.html 2015Essentiellement, propose un atomic<T>::is_always_lock_free() qui serait constexpr  
Offrir des garanties plus claires à la compilation sur le caractère « sans verrou » ou non des types atomiques (suite) Olivier Giroux, J.F. Bastien et Jeff Snyder 2015, 2016  Adopté
Ajout d'un type std::synchronic<T> pour faciliter l'expression de primitives de synchronisation maison qui soient correctesOlivier Giroux et H. Carter Edwards http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4195.pdf 2014Le type std::synchronic vise à faciliter l'attente de changements d'états sur des variables atomiques, en combinant des mécanismes locaux au processus et des mécanismes du système d'exploitation, à la manière des futex de Linux  
Ajout d'un type std::synchronic<T> pour faciliter l'expression de primitives de synchronisation maison qui soient correctes (suivi)Olivier Giroux, parfois avec Torvald Riegel et Jeffrey Yasskin 2015, 2016   
Préciser l'impact de memory_order_consume Paul E. McKenney, Torvald Riegel, Jeff Preshing, Hans Boehm, Clark Nelson, et Olivier Giroux 2014   
Préciser l'impact de memory_order_consume (suivi) Paul E. McKenney, Torvald Riegel, Jeff Preshing, Hans Boehm, Clark Nelson, Olivier Giroux, Lawrence Crowl et plusieurs autres 2015, 2016    
Construire un enchaînement de dépendances avec memory_order_consume Paul E. McKenney, Torvald Riegel, Jeff Preshing, Hans Boehm, Clark Nelson, Olivier Giroux, Lawrence Crowl, JF Bastien et Michael Wong http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0462r0.pdf 2016   
Une nouvelle (et meilleure) définition de memory_order_consume Paul E. McKenney, Michael Wong, Hans Boehm, Jens Maurer et plusieurs autres 2015, 2016    
Déprécier, du moins temporairement, memory_order_consume Hans Boehm 2016Le sens donné à cette modalité opératoire est sujet à changer, ce qui amène l'auteur à suggérer une période de dépréciation pour faciliter la transition vers un modèle plus utilisable. Ceci risque, à terme, d'affecter aussi [[carries_dependency]] et std::kill_dependency() Adopté
Insérer des valeurs « créées de nulle part » dans un programme, ce n'est pas gentil pour un modèle mémoire Paul E. McKenney, Alan Jeffrey et Ali Sezgin 2014, 2015   
Insérer des valeurs « créées de nulle part » dans un programme, ce n'est pas gentil pour un modèle mémoire (suivi) Paul E. McKenney, Alan Jeffrey, Ali Sezgin et Tony Tye http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0422r0.html2016 Texte très touffu  
Faire en sorte que lock_guard accepte des paramètres variadiques Mike Spertus 2015En chemin, le verrou variadique proposé est renommé scoped_lock pour éviter les bris d'ABI qui auraient résulté d'un changement d'implémentation à un type existant  
Ajouter un std::atomic_object_fence() Olivier Giroux et J.F. Bastien 2015   
Exposer les caractéristiques de la Cache de manière constexpr J. F. Bastien et Olivier Giroux 2015, 2016On parle de std::hardware_constructive_interference_size et std::hardware_destructive_interference_sizeAdopté
Étude comparative de diverses stratégies de synchronisation Paul E. McKenney, Michael Wong et Maged Michael http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0232r0.pdf 2016Compare RCU, les Hazard Pointers, le verrouillage par bloc, le verroulage global... 
Standardiser les Hazard PointersMaged Michael et  Michael Wong 2016  
Standardiser les Hazard PointersMaged Michael,  Michael Wong, Paul E. McKenney et Arthur O'Dwyer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0233r2.pdf 2016Outil pour faciliter la gestion de la réclamation post-utilisation des objets partagés en situation de concurrence optimiste, Single-Writer Multiple-Readers 
Une concurrent_queue Lawrence Crowl et Chris Mysen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0260r0.html 2016  
Faire de memory_order une énumération forte Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0439r0.html 2016On vise une syntaxe idiomatique de type memory_order::consume avec support des anciens noms (qui seraient éventuellement dépréciés) par des constantes globales constexpr  

Mathématiques

Propositions de nature mathématique.

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajout de littéraux binaires standards de manière primitive James Dennett http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3472.pdf 2012Préfixe 0b ou 0B, au choix Adopté
Support standardisé de l'arithmétique sur des nombres à virgule fixe Lawrence Crowl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3352.html 2012  
Entiers de taille arbitrairement grandePete Becker 2013, 2014  
Rationnels dynamiques Bill Seymour http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3611.html 2013  
Littéraux numériques plus lisiblesJens Maurer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3342.html 2012  
Littéraux numériques plus lisibles Lawrence Crowl 2013  
Littéraux numériques plus lisibles (suivi) Lawrence Crowl, Richard Smith, Jeff Snyder et Daveed Vandevoorde http://isocpp.org/files/papers/N3781.pdf 2013 Adopté
Nombres à virgule flottante décimauxDietmar Kühl 2012,
2014		  
Nombres à virgule flottante hexadécimauxThomas Köppe 2016 Adopté
Nombres à virgule flottante de précision fixée et conformes aux standards IEEE Paul A. Bristow, Christopher Kormanyos et John Maddock http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3626.pdf 2013Ceci n'est pas garanti par les standards de C et de C++  
Enrichir l'offre de fonctions mathématiques standardsVincent Reverdy http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3494.pdf 2013  
Enrichir l'offre de fonctions mathématiques standards Walter E. Brown 2013,
2015		  
Enrichir l'offre de fonctions mathématiques standards (suivi) Walter E. Brown, Axel Naumann et Edward Smith-Rowland 2016 Adopté
Implémentation standard du plus grand commun diviseur (PGCD) et du plus petit commun multiple (PPCM), sous la forme std::gcd() et std::lcm() Walter E. Brown 2014Les deux seraient qualifiés constexpr et offerts à même <cstdlib>  
Intégrer dès C++ 17 certains nouveaux éléments de la bibliothèque standard, sans passer par une spécification technique Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0295r0.pdf 2016Ne pas retarder les nouveaux std::lcm() et std::gcd() qui semblent prêts pour standardisation aux yeux de l'auteur  
Implémentations standards et qui soient constexpr de min() et de max() Gabriel Dos Reis http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3856.pdf 2014  
Bibliothèque d'opérations bit à bit standards qui soient constexpr Matthew Fioravante http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3864.html 2014  
Ajout d'une fonction standard abs_diff() (où ), très utile pour une vaste gamme d'algorithmes mais subtile à écrire correctement Jeremy Turnbull http://isocpp.org/files/papers/n4318.pdf 2014  
Les types des algorithmes std::accumulate() et std::inner_product() sont incorrectsVladimir Grigoriev http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4405.ht 2015  
Gérer les erreurs d'arrondi et de débordement selon une idiomatique de C++ plutôt que de C Lawrence Crowl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4448.html 2015  
Ajouter une version à trois paramètres de std::hypot()Benson Ma 2015 Adopté
Ajouter un type standard pour les nombres à virgule fixeJohn McFarlane 2015, 2016En lien direct avec les travaux de SG14 
Ajout de fonctions et de métafonctions globales pour manipuler les caractéristiques de précision des nombres à virgule fixe John McFarlane http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0381r0.html 2016  
Ajout de fonctions et de métafonctions globales pour manipuler les caractéristiques de précision des nombres à virgule fixe (suivi)John McFarlane et Michael Wong http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0381r1.html 2016  
Ajouter une fonction sincos()Paul Dreik http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0081r0.pdf 2015  
Comparaisons et précision Lawrence Crowl 2015, 2016  
Outils de base pour fins de comparaison numérique Lawrence Crowl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0474r0.html 2016  
Un aperçu de ce que sera la spécification officielle du groupe SG6 sur les calculs numériques Lawrence Crowl http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0101r0.html 2015  
Types numériques paramétriques Lawrence Crowl http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0102r0.html 2015On parle d'ajouts à <cstdint> et à <cstdfloat> 
Détection des débordements arithmétiques Lawrence Crowl http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0103r0.html 2015  
Opérations sur des entiers construits à partir de plusieurs mots mémoire Lawrence Crowl http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0104r0.html 2015  
Gestion des arrondissements et des débordements sur des nombres à virgule flottante Lawrence Crowl http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0105r0.html 2015  
Arithmétique à point fixe Lawrence Crowl http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0106r0.html 2015  
Nombres à virgule flottante courts (16 bits)Boris Fomichev, Sergei Nikolaev et Olivier Giroux 2016Nouveau type de données, short float, qui aurait un nombre surprenant d'applications 
Ajout de types safe<T> pour l'arithmétique évitant les débordementsRobert Ramey http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0228r0.pdf 2016  
Ajouter des outils de manipulation de bitsVincent Reverdy et Robert J. Brunner

 

 2016On parle de bit_reference, bit_pointer et bit_iterator 
Ajouter des outils de manipulation de bitsVincent Reverdy, Robert J. Brunner et Nathan Myers http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0237r2.html 2016On parle de bit_reference, bit_pointer et bit_iterator 
Appliquer constexpr à std::complexAntony Polukhin http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0415r0.html 2016  

Gestion de la mémoire

Thème riche, avec quelques catégories plus spécifiiques.

Gestion de la mémoire (considérations générales)

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Clarifier la formulation du standard Lawrence Crowl et Chandler Carruth http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3537.html 2013  
Clarifier la formulation du standard (suivi) Lawrence Crowl, Chandler Carruth et Richard Smith http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3664.html 2013 Adopté
Permettre de restreindre le contexte d'un appel à newNikhil Joshi http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3348.pdf 2012  
Opérateur delete conscient de la taille à libérer Lawrence Crowl 2013 Adopté
Clarifier certaines particularités quand au Placement New lorsqu'il est utilisé pour réinvestir une zone mémoire préalablement utilisée Richard Smith et Hubert Tong http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4303.html2014  

Allocateurs

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter aux allocateurs une méthode de réallocation sur place Ariane van der Steldt http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3495.htm 2013On cherche un analogue au realloc() du langage C  
Allocateurs polymorphiquesPablo Halpern 2013, 2014 Adopté
Supprimer l'opérateur d'affectation des allocateurs polymorphiques Pablo Halpern http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0337r0.html 2016Une défectuosité trouvée dans la texte original 
Faire de polymorphic_allocator<void> un type vocabulairePablo Halpern http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0339r0.pdf 2016  
Faire de polymorphic_allocator<void> un type vocabulaire (suivi)Pablo Halpern et Dietmar Kühl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0339r1.pdf 2016  
Offrir une gamme d'allocateurs standards autres que std::allocatorMark Boyall http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3575.html 2013  
Expressions régulières munies d'allocateursMichael Spertus et John Maddock 2011, 2014, 2016  
Quantifier le comportement d'un allocateur John Lakos, Jeffrey Mendelsohn, Alisdair Meredith et Nathan Myers 2015, 2016  
Nettoyer les traits des allocateurs Alisdair Meredith 2016  
Interaction entre allocateurs et swap() Alisdair Meredith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0178r0.html 2016  
Ajouter des équivalents à certaines opérations clés, comme par exemple le Placement New, mais d'une manière tenant compte des allocateurs Thomas Köppe 2016  
Comparatif de vitesse d'exécution à l'aide de diverses stratégies d'allocation dynamique de mémoireGraham Bleaney http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0213r0.pdf 2016  
Séparer l'allocation des noeuds et des tableaux dans les allocateursMarcelo Zimbres http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0310r0.pdf 2016  
Enrichir l'interface des allocateurs Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0401r0.html 2016On vise à couvrir les cas où un allocateur alloue des blocs de taille supérieure à ceux demandés, pour que l'appelant soit informé de la taille réellement allouée et évite ainsi de réallouer inutilement quand la mémoire disponible suffit aux besoin 
Gérer correctement Copy Elision dans un cas de construction à la pièce (Piecewise Construction) Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0475r0.html 2016  

Tableaux de taille connue à l'exécution mais gérés automatiquement

On cherche ici une solution un peu comme celle mise en application avec C, mais dans le respect des moeurs de C++. Pour une explication de leur utilité, voir ce texte de Danny Kalev en 2013 : http://blog.smartbear.com/development/a-glimpse-into-c14/

Notez que les travaux portant sur ce type de structure de données en C++ ont été essentiellement interrompus, le concept s'intégrant mal au reste du langage.

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Proposition générale, semblable à ce que propose C Jens Maurer http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3497.html 2013  
Tableau dont la taille est connue dynamiquement et fixée à la construction Lawrence Crowl et Matt Austern 2013  
Proposition générale, semblable à ce que propose C (suivi)Jens Maurer http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3639.html 2013  
Spécification technique de dynarray, ou tableaux automatiques dont la taille est connue dynamiquement Lawrence Crowl http://isocpp.org/files/papers/n3820.html 2013  
Alternative aux extensions des tableaux Bjarne Stroustrup http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3810.pdf 2013  
Ne permettre de tels tableaux qu'en tant qu'attributs d'instance, et avec une syntaxe particulièreJ. Daniel Garcia et Xin Li http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3875.pdf 2014  
Tableaux qu'en tant qu'attributs d'instance (suivi)J. Daniel Garcia http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4294.pdf 2014  
Portées imbriquées, une réflexion Lawrence Crowl 2014  
Ajouter aux constructeurs la possibilité d'indiquer de l'information dynamique sur la taille effective des objets, pour faciliter l'introduction de tableaux de taille connue à l'exécutionJeff Snyder et Richard Smith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4025.pdf 2014 Rejeté
Approche pour généraliser le cas des types dont la taille n'est connue qu'à l'exécution L. Deniau et A. Naumann http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4188.pdf 2014  

Pointeurs intelligents

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Pointeur intelligent réalisant une duplication en profondeur, par copie ou par clonage Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf 2012  
Le « pointeur intelligent le plus idiot au monde » Walter E. Brown 2013, 2014 Adopté
Fonction make_unique() Stephan T. Lavavej 2013 Adopté
Adapter shared_ptr de manière à ce qu'il supporte les tableaux Peter Dimov 2013, 2014 Adopté
Adapter make_shared() de manière à ce qu'elle supporte les tableaux Peter Dimov 2013, 2014  
Raffiner operator->() pour permettre de le solliciter sur un rvalue Pascal Costanza http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3723.html 2013  
Opérations de nettoyage polymorphiques pour unique_ptr (ajout d'un type unique_safe_ptr) Marco Arena, Davide di Gennaro et Peter Sommerlad http://isocpp.org/files/papers/N3974.pdf 2014  
Définir les conversions qu'il est sécuritaire de permettre à partir d'un unique_ptr<T[]>Geoffrey Romer 2014  
Depuis C++ 11, auto_ptr<T> est déprécié. Cette proposition recommande d'enlever carrément auto_ptr<T> du standard Billy Baker http://isocpp.org/files/papers/n4168.html 2014  
Corriger le problème d'une règle SFINAE manquante dans unique_ptr<T> Howard E. Hinnant http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4366.html 2015La proposition comprend une analyse très intéressante d'un bogue du standard 
Rendre plus symétrique la relation entre shared_ptr<T> et weak_ptr<T> Arthur O'Dwyer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4537.html 2015  
Clarifier la spécification de shared_from_this Jonathan Wakely et Peter Dimov 2015, 2016 Adopté
Ajout d'un type memory_resource_ptr Pablo Halpern et Dietmar Kühl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0148r0.pdf 2015L'idée est d'offrir un pointeur intelligent dont le rôle se limite à la saine gestion d'une instance du type memory_resource. utile pour les allocateurs polymorphiques  
Alléger l'écriture du code requis pour obtenir un weak_ptr Arthur O'Dwyer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0163r0.html 2015Ajouter un type interne et public weak_type à std::shared_ptr<T>  
Ajout d'un cloned_ptr<T> Jonathan Coe et Ville Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0201r0.pdf 2016  
Ajout d'un indirect<T> Jonathan Coe et Sean Parent http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0201r1.pdf 2016Évolution de la proposition portant initialement sur un type cloned_ptr<T>. L'objectif est de supporter les objets alloués dynamiquement mais avec une sémantique de valeur 
Appliquer les changements proposés pour shared_ptr directement à C++ 17 Jonathan Wakely 2016  
Quelqus correctifs à appliquer dans le cas d'un shared_ptr<T[]> Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0497r0.html 2016  
Ajouter un pointeur intelligent intrusif à la bibliothèque standard Isabella Muerte et Bryce Adelstein Lelbach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0468r0.html 2016Le type se nommerait retain_ptr<T,R>. Fruit des travaux de SG14 
Clarifier le comportement de la méthode use_count() de shared_ptr<T> Stephan T. Lavavej http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0521r0.html 2016La résolution proposée sépare la spécification de la méthode unique() de celle de use_count(), car leur association provoque une condition de course 

Structure du langage

Propositions en lien avec les outils structurels du langage.

Bases du langage et outils généraux

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Simplifier l'utilisation des espaces nommésNikhil Joshi http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3349.pdf2012   
Spécialiser dans un espace nommé une fonction ou un type défini initialement dans un autre espaces nomméMike Spertus 2013, 2014   
Faciliter l'écriture d'espaces nommés imbriquésRobert Kawulak http://isocpp.org/files/papers/n4026.html2014   
Faciliter l'écriture d'espaces nommés imbriqués (suivi)Robert Kawulak et Andrew Tomazos 2014   Adopté
Utiliser une classe à titre d'espace nomméMatthew Woehlke http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0223r0.html 2016 Pour permettre de remplacer ceci :
struct X {
   int f() const;
   int g() const;
};
// ...
int X::f() const { return 3; }
int X::g() const { return 4; }
... par cela :
namespace struct X {
   int f() const;
   int g() const;
};
// ...
namespace struct X {
   int f() const { return 3; }
   int g() const { return 4; }
}
 
Permettre d'écrire des qualifications telles que const, constexpr, explicit, etc. une seule fois pour plusieurs méthodes, un peu comme on le fait pour public ou privateAndrew Tomazos http://isocpp.org/files/papers/N3955.pdf2014 Pour simplifier l'écriture des classesRejeté
Ajouter des méthodes privées (seulement) sans les déclarer à même la classeMatthew Fioravante http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3863.html2014   
Raffinement des comparaisons de pointeursJens Maurer 2013 Pour mieux tenir compte des qualifications de sécurité 
Comparer des spécialisations de pointeurs pour fins d'ordonnancement Gabriel Dos Reis http://isocpp.org/files/papers/n4229.pdf2014 Pour combler un trou dans la formulation du standard 
Éliminer certains cas d'Undefined Behavior dans des opérations de bas niveau telles que std::memcpy() Gabriel Dos Reis http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3751.pdf2013   
Éliminer certains cas d'Undefined Behavior dans dans les actions du préprocesseur Gabriel Dos Reis http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3801.pdf2013   
Éliminer certains cas d'Undefined Behavior dans dans le traitement des caractères étendus à même le code source David Krauss 2014   
Harmoniser le comportement du préprocesseur avec l'évolution du langage à partir de C++ 11 David Krauss 2014   
Déterminer une ABI (Application Binary Interface) portable pour les binaires C++ Herb Sutter http://isocpp.org/files/papers/n4028.pdf2014   
Simplifier et alléger le recours à return Herb Sutter 2014 L'idée est que l'auteur de l'instruction return est le même individu qui a choisi le type de retour de la fonction, ce qui fait que dans ce cas, même pour un constructeur qualifié explicit, le recours explicite au constructeur ne devrait (selon l'auteur) pas être requis 
Simplifier et alléger le recours à return (critique) Filip Roséen http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4131.html2014 L'auteur explique pourquoi il estime que ce qui est explicit ne devrait jamais être implicite 
Simplifier et alléger le recours à return (riposte) Howard E. Hinnant et Ville Voutilainen http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n4094.html2014 C'est un argumentaire convaincant 
Simplifier et alléger le recours à return (riposte) Ville Voutilainen, Mikael Kilpeläinen et Jonathan Wakely http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4223.html2014 C'est aussi un argumentaire convaincant 
Dans le cas où une signature est non-ambiguë, ne pas avoir à répéter le type de retour lors de la définition de la fonction Matthew Woehlke http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0224r0.html 2016   
Harmoniser initialisation de copie (de forme X x{args}) et initialisation directe (de forme X x = {args}), même dans le cas d'un constructeur qualifié explicit Nicolai M. Josuttis http://isocpp.org/files/papers/n4014.pdf2014 La forme X x = args demeurerait illégale (c'est le recours aux accolades qui serait considéré comme correct) 
Ajouter une forme if(T x : e) s pour les tests utilisant une temporaire locale Eelis van der Weegen http://isocpp.org/files/papers/n4127.html2014   
Unifier les formes obj.f(x) et f(obj,x) Herb Sutter http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4165.pdf2014 Son approche est de permettre d'appeler des fonctions qui ne sont pas des méthodes à partir de la syntaxe p.f() ou p->f() 
Unifier les formes obj.f(x) et f(obj,x) Bjarne Stroustrup 2014, 2015 Ceci rejoindrait certains autres langages (je pense entre autres à D ici) où ceci est possible, et permettrait d'alléger l'écriture de bibliothèques, surtout dans le cas de code générique. Cependant, cette proposition est exploratoire et met surtout de l'avant les difficultés et les risques que cela impliquerait pour un langage de la complexité de C++
Pour une réflexion de 2014 par Marius Bancila sur le sujet, voir http://mariusbancila.ro/blog/2014/10/15/extension-methods-in-cpp/		  
Unifier les formes obj.f(x) et f(obj,x) Bjarne Stroustrup et Herb Sutter 2015, 2016    
Terminologie de la sytaxe des appels de fonctions unifiés (Unified Call Syntax) Jens Maurer 2016   
Extension généralisée à la durée de vie des temporaires David Krauss 2014, 2015 Avec l'avènement des rvalue references, la question (déjà complexe) de la durée de vie des temporaires est devenue plus subtile encore. Cette proposition vise à clarifer cet aspect du langage  
Éliminer certaines indéterminations dans l'ordre d'évaluation des opérations Gabriel Dos Reis, Herb Sutter et Jonathan Caves 2014, 2015, 2016 Certaines conséquences de l'indétermination de l'ordre de certaines opérations sont si subtiles qu'elles échappent même aux experts. Cette proposition vise à rendre le langage plus utilisable en pratique . Notez que la version adoptée est un compromis, la proposition entière ne rencontrant pas l'assentiment d'une proportion suffisante du comitéAdopté
Imposer un ordre d'évaluation pour les sous-expressions d'une expression donnée Hyman Rosen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0431r0.htm 2016 L'auteur souhaite réduire le nombre de cas où l'évaluation d'une expression complexe donnerait un résultat indéfini ou non-spécifié  
Ajouter une nouvelle forme pour les alternatives if, c'est-à-dire if (T x : expr) stmt (avec variantes pour for, switch et autres) Eelis van der Weegen http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4127.html 2014 Rejoint en partie la syntaxe des répétitives for sur des intervalles 
Raffiner la présentation et la formulation des références de relais (Forwarding References)Herb Sutter http://isocpp.org/files/papers/n4262.pdf2014  Adopté
Ajouter des paramètres à des fonctions, en particulier à des constructeurs, qui ne seront évalués que lors de leur première utilisation Douglas Boffey http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4360.pdf 2015 La proposition suggère d'apposer le mot clé inline au paramètre visé. Cela pourrait entre autres faciliter l'implémentation d'un opérateur && ou || surchargé mais dont le comportement rejoindrait celui des versions Built-In 
Constructeurs sans effets de bord Pablo Halpern http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4393.pdf 2015 En lien direct avec le Destructive Move 
Initialisation des agrégatsOleg Smolsky 2015 Pemet ceci (exemple emprunté à Jason Merrill) :
struct B { int i; };
struct D: B { int j; };
D d { {1}, 2 };
Adopté
Permettre l'initialisation des attributs d'agrégats par leur nom Tim Shen, Richard Smith, Zhihao Yuan et Chandler Carruth 2016 En ceci, C++ rejoindrait C mais de manière plus restrictive (certains trucs de C ne conviennent pas à C++) 
Permettre l'initialisation des attributs d'agrégats par leur nom (suivi) Tim Shen et Richard Smith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0329r1.pdf 2016   
Déclaration de variables globales inline Hal Finkel et Richard Smith 2015, 2016 Permettrait de contourner certains irritants liés à ODR qui remontent aux jours du langage C Adopté
Représenter des suppositions du programmeur en utilisant true() et false() comme des fonctions Hal Finkel http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4425.pdf 2015 Truc d'optimisation. Il se trouve que la plupart des compilateurs ont des extensions semblables, par exemple __assume(size%4==0) qui indique au compilateur que le programmeur souhaite que l'on estime que size soit un multiple de 4 lors de l'optimisation 
Interaction entre constructeurs génériques et paramètres Mike Spertus http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4471.html 2015 Vise à réduire le recours aux fonctions génératrices en déduisant les types d'un template par les paramètres de son constructeur 
Interaction entre constructeurs génériques et paramètres (suivi) Mike Spertus et Richard Smith http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0091r0.html 2015   
Interaction entre constructeurs génériques et paramètres (suivi) Mike Spertus, Faisal Vali et Richard Smith 2016 Ceci permettrait de réduire drastiquement le recours aux fonctions de fabrication. Amène le concept de guides à la déduction (Deduction Guides)Adopté
Intégrer la déduction des types génériques à la bibliothèque standard Mike Spertus et Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0433r0.html 2016   
Introduire un mécanisme de Soft Keywords (mots clés « mous »?) Gor Nishanov http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0056r0.html 2015 Il est difficile de trouver des mots clés à la fois pertinents et qui ne briseraient pas le code existant. Cette proposition vise à ouvrir un champ d'expérimentation en ce sens 
Ajouter des méthodes d'extension Jonathan Coe et Roger Orr http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0079r0.pdf 2015 Ils nomment cela Uniform-Function-Calling Lite 
Tester la présence ou l'absence d'une méthode dans la vtbl Scott Wardle et Roberto Parolin http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0130r0.pdf 2015   
Trouver un meilleur nom pour brace-or-equal-initializer dans le cas des NSDMI Richard Smith http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0134r0.html 2015   
Simplifier les catégories de valeur pour garantir la Copy Elision Richard Smith 2015, 2016 Cette optimisation est possible depuis longtemps, et réalisée par la vaste majorité des compilateurs, mais elle n'était pas garantie auparavant Adopté
Clarifier les règles pour les constructeurs hérités Richard Smith 2015  Adopté
Structured Bindings, ou la capacité de retourner et de recevoir en bloc de multiples valeurs d'une même fonction Herb Sutter, Gabriel Dos Reis et Bjarne Stroustrup 2015, 2016 Ceci se simule par des tuple et des appels à tie(), mais l'idée serait de faire de cette pratique quelque chose de normal et de supporté à même le langage, comme on le fait par exemple en Go ou en Erlang  
Structured Bindings, ou la capacité de retourner et de recevoir en bloc de multiples valeurs d'une même fonction, terminologie Jens Maurer 2016    
Structured Bindings, présentés comme des multi-déclarateurs Andrew Tomazos http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0151r0.pdf 2015 Approche alternative, qui repose sur la multi-initialisation des tuple  
Structured Bindings et points de personnalisationVicente J. Botet Escribá http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0326r0.pdf 2016    
Permettre de typer les valeurs de retour captées à l'aide de Structured BindingsVille Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0480r0.html 2016 Il est parfois utile d'utiliser autre chose qu'auto ou auto&&. L'auteur montre qu'il existe des solutions de type « bibliothèque » à ce problème, mais qu'une solution de niveau « langage » serait préférable  
Standardiser l'accès aux Product TypesVicente J. Botet Escribá 2016 L'idée est d'offir une interface uniforme d'accès à tuple, pair, array et d'autres encore  
Généralisation de la syntaxe des pointeurs sur un membre d'instance Jeff Snyder http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0149r0.pdf 2016 Offrir une syntaxe pour définir certains pointeurs sur des membres d'instance selon des modalités a priori non-permises  
Retourner des struct anonymes d'une fonction Matthew Woehlke http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0222r0.html 2016 Directement associé à p0144  
Élargir les cas où l'initialisation par une liste des membres manquants d'un agrégat est permise James Touton http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0280r0.html 2016   Rejeté
Faciliter l'accès aux énumérations fortes logées dans un espace nommé à l'intérieur d'une sélective James Touton http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0284r0.html 2016   Rejeté
Comparer les pointeurs de méthodes virtuelles Daniel Markus http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0191r1.pdf 2016    
Enrichir la terminologie du standard avec le terme templated entity Jens Maurer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0391r0.html 2016 C'est un terme qui allégerait beaucoup, beaucoup l'écriture d'une partie du coeur du texte du standard Adopté
Terminologie pour clarifier le fait qu'une classe qui déclare un constructeur par défaut explicit ou expose des constructeurs hérités n'est plus considérée comme un agrégat Jens Maurer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0398r0.html 2016    
Terminologie pour clarifier l'ordre d'évaluation des paramètres passés à une fonction William M. Miller http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0400r0.html 2016 Le terme clé est indeterminately sequenced  
Proposition d'une nouvelle structure grammaticale pour permettre la sélection à la compilation de types, d'expressions et d'énoncés par voie de Pattern Matching Hubert Tong et James Touton http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0404r0.html 2016 Suit philosophiquement constexpr if en visant une meilleure localité des décisions prises à la compilation  
Déduction des classes génériques imbriquées S. David Herring http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0293r0.pdf 2016    
Ajout de constructeurs de classe statiques Mariusz Moczala http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0421r0.html 2016    

Alignement

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Allocation dynamique de mémoire pour des données sur-alignées Clark Nelson 2012, 2015, 2016 Son exemple de base est une classe contenant un tableau de quatre float et qualifié alignas(16). L'opérateur new n'a pas accès à cette information. L'auteur préconise une variante du Placement New 
Quelques nouveaux outils pour faciliter la gestion de l'alignement des objets en mémoire, soit is_aligned(), align_up() et align_down() Matthew Fioravante http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4201.html2014   
Enrichir les outils de gestion de l'alignement en permettant d'obtenir l'alignement en mémoire d'un objet, pas seulement d'un type, avec alignof Robert Haberlach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0314r0.html 2016   

auto

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Faire en sorte qu'évaluer le type auquel correspond auto lors d'un calcul résulte en un Expression Template Joël Falcou, Peter Gottschling et Herb Sutter 2013, 2014   
Déclarer auto un attribut d'instance n'est probablement pas une bonne idéeVille Voutilainen selon  en 2014, ce  : http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3897.html 2014 Plus une réflexion qu'une proposition 
Déduction automatique des types de retour de certaines fonctions Jason Merrill http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2012/n3386.html2012   
Déduction automatique des types de retour de certaines fonctions Scott Prager http://yapb-soc.blogspot.ru/2012/12/gcc-48-has-automatic-return-type.html2012 Rapport d'expérimentations sur g++ 4.8  
Déduction automatique des types de retour de certaines fonctions épargne des manoeuvres douloureuses Eric Niebler http://isocpp.org/blog/2012/12/stupid-name-lookup-tricks-for-c112012   
Déduction automatique des types de retour de certaines fonctions (raffinement)Jason Merrill 2013  Adopté
Déduction automatique des types de retour de certaines fonctions (raffinement tenant compte des fonctions =default et =delete)Michael Price http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4309.html 2014 Comble un oubli de n3638 
Utiliser auto en tant que type de retour pour operator= est dangereuxMichael Price http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0264r0.html 2016  Rejeté

Concepts

Les travaux sur les concepts se poursuivent (suivez le lien pour des détails).

Qualifications const et volatile

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Permettre de qualifier une relation d'héritage de constAlan Talbot, puis David Wilson 2016 De cette manière, de la fin de la construction de l'enfant au début de sa destruction, la partie parent se comporterait comme un attribut d'instance const 
Clarifier quelques aspects obscurs en lien avec la qualification volatile Jon Kalb et Dan Saks http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0278r0.html 2016 Par exemple, un objet volatile peut représenter une lecture sur un port Read-Only, mais le standard indique que ne pas initialiser l'objet constitue un comportement indéfini. Cette situation devrait être corrigée 

constexpr

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Raffinements à constexpr Scott Schurr http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3583.pdf 2013   
Raffinements à constexpr Richard Smith http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3597.html 2013   
Mieux faire coexister const et constexpr Richard Smith http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3598.html2013   
Raffiner le support de constexpr pour std::array Louis Dionne http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0107r0.pdf 2015   
L'écriture proposée pour le standard est telle que les méthodes qualifiées constexpr ne sont plus implicitement const. Proposition pour y remédier Nicolai M. Josuttis http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3669.pdf 2013   
Raffinements à constexpr (suivi) Richard Smith http://isocpp.org/files/papers/N3652.html2013  Adopté
Définir des variables génériques constexpr Gabriel Dos Reis 2013  Adopté
Faire en sorte que certains foncteurs standards tels std::less offrent un opérateur () qui soit constexpr Marshall Clow 2013  Adopté
Permettre l'évaluation constante de tous les paramètres non-types de templates Richard Smith http://isocpp.org/files/papers/n4268.html2014  Adopté
Permettre les λ qui seraient constexpr Faisal S. Vali, Jens Maurer et Richard Smith 2015 Permet ceci :
constexpr auto ajouter(auto n) {
    return [n](auto m) {
       return n + m;
   };
}
static_assert(ajouter(1)(1)==2,"");
Adopté
Permettre les goto dans une fonction constexpr Ville Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4472.html 2015   
Ajouter une version constexpr de reverse_iterator, move_iterator, array et aux intervallesAntony Polukhin http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0031r0.html 2015  Adopté
Interaction entre les union constexpr est les séquences initiales communes Anthony Williams http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0120r0.html 2015   
Ajouter constexpr à certaines fonctions dans <algorithm> et dans <cstring>Antony Polukhin 2016   

Exceptions

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Faciliter le transfert d'information lors de levées d'exceptions Emil Dotchevski http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3757.html2013   
Complément décrivant les informations standards lors de levées d'exceptions Emil Dotchevski http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3758.html2013   
Permettre à un destructeur de constater qu'il est appelé dù à un Stack Unwinding résultant d'une levée d'exception Herb Sutter 2013,
2014		 À l'aide de std::unwinding_exception, puis raffinement qui passe par std::uncaught_exceptions() pour connaître le nombre d'exceptions en vol Adopté
Mettre de l'ordre dans la bibliothèque standard en ce qui a trait à noexcept Nicolai M. Josuttis 2014   Adopté
Réflexions quant à la spécification noexcept pour certains conteneurs Ville Voutilainen http://isocpp.org/files/papers/N4055.html2014    
Réduire les contraintes lors de levées d'exceptions par des algorithmes parallèlesArch D. Robison, Jared Hoberock et Artur Laksberg 2014 L'idée est que, dans les cas où une seule exception est levée par l'exécution parallèle, on devrait pouvoir éviter de colliger « les » exceptions dans une exception_list   
Clarification du texte du standard pour ce qui touche aux expressions throw et aux spécifications d'exceptions Jens Maurer http://isocpp.org/files/papers/n4285.html2014 Tient compte de la dépréciation des spécifications d'exceptions, et relocalise des passages dans des sections plus à propos Adopté
Faire en sorte que les spécifications d'exceptions d'une fonction fassent partie de son type Jens Maurer 2014, 2015 La vision qu'a l'auteur des spécifications d'exceptions inclut la clause noexcept. L'un des problèmes discutés ici est la prise de l'adresse d'une fonction munie d'une telle spécification dans un pointeur pour lequel ces spécifications diffèreraient Adopté
Le cas de noexcept(auto) Ville Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4473.html 2015 L'idée ici est de faire déduire par le compilateur la clause noexcept d'une fonction  
Abandon de noexcept(auto) Ville Voutilainen http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0133r0.html 2015 L'idée ici est de faire déduire par le compilateur la clause noexcept d'une fonction  
Supprimer les clauses throw(X,Y,Z) Alisdair Meredith 2015, 2016 L'écriture throw() demeurerait, serait désormais équivalente à noexcept(true) et demeurerait dépréciée  
Clarifier les restrictions sur la levée d'exceptions James Dennett http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0509r1.pdf 2016    
Ajout d'un type std::unwinding_state, qui remplacerait à la fois std::uncaught_exception (singulier) et le type std::uncaught_exceptions (pluriel) qui est déjà proposé pour le remplacer David Krauss http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0044r0.pdf 2015 Selon l'auteur, std::uncaught_exceptions ne règlerait pas vraiment les problèmes qu'il était supposé régler  
Conteneurs et opérations qui ne lèvent pas d'exceptions Ville Voutilainen http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0132r0.html 2015    
Généraliser les exception_list du monde parallèle pour les intégrer à la programmation plus généraliste Bryce Adelstein Lelbach, Alisdair Meredith et Jared Hoberock http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0322r0.html 2016 Le design proposé repose sur des exceptions immuables  
État de la situation des travaux de SG14 en lien avec l'impact des exceptions et les alternatives à cette approche Michael Wong, Sunil Srivastava, Sean Middleditch et Patrice Roy http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0364r0.pdf 2016    

Généricité et traits

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Nommer et manipuler les Parameter Packs dans les templates variadiques Mike Spertus http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3728.html2013   
Utiliser des Parameter Packs hors des templates Mike Spertus http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0341r0.html2016 Ceci changerait radicalement certaines pratiques de programmation 
Faciliter la réutilisation du code lors de spécialisations de types génériquesPeter Gottschling et associés http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3596.pdf2013   
Paramètres génériques implicitesMike Spertus et Daveed Vandevoorde http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3601.html2013   
Déduction des paramètres génériques des constructeurs Mike Spertus et Daveed Vandevoorde http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3602.html 2013   
Faciliter la manipulation de fonctions Philipp Juschka http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3617.htm 2013   
Ajouter un trait swappable<T> à la bibliothèque standard Andrew Morrow http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3619.html 2013   
Ajouter un trait invocation_type Mike Spertus 2013, 2014 Pour automatiser la déduction du type « idéal » pour un passage de paramètre  
Raffiner le type integral_constant Walter E. Brown http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3545.pdf2013 Raffinement à <type_traits>  
Raffiner les traits de transformation de types Walter E. Brown 2013 Raffinement à <type_traits>  
Ajouter un trait pour les métafonctions Michael Park http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3887.pdf2013 Raffinement à <type_traits> Adopté
Ajouter un trait pour les signatures de fonctions Mike Spertus http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3579.html2013 Raffinement à <type_traits>  
Ajouter un trait identity Jeffrey Yasskin http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3766.html2013 Raffinement à <type_traits>  
Offrir une syntaxe allégée pour les traits qui sont des valeurs, passant par exemple de std::is_same<T,U>::value à std::is_same_v<T,U> Stephan T. Lavavej 2014 Dépend de celle qui permet de définir des variables génériques constexprAdopté
Formaliser les variable templates suffixés par _v pour les valeurs Alisdair Meredith http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0006r0.html 2015   
Raffiner le trait result_of pour l'harmoniser avec SFINAE Eric Niebler, Daniel Walker et Joel de Guzman http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3462.html 2012 Adopté
Raffiner le trait iterator_traits pour l'harmoniser avec SFINAE Walter E. Brown 2014 Donne des pistes intéressantes et générales pour la détection statique de traits, un vieux problèmeAdopté
Raffiner le trait underlying_type pour l'harmoniser avec SFINAE R "Tim" Song http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0340r0.html 2016   
Raffiner le trait common_type pour l'harmoniser avec SFINAE Walter E. Brown http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3843.pdf 2014 Donne des pistes intéressantes et générales pour la détection statique de traits, un vieux problème 
Faciliter la spécialisation du trait common_type David Stone http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0015r0.htm 2015   
Clarifier la spécification du trait common_type Walter E. Brown 2016 Il s'avère qu'une écriture correcte est particulièrement difficile à réaliser  
Ajouter le type void_t aux alias de transformation standards Walter E. Brown 2014, 2015 Chose extrêmement simple mais qui a sa place dans la bibliothèque standard. Son nom informel est l'« idiome de détection de C++ »  
Ajout d'un ensemble de traits intrinsèques au langageCleiton Santoia Silva et Daniel Auresco http://isocpp.org/files/papers/n3987.pdf2014 Des trucs tels que is_friend, is_default, is_delete, is_extern, is_inline, etc.  
Clarifier la résolution des méthodes génériquesFaisal Vali http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n4090.pdf 2014    
Combiner le support diagnostic et SFINAE Matthias Kretz et Jens Maurer http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4186.pdf 2014 Il se trouve que static_assert et SFINAE ne cohabitent pas très bien... Ici, on pourrait associer un message d'erreur choisi avec une clause =delete pour que le diagnostic soit plus clair  
Élargir les cas de constantes qui peuvent être utilisés dans un template Richard Smith http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4198.html 2014    
Ajouter des expressions primaires variadiques (Fold Expressions) Andrew Sutton et Richard Smith 2014

Permet d'écrire des trucs comme :

template <class ... Args>
   auto somme(Args ... args)
   {
      return args + ...;
   }

... qui donnerait int{} dans le cas où le Parameter Pack serait vide.

 Adopté
Correctif aux Fold Expressions unairesJens Maurer http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0160r0.html 2015   
Supprimer certains opérateurs relationnels des opérateurs auxquels s'appliquent les Fold ExpressionsVile Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0313r0.html 2016L'auteur propose de retirer les opérateurs relationnels classiques que sont ==, !=, <, <=, > et >= du lot des opérateurs supportés  
Expressions primaires variadiques unaires et Parameter Packs videsThibaut Le Jehan 2015La notation préconisée par n4295 poserait problème avec certaines bibliothèques mathématiques existantes Adopté
Ajouter un trait intermédiaire bool_constant<bool> entre true_type/false_type et integral_constant Zhihao Yuan 2014, 2015   
Formaliser le design des points de personnalisation (Customization Points) Eric Niebler http://ericniebler.github.io/std/wg21/D4381.html 2015   
Standardiser un trait pour l'idée de nothrow-swappable Daniel Krügler 2015, 2016  Adopté
Ajouter un trait std::is_callable Agustín K.-Ballo Bergé 2015,
2016		  Adopté
Ajouter des traits pour les opérateurs logiques Jonathan Wakely http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0013r0.html 2015  Adopté
Ajouter des traits pour les opérateurs logiques (suivi) Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0013r1.html 2015On leur a trouvé un nom!  
Faire de std::is_transparent une métafonctionTomasz Kamiński 2015, 2016   
Faciliter la déclaration de paramètres non-types pour des templates James Touton et Mike Spertus 2015Permettrait de remplacer template<class T,T x> par template<auto x> tout simplement Adopté
Ajout d'un type générique std::constant Matt Calabrese http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0377r0.html 2016Dépend de l'acceptation de la notation template<auto x>  
Quoi faire avec les « fonctions abominables »? Alisdair Meredith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0172r0.html 2015Certains types peuvent être générés par métaprogrammation sans être en soi utiles dans le langage, et compliquent grandement l'écriture de code générique  
Assujettir les erreurs dans les types de retour à SFINAETomasz Kamiński http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0238r0.html 2016   
Ajouter un trait originalement nommé std::is_contiguous_layout, mais qui sera en pratique nommé has_unique_object_representationsMichael Spencer 2016Ce trait ne peut être aisément implémenté de manière portable sans support du compilateur. On vise à détecteur la présence ou non de bits de Padding dans une représentation Adopté
Supprimer l'élision des virgules devant un variadiqueJames Touton http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0281r0.html 2016Les deux écritures suivantes sont équivalentes :
void f(int i, ...);
void f(int i ...);
...ce qui mène à certaines ambiguïtés. La proposition vise à rendre la virgule obligatoire		 Rejeté (mais pourrait être réexaminé dans le futur)
Déduire les signatures variadiques dans les cas où la variadicité n'est pas terminale dans la signatureBruno Manganelli, Michael Wong et Simon Brand http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0478r0.pdf 2016   
Éliminer des cas d'ambiguïté dans la comparaison de possibles instanciations de templates variadiquesBruno Manganelli, Michael Wong et Simon Brand http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0485r0.pdf 2016   
Ajouter des traits decay_unwrap<T> et unwrap_reference<T>Vicente J. Botet Escribá http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0318r0.pdf 2016L'auteur estime que ces métafonctions aideraient à la saine gestion des reference_wrapper<T>  
Métaprogrammation et fonctions d'ordre élevéVicente J. Botet Escribá http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0343r0.pdf 2016Propose plusieurs outils de base, utiles dans une multitude de contextes. Inspiré en partie des pratiques mises de l'avant dans Boost.Hana de Louis Dionne  
Tests de validité et traits, surtout dans les cas de SFINAEAndrzej Krzemieński http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0348r0.html 2016Test qui soulève des questions au comité, plutôt que de poposer des solutions  
Permettre de lever une ambiguïté en appliquant le mot template sur des identifiants non-qualifiésRobert Haberlach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0389r0.html 2016En date de C++ 17, la situation est la suivante (la modification que rendrait possible cette proposition est indiquée en commentaire) :
template <typename T>
  struct B {
    template <typename U>
      void f();
  };
template <typename T>
  struct D : B<T> {
    void g() {
      f<T>(); // malformé: < est l'opérateur « plus petit que »
      template f<T>(); // deviendrait bien formé
    }
  };
  
Quelques traits pour les exécuteurs et la réseautique Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0423r0.html 2016   
Faire en sorte que les services de std::char_traits<T> soient constexprAntony Polukhin 2016   
Une vision pour le futur de <limits>, et de quelques autres outils numériques hérités du langage C et dispersés dans la bibliothèque standard, menant vers un éventuel <num_traits> Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0437r0.pdf 2016Le fait que numeric_limits soit un bloc monolithique nuit à l'évolution de ce trait. Le souhait est de le briser en morceaux, suivant ainsi l'évolution de nos pratiques de programmation générique  
Compatibilité dans la disposition des objets et convertibilité des pointeurs Lisa Lippincott http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0466r0.pdf 2016 Solution qui repose sur un groupe d'outils, soit : un trait à deux types are_layout_compatible<T,U>, un trait à deux types is_initial_base_of<Base,Derive>, et deux prédicats constexpr qui seraient is_initial_member<S,M>(M S::*m) et are_common_members<S1,M1,S2,M2>(M1 S1::*m1, M2 S2::*m2)  
Représentation des objets pour fins de copie bit à bit JF Bastien   Se limiter à un union ou à reinterpret_cast ne tient pas nécessairement compte de l'alignement, ce qui est une erreur fréquente. Cette proposition amène un bit_cast correctement écrit, ce qui n'est pas une mince affaire  
Corriger un problème de détection de paramètres template<template>James Touton et Hubert Tong http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0522r0.html      

Hashage

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Hashage et types maisonJeffrey Yasskin et Chandler Carruth http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3333.html2012   
Hashage et types maison (ajustement)Geoff Pike http://isocpp.org/files/papers/N3898.txt2014   
Extensions aux conteneurs non-ordonnancésMark Boyall http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3573.html2013   
Combiner des hash Nicolai M. Josuttis http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3876.pdf2014 Permettrait de spécialiser un template dans un autre espace nommé que celui d'origineRejeté
Hashage standardisé d'un std::tuple Geoffroy Romer http://isocpp.org/files/papers/n3983.pdf2014 Pourrait permettre de définir un hashage standard pour tout agrégat, en l'exprimant en std::tuple par extension 
Technique pour découpler le hashage des types qui ont besoin d'un hash Howard E. Hinnant, Vinnie Falco et John Bytheway http://isocpp.org/files/papers/n3980.html2014   
Unifier les approches au hashage standardisé Geoff Romer et Chandler Carruth http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0029r0.html 2015   
Offrir les opérations de hashage par défautVicente J. Botet Escriba http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0199r0.pdf 2016   
Empoisonner std::hash Lisa Lippincott http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0513r0.pdf 2016 Proposition pour clarifier quelles sépcialisations de std::hash devraient être permises ou empoisonnées 

Initialisation standardisée

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Raffinements à l'initialisation standardisée pour tenir compte de cas limitesMichael Price http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3526.html2013   
Raffinements à l'initialisation standardisée pour tenir compte de cas limitesVille Voutilainen http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3605.html2013   
Régler certains irritants survenant en conbinant auto et l'initialisation standardisée Ville Voutilainen 2013, 2014   
Régler certains irritants survenant en conbinant auto et l'initialisation standardisée (mise à jour) James Dennett http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n3922.html 2014 À partir de maintenant, auto x{y}; fera de x une variable du type de y plutôt qu'un initializer_list d'un seul élémentAdopté

Expressions λ

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Raffiner les λ pour que celles-ci soient plus génériques, une réflexion Dave Abrahams http://cpp-next.com/archive/2012/09/unifying-generic-functions-and-function-objects/2012   
Raffiner les λ pour que celles-ci soient plus génériques, propositionFaisal Vali, Herb Sutter et Dave Abrahams http://cpp-next.com/files/2012/09/N3418.pdf2012   
Raffiner les λ pour que celles-ci soient plus génériques, proposition plus formelle Faisal Vali http://isocpp.org/blog/2012/12/an-implementation-of-generic-lambdas-request-for-feedback-faisal-vali2012   
Plusieurs enrichissements aux λ pour que celles-ci soient plus génériquesFaisal Vaili, Herb Sutter et Dave Abrahams 2013  Adopté
Intégrer paramètres à la capture de λ et sémantique de mouvement Ville Voutilainen http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3610.html2013   
Raffiner la capture des λ Daveed Vandevoorde et Ville Voutilainen http://isocpp.org/files/papers/N3648.html2013  Adopté
Capturer this par valeur dans une λ? Ville Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0207r0.html 2016   
Lier un objet muni d'états à un pointeur de fonctionMark Boyall http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3574.html2013   
Capturer this par valeurH. Carter Edwards et plusieurs autres 2015, 2016 Résout un vieux problème, soit (exemple emprunté à Jason Merrill) : 
struct A {
  int i;
  auto f() { return [*this]{return i;}; }
};
auto lam = A{}.f(); // closure contains a copy of the A temporary
auto i = lam();     // OK, no dangling pointer
Adopté
Ajouter un Y-Combinator standard au langageYegor Derevenets http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0200r0.html 2016   
Lever la restriction à l'effet qu'une λ ne puisse apparaître dans un contexte non-évalué Louis Dionne 2016 Cette restriction remontait à C++ 11 et tenait à la crainte de générer un cauchemar dans la gestion des noms uniques des templates, mais ne semble plus tenir depuis C++ 14 et la résolution de CWG 1607 
Capturer [=,this] dans une λ? Thomas Köppe 2016 L'auteur vise à rendre ce type de construction clair et explicite :
std::function<void()> X::f(int n) {
  return coin() ?
    [=,  this]() { g(n, x_, y_, z_); } :
    [=, *this]() { h(n, x_, y_, z_); };
}
 
Enrichir la syntaxe des λ génériques pour faciliter l'identification des types utilisés Louis Dionne http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0428r0.pdf 2016   

Littéraux maison

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter des littéraux maison pour certains types de la bibliothèque standardPeter Sommerlad 2013  Adopté
Ajouter des littéraux maison pour std::complexPeter Sommerlad 2013  Adopté
Ajouter des littéraux maison standards UTF-8 (prefixe u8) Richard Smith http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4197.html 2014 C'est le grand absent du lot. Par conformité avec les autres littéraux genre, u8 serait un préfixe ici 
Ajouter des littéraux maison standards pour les types std::size_t (et, dans certaines propositions, à std::ptrdiff_t) Rein Halbersma 2014, 2016   
Élargir la gamme des types entiers non-signés pour fins de paramètres aux littéraux maisonMichał Dominiak http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0345r0.html 2016   
Ajouter un littéral maison standard pour représenter le contenu d'un fichierAndrew Tomazos http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0373r0.pdf 2016 Notation préfixe, qui réalise l'inclusion du contenu du fichier à la compilation 
Reconsidérer le refus d'inclure des littéraux maison standards pour les chaînes de caractères Louis Dionne http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0424r0.pdf 2016 Les connaissances sur le sujet ont évolué depuis l'époque où ceci était considéré trop ardu 

Mouvement

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Permettre un mouvement destructif brut (équivalent d'un memcpy() suivi d'un memset() sur la représentation interne des objets), avec destructive_move()Pablo Halpern http://isocpp.org/files/papers/n4034.pdf2014 Approche qui se veut une opportunité d'optimisation dans les cas pour lesquels move_if_noexcept() ne serait pas une option.  
Améliorer le Perfect ForwardingVille Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4462.html 2015    
Il n'est pas raisonnable d'espérer se débarasser des exceptions dans les opérations de mouvementVille Voutilainen http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0129r0.html 2015    
Relocalisation, pour un mouvement plus efficace encore lorsque cela s'avère possible Denis Bider http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0023r0.pdf 2016    

Opérateurs et méthodes clés

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter nouvel opérateur (l'opérateur « swap ») Walter E. Brown 2013 Il s'écrirait :=: 
Remplacer la « règle de trois » (la Sainte-Trinité) par une nouvelle « règle de cinq » Walter E. Brown 2013, 2014 Pour couvrir les opérations clés de la sémantique de mouvement  
Permettre d'écrire une fonction swap(T&,T&) = defaultVicente J. Botet Escriba http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0198r0.pdf2016    
Opérateurs relationnels par défautOleg Smolsky 2014 Générés à partir de la spécification = default  
Ajout d'opérateurs de glissements circulaires de bitsDaniel Gutson et Angel Bustamante http://isocpp.org/files/papers/n3990.pdf2014 Ces opérations existent typiquement au niveau du code machine. La syntaxe proposée est d'ajouter les opérateurs >>> et <<<. On parle d'un ajout pertinent en particulier pour les systèmes embarqués. Rejeté
Ajout d'un opérateur assertDavid Krauss http://isocpp.org/files/papers/N4154.pdf2014 Dans le but de corriger du code a priori incorrect, par exemple quand le code auquel est appliquée la macro assert traditionnelle comporte des effets de bord  
Opérateurs relationnels par défaut Bjarne Stroustrup 2014, 2015 L'auteur propose de générer les six opérateurs relationnels par défaut, tout simplement, tout en pemettant de les écrire ou de les supprimer si cela semble à propos. L'égalité se ferait sur la base de la conjonction des égalités des attributs; l'ordonnancement sur la base l'opérateur < serait basé sur l'ordonnancement lexicographique des attributs, en ordre de déclaration.  
Opérateurs relationnels par défaut (proposition de formulation) Jens Maurer 2015, 2016 Pour un texte donnant une forme de contexte quant à cette proposition, voir https://isocpp.org/blog/2016/02/a-bit-of-background-for-the-default-comparison-proposal-bjarne-stroustrup par Bjarne Stroustrup  
Mieux vaut ne pas générer operator<() par défaut Tony Van Eerd http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0354r0.pdf 2016 L'auteur argumente que générer operator==() par défaut ne donne pas de résultats vraiment surprenants, du moins si l'on s'en tient aux propriétés manifestes d'un objet, mais qu'il est nettement moins clair que la situation soit la même pour operator<()  
Générer automatiquement == et !=, mais seulement quand le constructeur de copie est celui généré par défaut par le compilateur Tony Van Eerd http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0481r0.pdf 2016 L'idée de l'auteur est que les opérateurs == et != sont intrinsèquement liés au concept de copie, de toute manière  
Comparaisons par défaut, implicites et explicites David Stone http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0432r0.html 2016 Proposition qui se veut un hybride entre les approches implicites et explicites, qui ne sont pas parvenues à atteindre un consensus  
Réinterprétation d'opérateurs Walter E. Brown 2016 Adopter les parties non-controversées des propositions sur la génération automatique des opérateurs relationnels, soit les opérateurs == et !=, et ajouter le concept de « réinterprétation d'opérateurs » pour le reste, soit générer >, <= et >= sur la base de < quand ce dernier existe  
Permettre la surcharge de l'opérateur « . » Bjarne Stroustrup et Gabriel Dos Reis 2014, 2015, 2016 L'idée est de permettre d'exprimer des références intelligentes, un peu comme un peut exprimer des pointeurs intelligents  
Approche alternative à la surcharge de l'opérateur « . » Hubert Tong et Faisal Vali http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0352r0.pdf 2016 Proposition visant à offrir la même sémantique que celle associée à la surcharge de l'opérateur « . », mais d'une manière qui soit plus repérable et qui faciliterait l'entretien du code  
Améliorer la manière dont le langage traite les comparaisons en ajoutant des prédicats binaires plus fins Lawrence Crowl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4367.html 2015 L'idée est que les requis des opérateurs de comparaison varient en fonction des applications (mémoisation, itération, etc.), et que le langage n'en tient pas suffisamment compte  
Smart Objects en tant qu'alternative à la surcharge de l'opérateur « . »Mathias Gaunard et Dietmar Kühl 2015 Leur approche suggère de synthétiser des membres qui seraient des foncteurs silencieux mais avec une syntaxe d'attribut. Ça permettra de générer des propriétés et des références intelligentes. Cette proposition est un complément à la réflexivité  
Supprimer operator++(bool) Alisdair Meredith 2015 Cet opérateur est déjà déprécié... depuis 1998! Adopté
Offrir un trait pour représenter une implémentation de l'opérateur < pour fins d'ordonnancement Alisdair Meredith 2016    
Un outil pour assiter à l'idiome d'affectation sécuritaire Pablo Halpern http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0208r0.pdf 2016 L'idée est de tenir compte des cas où on réaliserait un swap() sur un objet muni d'un allocateur  

Réflexivité

Il y eut un appel de propositions pour des outils de réflexivité statique, en 2013 : http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3814.html

En 2014, Sumant Tambe propose un plaidoyer pour la réflexivité statique en C++ : http://cpptruths.blogspot.ca/2014/03/why-we-need-compile-time-reflection-in.html

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Proposition de rich_pointer, des pointeurs intelligents sémantiquement chargésDean Michael Berris, Matt Austern et Lawrence Crowl (entre autres) 2012 Pour réaliser une forme de réflexivité dynamique, par exemple 
Réflexion sur la pertinence de rich_pointer et sur ses cas d'utilisationDean Michael Berris http://www.cplusplus-soup.com/2012/09/rich-pointers-update-and-reflection.html 2012Ceci n'est pas un texte soumis pour fins de standardisation  
Ajouter un trait pour parcourir les valeurs d'une énumération Andrew Tomazos et Christian Käser 2013,
2014,
2015		 Raffinement à <type_traits>  
Support standardisé à un accès séquentiel aux membres d'instance d'un objet et de ses parents, forme de déconstruction supportée à même le langageAndrzej Krzemieński http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3326.pdf2012   
Proposition incluant l'ajout des opérateurs statiques typename<T>... et typedef<T>...Cleiton Santoia Silva et Daniel Auresco 2014, 2015, 2016 Une application possible serait l'élimination de moc dans Qt : http://woboq.com/blog/reflection-in-cpp-and-qt-moc.html  
Ajouter un type std::integer_sequence Jonathan Wakely http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3658.html2013 Pour accéder aux éléments d'un Parameter Pack variadique par leur indice  
Traiter un tuple comme un variadique Peter Sommerlad 2013,
201014		   Adopté
Généraliser get<I>() et d'autres services connexes our que les accès permis sur des tuple le soient pour d'autres typesVicente J. Botet Escriba http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0197r0.pdf 2016    
Vision unificatrice de la manipulation des objets offrant une interface comme celle de tuple Matthew Woehlke http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0311r0.html 2016 Serait surtout utile dans la manipulation des éléments d'un Parameter Pack  
Ajouter un type source_context, représentant la situation d'un moment du le programme dans le code source (entre autres pour remplacer des macros telles que __FILE__ et __LINE__) Robert Douglas 2014    
Ajouter un type source_context (suivi) Robert Douglas http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4417.pdf2015    
Capturer les valeurs des paramètres pour fins de réflexivité Robert Douglas http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4418.pdf 2015    
Capturer la position dans un fichier pour fins de réflexivité Robert Douglas 2015    
Marquer le code dédié aux fins de tests Robert Douglas et Michael Smith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4420.pdf 2015    
Ajout de réflexivité statique sur la base d'annotations Cleiton Santoia Silva et Daniel Auresco http://isocpp.org/files/papers/n3984.pdf2014 On parle d'un changement en apparence mineur mais qui transformerait le langage de manière significative  
Exposé sur la réflexivité statique et des manières de l'implémenter Matúš Chochlík 2014, 2015    
Exposé sur la réflexivité statique et des manières de l'implémenter (suivi) Matúš Chochlík et Axel Naumann 2016    
Exposé sur la réflexivité statique et des manières de l'implémenter (suivi) Matúš Chochlík, Axel Naumann et David Sankel 2016 En résumé : pendant la compilation, le compilateur générerait des métaobjets dont les services seraient génériques, et qui pourraient être utilisés de manière statique  
Accepter des Parameter Packs de taille fixe Maurice Bos http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n4072.html 2014 Pour couvrir des cas spécifiques mais fréquents sans trop écrire de code redondant  
Ajout d'un mécanisme pour retrouver un type dans un Parameter Pack Bill Seymour et Stephan T. Lavavej 2014    
Implémenter la comparaison par défaut à partir de réflexivité statique Andrew Tomazos et Michael Spertus http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4239.pdf 2014    
Considérations quant à la comparaison Michael Price http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4401.html 2015    
Réflexivité « légère »Cleiton Santoia Silva http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0256r0.pdf 2016    

Résilience

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Définir des interfaces offrant des contrats sémantiques restreints, et améliorer les stratégies de programmation défensive avec des assertions de préconditions et de postconditions John Lakos et Alexei Zakharov 2013, 2014   
Définir des interfaces offrant des contrats sémantiques restreints, et améliorer les stratégies de programmation défensive avec des assertions de préconditions et de postconditions (suivi) John Lakos,  Alexei Zakharov et Alexander Beels 2014    
Définir des interfaces offrant des contrats sémantiques restreints, et améliorer les stratégies de programmation défensive avec des assertions de préconditions et de postconditions J. Daniel Garcia http://isocpp.org/files/papers/N4110.pdf2014 Approche différente mais connexe de celle de John Lakos et cie  
Ce que le langage C++ offre comme support à la programmation par contrats J. Daniel Garcia http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4293.pdf2014    
Quelles sont les options pour formaliser la programmation par contrats en C++? Gabriel Dos Reis, Shuvendu Lahiri, Francesco Logozzo, Thomas Ball et Jared Parsons http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4319.pdf 2014    
Définir un contrat sémantique sur la base de contraintes sur les valeursAndrzej Krzemieński http://isocpp.org/files/papers/n4160.html2014    
Définir des interfaces offrant des contrats sémantiques restreints, et améliorer les stratégies de programmation défensive avec des assertions de préconditions et de postconditions (suivi) John Lakos, Alexei Zakharov, Alexander Beels et Nathan Myers 2014, 2015    
Foire aux questions à propos des assertions contractuelles John Lakos et Nathan Myers http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4379.pdf2015    
Programmation par contrats (simple) en C++ Gabriel Dos Reis, J. Daniel Garcia, Francesco Logozzo, Manuel Fähndrich et Shuvendu Lahiri 2015,
2016		 Approche qui repose sur des annotations 
Les préconditions des outils d'une bibliothèque standard sont en fait une caractéristique du langage lui-même Alisdair Meredith http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4248.html 2014 Plaidoyer de l'auteur  
Réflexion sur le design et l'utilisation des contrats Lawrence Crowl http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0147r0.html 2015    
Trois questions pertinentes à propos des contrats Jose Daniel Garcia http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0166r0.pdf 2015 Les questions sont (a) comment spécifier les règles de non-débordement d'un tableau, (b) comment interagir avec noexcept, et (c) que faire lors d'un bris de contrat  
Proposition fusionnée de contrats John Lakos, Alisdair Meredith et Nathan Myers http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0246r0.pdf 2016    
Critères minimaux pour le support de contrats Nathan Myers http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0247r0.pdf 2016    
Un design pour les contrats Gabriel Dos Reis, J. D. Garcia, John Lakos, Alisdair Meredith, Nathan Myers et Bjarne Stroustrup 2016 Repose sur des annotations paramétrables : [[expects]], [[assert]] et [[ensures]]  
Réflexion sur les interfaces procédurales Lisa Lippincott http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0465r0.pdf 2016 Pensée très profonde sur une perspective autre que fonctionnelle sur la validation et les contrats, prenant comme point de départ qu'un programme est sa propre preuve  

Structures de contrôle

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Raffinement aux instructions de branchement et de saut, telles que continue, switch ou gotoAndrew Tomazos http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3879.pdf2014  Rejeté
Introduire l'écriture for(e : c) (pour un conteneur c donné) soit équivalente à for(auto &&e : c) Stephan T. Lavavej 2014 Objectif de pédagogie et d'efficacitéRejeté
Enrichissement des boucles forAlan Talbot 2013,
2015,
2016		 Pour tenir compte de sorties impromptues, ceci propose de pouvoir tester une boucle for dans une condition pour savoir si elle s'est complétée 
Enrichissement des sélectives (des switch) Zhihao Yuan http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3627.html2013 Pour qu'elles opèrent sur des littéraux maison autant que sur des entiers 
Répétitives for multi-intervallesMatthew McAtamney-Greenwood http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0026r0.pdf 2015 Pour les cas qui opèrent itérativement sur plus d'une séquence à la fois Rejeté
Permettre de déclarer une variable dans le test de condition d'un ifThomas Köppe 2016 La syntaxe proposée serait :
if(init; cond) {
   // ...
}
switch(init; val) {
// case, default, etc.
}
L'idée est de réduire la portée des variables locales à un bloc if...else		 Adopté
Omettre ou élider une virgule terminaleThomas Köppe 2016 Facilite la gestion des cas limites dans le code variadique, surtout dans le cas des macros  

Types

En 2014, Jonathan Wakely souligne que certaines décisions du comité de standardisation et impliquant des changements aux types de la bibliothèque standard peuvent être faits de manière un peu trop intempestive, et recommande la prudence : hhttp://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4041.html

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Alias opaques de types Walter E. Brown 2013,
2015		 Pour couvrir des cas tels que la constante pi, qui pourrait plusieurs valeurs pour plusieurs types, en fonction du contexte  
Raffinement du support pour Unicode Mark Boyall http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3572.html 2013   
Marquer les paramètres aux fonctions qui sont des intrants stricts d'un mot clé Lawrence Crowl http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3538.html 2013 Permettre au compilateur de choisir entre un passage par valeur ou par référence-vers-const, en fonction de ce qui donnera le meilleur code sur une implémentation donnée 
Marquer les paramètres aux fonctions qui sont des intrants stricts d'un mot clé (raffinement) Ian McIntosh et plusieurs autre http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3635.pdf 2013   
Offrir en C++ un support semblable à celui que permet restrict en C Hal Finkel, Hubert Tong, Chandler Carruth, Clark Nelson, Daveed Vandevoorde et Michael Wong 2014 L'approche proposée repose sur des annotations, un beau cas d'application du fait que les ignorer n'affecte pas le bon fonctionnement du programme (pour un compilateur, comprendre ces annotations est une opportunité d'optimisation) 
Ajouter une classe générique logical_const<T> pour offrir une constance logique plutôt que physique, même pour les pointeurs Jonathan Coe et Robert Mill http://isocpp.org/files/papers/n3973.pdf 2014   
À propos de la propagation de la constance (suivi) Jonathan Coe et Robert Mill 2014, 2015 logical_const<T> devient propagate_const<T> 
Ajout d'une fonction std::as_const<T>(), complément à const_cast<const T&> Adam David Alan Martin et Alisdair Meredith 2015 Une fonction qui habiterait <utility> et allégerait l'écriture de certaines conversions courantes 
Faciliter la description de structures compactesSebastian Davalle, Daniel Gutson et Angel Bustamante http://isocpp.org/files/papers/n3986.pdf 2014 Particulièrement utile pour les systèmes embarqués 
Ajout d'un Null Coalescing OperatorAlexander Bock http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n4120.pdf 2014   
Classes qualifiées selon l'usageDavid Krauss https://isocpp.org/files/papers/n4149.pdf 2014 L'auteur constate que certaines classes n'ont de sens que dans des contextes précis (p. ex. : ne devraient jamais représenter une variable temporaire) et propose quelques ajouts au langage pour soutenir ce constat 
Variables inlineDavid Krauss https://isocpp.org/files/papers/n4147.pdf 2014 Une approche qui pourrait, selon l'auteur, mener à l'élimination d'un certain nombre de macros 
Faire en sorte que certaines opérations ne puissent être =delete dans un type Trivially CopyableMatheus Izvekov https://isocpp.org/files/papers/n4148.html 2014 L'auteur cherche par ces proposition à pallier une faille dans le standard  
Faire en sorte que le type initializer_list devienne déplaçableDavid Krauss 2014, 2015    
Le type reference_wrapper (entre autres) devrait être copiable de manière trivialeAgustín Bergé http://isocpp.org/files/papers/n4151.html 2014    
Le type reference_wrapper (entre autres) devrait être copiable de manière triviale (suivi)Agustín Bergé https://isocpp.org/files/papers/N4277.html 2014    
Fonctions invariantes devant les données, raffinemenent reposant sur constant_time::value Jens Maurer 2014, 2015    
Ajustement proposé à reinterpret_cast Jens Maurer 2014 Bien gérer les conversions de tableaux de pointeurs vers pointeurs de pointeurs Adopté
Permettre la création de nouveaux types, pas seulement des alias, d'une manière inspirée de typedef ou de usingTroy Korjuslommi http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0027r0.pdf 2015    
Des fabriques génériquesVicente J. Botet Escriba 2016 Une fonction make<TC>(args...)  
Faciliter la surcharge d'expressions λ (entre autres) à l'aide d'une fonction overload Vicente J. Botet Escriba 2015, 2016 C'est le genre de truc qu'on peut écrire soi-même, mais qui est fastidieux et qui pourrait aider à utiliser des λ dans un contexte de visite de variant  
Déprécier le préfixe 0 pour les littéraux octaux et le remplacer par 0o Michael Jonker et Axel Naumann http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0085r0.html 2015    
Supprimer les types internes et publics result_type et compagnie Stephan T. Lavavej http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0090r0.htm 2015    
Faire de void un type régulier Matt Calabrese 2015, 2016    
Supprimer les spécialisation explicites de futures pour le type void Matt Calabrese http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0241r0.html 2016    
Spécialiser certains outils de la bibliothèque standard pour le type void Matt Calabrese http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0242r0.html 2016    
Utiliser des enum class sans valeurs énumérées à titre de types forts Gabriel Dos Reis 2015, 2016   Adopté
Permettre l'initialisation par défaut des membres d'un champ de bits Andrew Tomazos 2016 Supporter une syntaxe telle que (tiré de la proposition) :
struct X {
   int n : 6 : = 42;
};
  
Moderniser using pour tenir compte des Parameter Packs Robert Haberlach 2016    
Supporter les classes partiellesDaniele Bordes et Markus Hosch http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0309r0.pdf 2016 Argumentaire faisant entre autres valoir les avantages de cette approche dans la séparation de l'interface et de l'implémentation d'une classe  
Rendre appelables les pointeurs sur des méthodes d'instance Barry Revzin http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0312r0.pdf 2016 La syntaxe existante est hétérogène et mène à trop de cas particuliers  
Clarifier ce qui se produit lors du remplacement d'un objet contenant des attributs qui soient des références Richard Smith 2015, 2016 Fait partie des enjeux derrière std::launder(). Pour comprendre l'enjeu, examinez l'exemple suivant (tiré directement du texte du standard) : 
struct X { const int n; };
union U { X x; float f; };
void tong() {
  U u = {{ 1 }};
  u.f = 5.f; // OK, creates new subobject of 'u' (9.5)
  X *p = new (&u.x) X {2}; // OK, creates new subobject of 'u'
  assert(p->n == 2); // OK
  assert(*std::launder(&u.x.n) == 2); // OK
  // undefined behavior, 'u.x' does not name new subobject
  assert(u.x.n == 2);
}
 Adopté
Permettre de convertir un tableau de taille connue en un tableau de même type mais de taille inconnue Robert Haberlach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0388r0.html 2016    
Ajouter des conversions explicites de types sur des pointeurs de manière à supporter la sémantique de mouvementNickolas Pokhylets http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0390r0.htm 2016 On vise ici des variantes des conversions explicites de types ISO classiques, mais applicables à des shared_ptr. On parle de static_pointer_cast, dynamic_pointer_cast, const_pointer_cast et reinterpret_pointer_cast  
Déplacer std::monostate dans <utility>David Sankel http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0472r0.html 2016 Il se trouve que ce type est défini dans <variant> mais pourra servir pour d'autres abstractions du genre, donc que ce couplage semble superflu  

Le cas particulier du type std::variant demande une attention toute aussi particulière.

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajout d'un type variant Axel Naumann 2014, 2015, 2016 Ce serait une sorte d'union étiqueté qui serait Type-Safe, idéalement « sans comportement indéfini » et « rarement invalide » Adopté
Ajout d'un type variant (approche alternative) Michael Park http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0080r0.pdf 2015    
Ajout d'un type variant (approche alternative) David Sankel http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0094r0.html 2015 Approche qui se veut très simple, avec garanties minimales en cas d'exception  
Ajout d'un type variant (approche alternative) David Sankel http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0093r0.html 2015 Approche qui se veut très simple, avec garanties fortes en cas d'exception  
Ajout d'un type variant (approche alternative) David Sankel 2015 Approche de niveau langage  
Implémenter la garantie forte face à des exceptions pour un type variant Anthony Williams http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0110r0.html 2015    
Raffiner variant<T0,T1,...> dans le cas où tous les types possibles exposent des constructeurs de mouvement qui sont noexcept Peter Dimov http://www.pdimov.com/cpp2/P0308R0.html 2016    
Unifier les interfaces des types variant<Ts...>, any et optional<T>Vicente J. Botet Escriba 2015, 2016 Adopté  
Raffiner la gestion ds types étiquettes tels que std::in_place_t Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0504r0.html 2016    
Introduire un type none_t ou une fabrique none() utilisable pour tout type nullableVicente J. Botet Escriba 2016 Destiné aux types nullables comme les pointeurs bruts, les pointeurs intelligents ou optional<T>  
Renommer corrupted_by_exception() pour obtenir valueless_by_exception() Tony Van Eerd http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0239r0.pdf 2016 Certaines entreprises ne pouvaient utiliser un type pour lequel le nom d'un des membres contient la sous-chaîne corrupted  
Pallier un défaut du langage, susceptible de corrompre un variant, par std::direct_init Richard Smith, Tony Van Eerd, et David Sankel http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0271r0.html 2016    
Ajout d'une fonction std::recover(), pour formaliser l'extraction d'une donnée dont le type a préalablement été effacé David Krauss http://open-std.org/jtc1/sparc22/wg21/docs/papers/2015/p0042r0.pdf 2015    
Ajout d'une fonction générique match pour faciliter l'implémentation du schéma de conception Visiteur sur un variant Vicente J. Botet Escriba http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0050r0.pdf 2015    
Permettre à un variant d'être Valueless est dangereux Peter Dimov http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0308r0.html 2016    
Uniformiser le comportement des types variant et optional pour ce qui est des opérateurs relationnels et de leur délégation aux types qu'ils contiennent Tony Van Eerd http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0393r3.html 2016   Adopté
Interdire les types « aberrants » (mon choix de nom ici) tels que les variant vides, contenant des références, des types incomplets, etc. Erich Keane http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0510r0.html 2016    

Bibliothèques

Enrichissements, ajouts et correctifs proposés aux bibliothèques standards du langage. Pour une vue d'ensemble des changements prévus pour la bibliothèque standard de C++ avec C++ 14, voir :

En 2016, dans http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0180r0.html puis http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0180r1.html puis http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0180r2.html, Alisdair Meredith a proposé qu'un espace nommé spécial soit réservé à la prochaine version de la bibliothèque standard.

Général

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Dans les descriptions de la bibliothèque standard, séparer les requis des préconditions Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0411r0.html 2016

La clause [res.on.required] indique traditionnellement :

Violation of the preconditions specified in a function's Requires: paragraph results in undefined behavior unless the function's Throws: paragraph specifies throwing an exception when the precondition is violated

alors qu'en pratique, plusieurs requis pourraient être validés, même de manière statique

 

Affichage 2D

Pour lire sur une expérimentation avec la bibliothèque proposée ici, voir ce texte de 2015 : https://msopentech.com/blog/2015/01/28/experimenting-with-a-proposed-standard-gui-for-the-c-language/

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Spécification technique Michael B. McLaughlin, Herb Sutter et Jason Zink 2014, 2016 Proposition basée sur une API nommée Cairo, qui a une excellente réputation 
Périphériques d'entrée pour fins d'affichage graphique 2DBrett Searles, Michael McLaughlin et Jason Zink 2016   
Une interface portable pour les interruptions lors d'entrées/ sorties, destinée aux interfaces personne/ machineBrett Searles http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0434r0.pdf 2016   

Algorithmes

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter un algorithme std::search() Marshall Clow 2013, 2014 Pour permettre des fouilles paramétriques sur la base de l'algorithme souhaitéAdopté
Corriger une erreur de design dans la signature des algorithmes std::search() Marshall Clow 2016  Adopté
Ajouter un algorithme std::split() Greg Miller 2013 Pour séparer une chaîne de caractères en sous-chaînes 
Ajouter un algorithme std::join()Greg Miller http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3594.html2013 Pour adjoindre des intervalles 
Ajouter un algorithme std::partition_copy() Vladimir Grigoriev hhttp://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3795.htm2013   
Ajouter un algorithme std::erase_if() Stephan T. Lavavej http://isocpp.org/files/papers/n4009.txt2014 L'idée est d'offrir une manière générale d'éliminer d'un conteneur (et non pas d'une séquence définie par une paire d'itérateurs) les éléments pour lesquels un prédicat d'avère 
Ajouter des algorithmes std::erase() et std::erase_if() Stephan T. Lavavej 2014 L'idée est d'offrir une manière générale d'éliminer d'un conteneur (et non pas d'une séquence définie par une paire d'itérateurs) les éléments pour lesquels un prédicat d'avèreAdopté
Ajouter une valeur par défaut au deuxième paramètre de std::advance()Vladimir Grigoriev 2015 Le cas type est d'avancer d'une position; l'auteur propose d'alléger l'écriture du code, et d'harmoniser sa signature avec celle de std::next() 
Ajouter des algorithmes de clamp, pour s'assurer qu'une valeur (ou qu'une séquence de valeurs) soi(en)t inclusivement entre deux bornesMartin Moene et Niels Dekker 2015  Adopté
Ajout d'algorithmes sur de la mémoire bruteBrent Friedman 2015, 2016 Fruit des travaux de SG14. Pour fins de référencement ultérieur, Brent Friedman se nomme désormais Brittany FriedmanAdopté
Ajout d'un algorithme unstable_remove(), qui ne préserve pas l'ordre relatif des éléments non-supprimésBrent Friedman http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0041r0.html 2015 Fruit des travaux de SG14 
Réduire les exigences sur les itérateurs de certains algorithmes standards Thibault Le Jehan http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0227r0.pdf 2016   
Ajout d'algorithmes move_if_noexcept() et uninitialized_move_if_noexcept() Patrice Roy http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0483r0.pdf 2016   
Ajout d'un algorithme for_each_iter()Ildus Nezametdinov et Patrice Roy http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0486r0.pdf 2016   

Bases de données

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Desiderata pour une interface d'accès aux bases de données Thomas Neumann http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3612.pdf2013   
Une interface standard pour l'accès aux bases de données Johann Anhofer http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3886.pdf2014 Enfin! 

Bibliothèques à liens dynamiques

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter les types et fonctions permettant de réaliser de manière portable le chargement de bibliothèques à liens dynamiquesAntony Polukhin http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0275r0.html 2016 Ceci repose en partie sur les outils de gestion portable du système de fichiers  

Chaînes de caractères

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Opérateurs littéraux pour les string Richard Smith http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3599.html 2013   
Ajouter un type std::string_ref, référence intrusive à une sous-chaîneJeffrey Yasskin http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3512.html2013   
Ajouter un type std::string_view, référence non-propriétaire vers une stringJeffrey Yasskin 2013, 2014  Adopté
Ajout d'un ensemble de fonctions rapides de manipulation de chaînes de caractères ASCII dans un nouvel en-tête standard nommé <ascii>Matthew Fioravante http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4203.html 2014   
Ajout d'une bibliothèque de fonctions statiques (à la compilation) sur des chaînes de caractères, le tout sur la base de littéraux maisons Michael Price http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4236.html 2014   
Type fixed_string, dont la taille des instances est connue à la compilation Michael Price et Andrew Tomazos http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0259r0.pdf 2016   
Ajout d'un support standard pour les littéraux UTF-8, avec préfixe u8 Richard Smith http://isocpp.org/files/papers/n4267.html 2014  Adopté
Des fonctions to_string() et to_wstring() génériques Robert Kawulak http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0117r0.html 2015   
Ajout d'un text_view pour définir des intervalles Unicode Tom Honermann 2016   
Ajouter une méthode data() à std:string qui soit non-const David Sankel 2016  Adopté
Dans les fonctions de conversion strtox() pour divers x, la qualification const des chaînes de formatage est perdue. La proposition est de corriger cette situation et de préserver cette qualification James Touton http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0282r0.html 2016  Rejeté
Bien intégrer les types std::string_view et std::string Marshall Clow 2016 Argumentaire à l'effet que le design accepté à Jacksonville en 2016 est « à l'envers », soit que plutôt que de placer ce qui intègre les deux types dans string_view, on devrait plutôt le faire dans stringAdopté
Offrir des fonctions de conversion aux / vers les formats UTF-8, UTF-16 et UTF-32 Beman Dawes 2016   
Ajouter un type pour représenter les données encodées en format UTF-8 Michael Spencer et Davide C. C. Italiano http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0372r0.html 2016 En gros, pour donner un coup de barre, ceci propose d'ajouter un type char8_t qui soit explicitement (mais pas implicitement) convertible à unsigned char 
Rendre basic_stringbuf conscient des allocateurs Peter Sommerlad http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0407r0.pdf 2016   
Rendre l'accès au tampon interne d'un basic_stringbuf plus efficace Peter Sommerlad http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0408r0.pdf 2016   
Littéraux standards pour basic_string_view Marshall Clow 2016 On parle du suffixe sv 
Remplacer strstream en utilisant un span<charT> en tant que tampon Peter Sommerlad http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0448r0.pdf 2016   
Ajouter des méthodes starts_with() et ends_with() à std::basic_string Mikhail Maltsev http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0457r0.html 2016   
Ajout d'un type char8_t Tom Honermann http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0482r0.html 2016   

<chrono>

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Fignoler <chrono> Howard E. Hinnant 2015 Il manque des trucs aussi simple que ++ ou -- sur un time_point et des mécanismes pour arrondir lors d'une conversion entre deux durées (notez que ++ et -- ont été rejetés à Kona, mais que le reste de la proposition a survécu) 
Représenter les « dates civiles »Greg Miller et Bradley White http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0215r0.html 2016    
Une bibliothèque pour représenter les fuseaux horairesGreg Miller et Bradley White http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0216r0.html 2016    
Étendre <chrono> pour supporter la gestion du calendrier et des fuseaux horaires Howard E. Hinnant 2016   
Ajouter des Timing Barriers Mike Spertus http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0342r0.html 2016 L'idée est de raffiner nos pratiques de mesure du temps écoulé, même dans le cas où la fonction mesurée n'a pas d'effet de bord 
Ajouter des primitives de mesure du temps écoulé (Benchmarking) Mikhail Maltsev http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0412r0.html 2016 L'idée est d'éviter que le compilateur n'applique des optimisations indûes au code mesuré, comme par exemple le faire disparaître faute d'effets de bord à la mesure réalisée 
Améliorer le support constexpr de <chrono> Howard E. Hinnant http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0505r0.html 2016   

Conteneurs

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter une fonction génératrice make_array() Zhihao Yuan 2013,
2014,
2015		   
Intégrer make_array() directement à C++ 17 Zhihao Yuan 2016   
Faire de priority_queue, queue et stack des conteneurs à part entière plutôt que des adaptateurs sur des conteneurs existantsTim Blechmann http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3543.pdf2013   
Ajouter des opérations à set et à map Alan Talbot hhttp://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3586.pdf2013   
Ajouter des opérations à set et à map (suivi)Alan Talbot, Howard E. Hinnant, James Dennett et Jonathan Wakely http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3645.pdf2013   
Ajouter des opérations à set et à map (suivi)Alan Talbot, Howard E. Hinnant, Jonathan Wakely et James Dennett 2015, 2016   
Ajouter des paramètres aux fonctions ne modifiant pas les séquences auxquelles elles s'appliquentMike Spertus et Attila Pall 2013 Dans une optique de robustesse 
Raffiner le type des objets utilisés pour fouiller dans un conteneur associatif Jonathan Wakely, Stephan T. Lavavej et Joaquín M. López Muñoz http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3657.htm2013   
Bibliothèque complète d'arbresBernhard Reiter et René Rivera http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3700.html2013   
Tableaux multidimensionnelsDaryle Walker http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3794.html2013   
Tableaux multidimensionnelsŁukasz Mendakiewicz et Herb Sutter 2013,
2014,
2015		 Inspiré de l'approche AMP et axée vers la multiprogrammation 
Tableaux multidimensionnel partagé avec disposition polymorphiqueCarter Edwards et Christian Trott http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4355.pdf 2015 Accompagne n4356 
Relâcher les règles pour fins de déclaration de tableauxCarter Edwards et Christian Trott http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4356.pdf 2015 Accompagne n4355 
Raffinements à map et à unordered_mapThomas Köppe 2014 Entre autres, ajustement aux fonctions emplace()Adopté
Conteneurs de types incomplets Zhihao Yuan 2014, 2015 Pour faciliter la conception de conteneurs de conteneurs, même quand certains des types impliqués sont incomplets 
Ajouter des fonctions utilitaires telles que std::size(), std::empty(), std::front(), etc.Riccardo Marcangelo 2014 Inspiré de fonctions telles que std::begin() et std::end()Adopté
Ajouter une méthode release() à std::vectorJerry Liang http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4359.pdf 2015 Cette méthode s'inspirerait de ce que fait std::unique_ptr, et viserait à faciliter l'interaction avec du code C 
Permettre d'entreposer dans un std::vector des types incopiables et non-déplaçablesNevin Liber http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4416.pdf 2015   
Garantir le respect des demandes du code client lors d'un appel à reserve() sur un std::vectorNevin Liber http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4524.pdf 2015   
Un array view multidimensionnel et polymorphique, nommé array_refH. Carter Edwards et plusieurs autres 2015, 2016 On parle bien d'un tableau multidimensionnel, pas d'un tableau de tableaux de tableaux... 
Déclarations de types array view multidimensionnels incompletsH. Carter Edwards et plusieurs autres 2016 Pour faciliter leur déclaration a priori 
Ajouter des conteneurs « plats » (Flat Containers)Sean Middleditch 2015 L'idée est d'offrir une alternative à certains conteneurs (typiquement associatifs) dont le substrat repose sur des noeuds, par des alternatives contiguës en mémoire. Fruit des travaux de SG14  
Terminologie pour les conteneurs « plats » (Flat Containers)Sean Middleditch http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0460r0.pdf 2016   
Ajouter une file circulaire (std::fixed_ring, std::dynamic_ring)Guy Davidson http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0059r0.pdf 2015 Fruit des travaux de SG14  
Ajouter une file circulaire (std::ring_span)Guy Davidson, Arthur O'Dwyer 2016 Fruit des travaux de SG14  
Ajouter une file circulaire (std::ring_span)Guy Davidson, Arthur O'Dwyer, Joe Best-Rotheray 2016 Fruit des travaux de SG14  
Rendre le comparateur owner_less plus pratique Jonathan Wakely http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0074r0.html 2015   
Modifier le type de retour de la méthode emplace_back()Alan Talbot 2015, 2016 L'idée est que cette méthode crée un objet, alors si elle retournait une référence on pourrait l'utiliser immédiatementAdopté
Un type array_view pour vérifier les débordements de tableauNeil MacIntosh http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0122r0.pdf 2015   
Un type span pour vérifier les débordements de conteneursNeil MacIntosh 2016   
Un type mdspan, qui servirait de span multidimensionnelH. Carter Edwards et Bryce Adelstein Lelbach http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0454r0.html 2016   
Unifier les interfaces des types array_view et string_viewNeil MacIntosh http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0123r0.pdf 2015   
Un type string_span pour vérifier les débordements de conteneursNeil MacIntosh 2016   
Un type pour représenter un petit vecteurThomas Köppe http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0210r0.html 2016 Ce type n'aurait pas d'opérations qui redimensionnent sur ajout, mais aurait un resize() 
Le type clump, petit vecteur conçu pour les systèmes embarquésNevin Lieber http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0274r0.pdf 2016   
Ajout de conteneurs immuables et persistantsBryce Adelstein Lelbach http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0334r0.html 2016 Un ajout intéressant à la bibliothèque standard pour cas d'utilisation pointus  
Ajout de conteneurs intrusifsHal Finkel http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0406r1.html 2016 En lien avec les travaux de SG14  
Ajout d'un type flat_mapZach Laine http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0429r0.pdf 2016 En lien avec les travaux de SG14, proposition basée sur Boost.FlatMap  
Ajout d'un type colonyMatthew Bentley 2016 En lien avec les travaux de SG14  
Tester la présence d'un élément dans un conteneur associatif Mikhail Maltsev http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0458r0.html 2016 Propose l'ajout d'une méthode contains() à ces conteneurs  
Ajouter un opérateur + sur deux vector<T> David Sankel http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0473r0.html 2016 Ceci modéliserait la concaténation  
Ajout d'un conteneur contiguous_container, qui se limite à l'essentiel Ildus Nezametdinov http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0494r0.pdf 2016 En lien avec les travaux de SG14  
Raffiner les types de retour des opérations de fouille dans des conteneurs associatifs Howard E. Hinnant http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0508r0.html 2016    
Offrir un Deduction Guide pour std::array qui aurait un comportement analogue à celui de la fonction make_array() Zhihao Yuan http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0511r0.html 2016    

Délégués

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Enrichir std::function pour le moderniserGeoffrey Romer et Roman Perepelitsa 2014, 2015 Certaines restrictions de std::function étaient raisonnables avec C++ 03 mais le sont moins avec C++ 11. Par exemple, rendre std::function Thread-Safe (depuis C++ 11, les implémentations tendent à solliciter les services const à travers des chemins non-const, ce qui pose un risque)  
Ajout d'un type unique_function, sorte de std::function pour les objets appelables mais incopiablesDavid Krauss 2015, 2016   
Modifier std::function pour permettre de lui apposer un allocateurDavid Krauss http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0043r0.pdf 2015 L'une des modifications proposées à std::function en vue de C++ 17 empêche de rendre ses opérations de mouvement noexcept, ce qui est très déplaisant. La proposition vise à corriger cette situation  
Permettre de surcharger une même instance de std::function pour plusieurs signatures et pour plusieurs qualifications comme const ou volatileDavid Krauss http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0045r0.pdf 2015    
Déprécier le recours aux allocateurs dans std::function Jonathan Wakely 2016 Selon l'auteur, ce mécanisme n'est pas supporté de manière homogène par la plupart des vendeurs, et est souvent ignoré Adopté
Ajout d'un type std::monostate_function Matt Calabrese http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0477r0.pdf 2016 Utilisation novatrice de template <auto>  

Entrées/ sorties

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Entrées/ sorties et chaînes de caractères entourées de guillemets Beman Dawes 2012,
2013		  Adopté
Une interface rappelant std::printf() sur les flux standards Zhihao Yuan 2012,
2013		   
Combler les manques de l'interface existante des flux standards Jens Maurer 2015, 2016 On vise une interface d'entrées / sorties à bas niveau très efficaces pour fins de conversions de données entre chaînes de caractères et types numériques, le tout sans tenir compte des locale Adopté
Les requis d'un périphérique d'entrée/ sortie pour C++Cleiton Santoia Silva et Daniel Auresco http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4463.pdf 2015    
Supprimer les alias dépréciés des iostream Alisdair Meredith http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0004r0.html 2015 Certains sont dépréciés depuis... 1998!  
Réparer operator>>(basic_istream<charT>&,charT*) Zhihao Yuan http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0487r0.html 2016 Cette proposition couvre deux volets, soit la suppression et la dépréciation de cette fonction qui, il faut bien le dire, est brisée (à moins que l'on ne l'accompagne de setw(n), mais c'est si facile à oublier...)  

Foncteurs et lieurs

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter un paramètre à std::mem_fn() pour faciliter le lien entre un objet et ses méthodesMikhail Semenov http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3702.htm2013   
Ajouter un std::invoke()Tomasz Kamiński 2013, 2014 Pour standardiser la forme de l'invocation de fonctions, foncteurs, λ, méthodes d'instance, etc. Avec support de templates de fonctions et de reference_wrapper 
Ajouter un foncteur général, std::not_fn, pour représenter la négation logique de l'exécution d'un objet appelableTomasz Kamiński 2013, 2014   
Accepter des groupes de paramètres avec std::bindTomasz Kamiński 2014, 2016 Ceci permettrait en quelque sorte d'utiliser bind de manière variadique 
Adopter rapidement std::not_fn Alisdair Meredith http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0005r0.html 2015 ... pour mieux éliminer std::not1 et std::not2 
Adopter rapidement std::not_fn (mise à jour) Alisdair Meredith, Stephan T. Lavavej et Tomasz Kamiński 2015, 2016  Adopté
Adapter reference_wrapper<T> pour le cas où T est un type incomplet Tomasz Kamiński http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0357r0.html 2016   
Adapter reference_wrapper<T> pour le cas où T est un type incomplet (suivi) Tomasz Kamiński, Stephan T. Lavavej et Alisdair Meredith http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0357r1.html 2016   
Corriger la terminologie de std::not_fin Tomasz Kamiński 2016  Adopté
Synthétiser une λ d'une expression Andrew Sutton 2015, 2016 Permettrait entre autres d'écrire : 
auto gt = (>);
...plutôt que : 
auto gt = [](const auto &a, const auto&b) {
   return a > b;
};
mais l'objectif général est de permettre d'utiliser une fonction générique dans tout contexte sans avoir à en expliciter les types ou à l'enrober explicitement dans une λ		  
Commentaires sur la proposition à l'effet de synthétiser une λ d'une expression Tomasz Kamiński http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0382r0.html 2016 L'auteur voit des conséquences surprenantes à la proposition telle que formulée, bien qu'il apprécie l'objectif visé  

Itérateurs et intervalles

La plus récente version de la spécification technique pour les intervalles est, à ma connaissance : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4620.pdf pour le Working Draft, et http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4622.pdf pour le PDTS

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter un type std::range pour permettre le parcours d'un conteneur à travers un intervalle Jeffrey Yasskin 2012,
2013		 Inspiré sans doute du langage D 
Applications des intervallesJeffrey Yasskin http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3513.html2013   
Rendre un intervalle testable comme un booléenOlaf van der Spek http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3509.htm2013 Un peu comme le sont les flux 
Exprimer un intervalle en termes d'indices plutôt qu'en termes d'itérateursArno Schödl et Fabio Fracassi 2013   
Itérer à travers une std::pair ou un std::tuple avec un intervalle Alan Talbot http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3643.pdf2013   
Ajout d'itérateurs « délimités » Mike Spertus http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3581.html2013 Pour faciliter certaines entrées/ sorties 
Ajout d'une méthode last() aux conteneurs pour lesquels cela s'y prêteAlan Talbot http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3585.pdf2013   
Ajout de Null IteratorsAlan Talbot http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3644.pdf2013 Pour les cas où un itérateur par défaut est construit sans être associé à un conteneur spécifique 
Itérateurs sur données contiguësNevin Liber http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3884.pdf 2014 Raffinement proposé aux Random Access Iterators, utile dans les cas où un itérateur doit être utilisé pour interfacer avec un langage qui ne comprend que les pointeurs 
Itérateurs sur données contiguës, suiviNevin Liber http://isocpp.org/files/papers/N4183.pdf 2014   
Itérateurs sur données contiguësJens Maurer https://isocpp.org/files/papers/n4284.html 2014  Adopté
Itérateurs délimités, raffinement du ostream_joinerMike Spertus et Nathan Wilson 2014 Complète les ostream_iterator, où le « délimiteur » lors de la projection sur le flux est un suffixe, en permettant des notations plus flexibles (incluant un délimiteur infixe)Adopté
Des catégories d'itérateurs plus précisesBill Seymour http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n4068.html 2014 Parce que pour l'instant, certains itérateurs mentent sur leur catégorie d'appartenance (couvre entre autre l'infâme vector<bool>)  
Des catégories d'itérateurs plus précises (suivi)Bill Seymour http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4124.html 2014    
Intervalles, algorithmes et enjeux Eric Niebler, Sean Parent et Andrew Sutton https://ericniebler.github.io/std/wg21/D4128.html 2014 Proposition très complète  
Algorithmes plus sécuritaires pour faire avancer un itérateur Patrick Grace http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4317.pdf 2014    
Potentielle spécification technique (TS) pour les intervalles Eric Niebler http://boost-sandbox.sourceforge.net/std/wg21/D4382.pdf 2015    
Intervalles Eric Niebler http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0021r0.pdf 2015    
Itérateurs Proxy pour intervalles Eric Niebler 2015, 2016    
Étendre les fonctionnalités de raw_storage_iterator Brent Friedman http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0039r0.html 2015 Fruit des travaux de SG14  
Étendre les capacités des boucles for sur des intervalles Eric Niebler http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0184r0.html 2016 Dans l'optique d'une meilleure intégration avec les intervalles tels que pris comme évolution de la STL Adopté
Offrir une façade d'itérateurs pour les intervalles Beman Dawes, Eric Niebler et Casey Carter http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0186r0.html 2016    
Introduire des expressions UpTo Mike Spertus et Andrew Tomazos http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0268r0.pdf 2016 Permettre des trucs comme
for(int i : [0..5))
   f(i);
 Rejeté
Mise à jour du design de la spécification technique des intervalles Casey Carter et Eric Niebler 2016 Repose fortement sur les concepts  
Fusionner Writable et MoveWritable dans le design de la spécification technique des intervalles Casey Carter et Eric Niebler 2016 L'expérience semble montrer que notre vision des itérateurs demandait à être raffinée  
Proposition « spéculative » de spécification technique pour les intervalles Casey Carter et Eric Niebler http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0459r0.pdf 2016 Fusionne P0370 et P0441 avec N4560  
Ajouter une version simplifiée (à un seul paramètre) du type std::inserter David Sankel http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0471r0.html 2016 Cette proposition découle du constat qu'il est très rare que le paramètre hint d'un std::inserter soit réellement utilisé  

Réseautique et Internet

À ma connaissance, la plus récente version du Working Draft sur la réseautique est http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4626.pdf alors que la plus récente version du PDTS est http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4625.pdf

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajout d'un type standard pour représenter les URI Dean Michael Berris http://www.cplusplus-soup.com/2012/09/c-standard-proposals-standard-uri-type.html2012
Ajout d'un type standard pour représenter les URI (suivi) Glyn Matthews et Dean Michael Berris 2013, 2014   
Représenter une adresse IP Aleksandar Fabijanic http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3565.pdf2013   
Représenter une adresse IP (mise à jour) Christopher Kohlhoff 2013, 2014   
Ajout de services pour les conversions vers/de le Network Byte Ordering Kyle Kloepper http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3620.pdf2013   
Ajout de services pour les conversions vers/de le Network Byte Ordering Robert Pratte 2013  Adopté
La primitive de réseautique htonl() poserait problème... du fait qu'elle et ses cousines ont historiquement été des macros!James Craig Burley et plusieurs autres http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4249.html 2014 Les auteurs recommandent essentiellement de choisir un nom qui ne posera pas de conflit avec les noms dans les bibliothèques classiques du langage C 
Bibliothèque de réseautiqueChristopher Kohlhoff 2014, 2015 Inspirée de Boost.AsioAdopté
TS de la bibliothèque de réseautique (plus récente version) Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/n4612.pdf 2016   
Terminologie mise à jour lors de la rencontre de Kona en 2015 pour la bibliothèque de réseautique Jonathan Wakely http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0405r0.html 2016   
Un type endian Howard E. Hinnant http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0463r0.html 2016   

Stochastique

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Raffinements à <random> Walter E. Brown 2013
Expliquer les difficultés propres à la génération des nombres pseudo-aléatoires, et encourager les bonnes pratiques Walter E. Brown http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3847.pdf 2014   
Ajout d'un type sample Walter E. Brown 2014 Pour faciliter l'échantillonnage de données dans une séquence de taille a priori connue ou nonAdopté
Argumentaire à l'effet qu'une critique portée sur la cohérence d'une proposition de distribution pseudo-aléatoire n'est en fait pas une défectuosité Walter E. Brown http://isocpp.org/files/papers/N3926.pdf2014   
Déprécier std::rand() et les outils connexes Zhihao Yuan http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3796.html2013   
Déprécier std::rand() et les outils connexes Stephan T. Lavavej http://view.officeapps.live.com/op/view.aspx?src=http%3a%2f%2fvideo.ch9.ms%2fsessions%2fgonat%2f2013%2fSTLGN13rand.pptx2013 Un plaidoyer 
Déprécier std::rand() et les outils connexes (suivi) Zhihao Yuan http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4217.html2014 Met l'accent sur le remplacement de std::rand() 
Un remplacement pour std::rand() Zhihao Yuan 2014, 2015   
Supprimer (pas juste déprécier) des trucs qui sont vraiment désuets, comme std::auto_ptr, std::random_shuffle(), std::bind2nd, etc. Stephan T. Lavavej http://isocpp.org/files/papers/N4190.txt2014  Adopté
Reformuler des passages du standard du langage pour décourager l'utilisation de std::rand() avec C++ 14 Walter E. Brown 2014  Adopté
Remplacer random_shuffle() par shuffle() Walter E. Brown 2013,
2016		   
Améliorer la qualité de programmes exécutant plusieurs générateurs de nombres pseudoaléatoires concurremment Pattabhi http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0010r0.pdf 2016   
Permettre d'initialiser un générateur de nombres pseudoaléatoires directement à partir d'un std::random_device Moritz Klammler http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0205r0.html 2016 L'auteur pense que ce serait plus simple que d'utiliser le random_device comme un foncteur une fois celui-ci construit 
Améliorer (légèrement) la nomenclature utilisée dans <random> Walter E. Brown 2016 Précision terminologique à l'effet que les outils génèrent non pas des nombres pseudoaléatoires mais bien des bits pseudoaléatoiresAdopté
Simplifier la saine utilisation de <random> R "Tim" Song et Melissa O'Neill 2016 Bien utiliser <random> est plus difficile qu'il n'y paraît 
Vers une spécification technique pour <random> Walter E. Brown http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0438r0.pdf 2016 Le projet est de considérer les diverses propositions d'amélioration de <random> comme un tout et de produire une spécification technique en ce sens 
Ajout d'un algorithme inplace_sample() R "Tim" Song http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0469r0.html 2016 Serait une version de sample() réalisant une partition des éléments plutôt qu'une copie 

Systèmes de fichiers

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Une interface standard au système de fichiers Beman Dawes http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3335.html2012 Enfin! 
Une interface standard au système de fichiers (suivi) Beman Dawes http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3505.html2013   
Une interface standard au système de fichiers (suivi) Beman Dawes http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3693.html2013   
Une interface standard au système de fichiers (suivi) Beman Dawes http://isocpp.org/files/papers/n3790.html2013    
Une interface standard au système de fichiers (suivi) Beman Dawes http://isocpp.org/files/papers/n3803.pdf 2013   
Une interface standard au système de fichiers (suivi) Plusieurs personnes http://isocpp.org/files/papers/N3906.pdf 2014   
Une interface standard au système de fichiers (mise à jour) Beman Dawes http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n3940.html 2014   
Une interface standard au système de fichiers (mise à jour) Beman Dawes http://isocpp.org/files/papers/n4099.html 2014   
Une interface standard au système de fichiers (mise à jour) Beman Dawes http://cplusplus.github.io/filesystem-ts/working-draft.html 2015   
Faciliter le référencement de chemins relatif Jamie Allsop et Nicolai M. Josuttis http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0011r0.html 2015   
Une interface standard au système de fichiers (mise à jour) Beman Dawes http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0218r0.html 2016   
Une interface standard au système de fichiers (mise à jour) Beman Dawes http://isocpp.org/files/papers/P0218r1.html 2016  Adopté
Gestion des chemins relatifs Beman Dawes 2016  Adopté
Implémenter le Caching des entrées d'un répertoire Beman Dawes 2016   
Intégrer string_view à l'interface aux systèmes de fichiers Nicolai M. Josuttis http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0392r0.pdf 2016  Adopté
Clarifier la terminologie de l'interface aux systèmes de fichiers dans le cas de systèmes autres que POSIX Jason Liu et Hubert Tong 2016   

Types utilitaires

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter un type std::any pour standardiser l'effacement de types Beman Dawes et Kevlin Henney http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3508.html2013   
Ajouter un type std::any pour standardiser l'effacement de types (raffinement) Beman Dawes, Kevlin Henney et Daniel Krügler http://isocpp.org/files/papers/n3804.html2013   
Ajouter un type std::dateStefano Pacifico, Alisdair Meredith et John Lakos http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3344.pdf2012 Enfin! 
Ajouter les types requis pour traiter les dates civiques, sans plus Bill Seymour http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0034r0.html 2015 Proposition qui se veut pragmatique, du fait que construire un type date complet est très difficile 
Proposition de nouveaux objets RAII Andrew L. Sandoval http://open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3677.html 2013 Par exemple, un type scoped_resource 
Proposition de nouveaux objets RAII (suivi) Peter Sommerlad et Andrew L. Sandoval 2014, 2015, 2016   
Accéder aux éléments d'un uplet par type lorsque cela ne mène pas à une expression ambiguë Mike Spertus http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3584.html 2013 Raffinements à <tuple> 
Ajouter type_at<> et value_at<> Sean Middleditch http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3761.html 2013 Raffinements à <tuple>  
Raffinements proposés pour std::pair et std::tuple Daniel Krügler 2013, 2014   
Raffinements proposés pour std::pair et std::tuple (suivi) Daniel Krügler, Geoffrey Romer et Ville Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4387.html 2015   
Définir std::tuple_size même dans le cas général, pour faciliter l'exploitation de SFINAE Nevin Liber http://isocpp.org/files/papers/N4386.pdf 2015 Raffinements à <tuple>  
Ajouter la monade expected<E,T> Vicente J. Botet Escriba et Pierre Talbot 2014, 2016 Cousin du type optional<T> voué à la gestion des erreurs dans les types de retour : le type T est le type de retour attendu, et le type E est le type de retour dans le cas où il n'a pas été possible de livrer un T (E ici représente ce que le code client recevra en cas d'erreur) 
Ajouter la monade expected<E,T> Vicente J. Botet Escriba http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0323r1.pdf 2016   
Formaliser des fonctions Data-Invariant, dont le temps d'exécution est le même peu importe les données sur lesquelles elles opèrent, avec un type std::constant_time::value<T> Jens Maurer http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4145.html 2014 Pour un attaquant d'un système sécurisé, constater le temps requis pour exécuter un calcul est une information précieuse... Ce que ce type vise à éviter. Utile pour les systèmes temps réel et pour des systèmes de sécurité  
Ajout d'un std::bitset qui serait fortement typé Matthew Fioravante http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4202.html 2014 L'idée serait de compléter std::bitset<N> par std::bitset<N,T>  
Ajout d'un type interne et public size_type à std::bitsetVladimir Grigoriev 2015    
Services ensemblistes pour std::bitset Vittorio Romeo http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0125r0.html 2015    
Étendre les opérations sur un std::bitset pour le rapprocher des conteneursNathan Myers http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0161r0.pdf 2016    
Ajouter l'option multiligne aux expressions régulières de format ECMAScriptNozomu Katō 2015    
Interaction des expressions régulières avec le standard UnicodeNozomu Katō http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0169r0.html 2015    
Conversion implicite vers bool pour certains types de la bibliothèque standardRobert Kawulak http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0116r0.html 2015    
Utiliser un tuple en tant que source pour fabriquer un objet, avec make_from_tuple()Pablo Halpern 2016 Raffinements à <tuple> Adopté
Ajout d'un type std::byteNeil MacIntosh 2016 Parce que char et unsigned char sont des types un peu magiques au sens de l'aliasing, ce qui peut ne pas convenir dans certains contextes  
Définir le type std::byteNeil MacIntosh 2016    
Généraliser les fonctions std::invoke(), std::apply() et std::visit() dans une seule et même fonction std::call()Matt Calabrese http://open-std.org/JTC1/SC22/WG21/docs/papers/2016/p0376r0.html 2016    

Le cas particulier du type optional<T> :

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Ajouter un type optional<T>Fernando Cacciola et Andrzej Krzemieński http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3527.html2013   
Ajouter un type optional<T> (raffinement) Fernando Cacciola et Andrzej Krzemieński http://isocpp.org/files/papers/N3672.html2013   Adopté
Réflexions sur les opérateurs relationnels et optional<T> Ville Voutilainen http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3764.html 2013   
Réflexions sur les opérateurs relationnels et optional<T> Tony Van Eerd http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3765.pdf 2013   
Ajouter un type optional<T> (mise à jour) Fernando Cacciola et Andrzej Krzemieński http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2013/n3793.html 2013   
Ajouter un type optional<T> (correctifs de formulation) Fernando Cacciola et Andrzej Krzemieński http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2014/n3966.html 2014   
Raffinements au type optional<T> Jeffrey Yasskin http://isocpp.org/files/papers/N3848.html 2014   
Ajouter quelques surchages de méthodes impliquant des références sur des rvalue à optional<T> Andrzej Krzemieński http://isocpp.org/files/papers/n3982.html 2014   
Ajouter une classe pour représenter à la fois un état et une valeur optionnelle Lawrence Crowl et Chris Mysen http://open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4233.html 2014   
Ajouter une classe pour représenter à la fois un état et une valeur optionnelle (suivi) Lawrence Crowl et Chris Mysen 2016 On parle ici d'un status_value<S,V> qui exposerait un service value() de même que d'un service status(), et qui serait testable pour reconnaître lequel des deux est pertinent 
Faire en sorte que l'opérateur >= sur du type optional<T> fonctionne correctementTony Van Eerd 2016  Adopté

En 2014, Andrzej Krzemieński souligne un irritant « caché » avec optional<T>, soit le fait qu'il soit implicitement Less-than-Comparableable, et ce même s'il est none : https://akrzemi1.wordpress.com/2014/12/02/a-gotcha-with-optional/

Domaines d'application

À propos des travaux dans des domaines d'application spécifiques

Jeu, systèmes temps réel et embarqués

Pour un suivi des travaux, voir :

SujetProposeur(s) URLAnnéeRemarquesVerdict?
Améliorer le support du développement de jeu vidéo, de STR et de systèmes embarqués Michael Wong, Sean Middleditch et Nicolas Guillemot 2015 Pour un peu de Background sur ces travaux, voir http://seanmiddleditch.com/c-paper-n4456-survey-of-c-problems-for-game-development/ par Sean Middleditch 
Un compilateur pour plateformes hétérogènes, le compilateur HCC Ben Sander, Greg Stoner, Siu-chi Chan, Wen-Heng (Jack) Chung et Robin Maffeo http://open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0069r0.pdf 2015   

Valid XHTML 1.0 Transitional

CSS Valide !