🔝 Retour au Sommaire
Au moment de la rédaction de cette section (mars 2026), le standard C++26 est dans sa phase finale de ratification. Le gel des fonctionnalités a eu lieu à Sofia en juin 2025, les commentaires du ballot international ont été traités à Kona en novembre 2025, et le comité se réunit à Londres/Croydon (23-28 mars 2026) pour résoudre les derniers commentaires et finaliser techniquement le brouillon avant le vote d'approbation final. La publication officielle est attendue dans le courant de l'année 2026.
Le support compilateur de C++26 est, naturellement, partiel et expérimental. Les compilateurs implémentent les fonctionnalités progressivement, souvent avant la finalisation du standard. Le flag -std=c++2c (GCC, Clang) ou /std:c++latest (MSVC) active les fonctionnalités C++26 disponibles.
Les ajouts de taille modérée — ceux qui ne nécessitent pas de changements architecturaux dans le compilateur — sont généralement implémentés en avance ou rapidement après leur adoption dans le brouillon du standard.
┌─────────────────────────────────────────┬────────┬──────────┬────────┐
│ Fonctionnalité │ GCC │ Clang │ MSVC │
├─────────────────────────────────────────┼────────┼──────────┼────────┤
│ Placeholder _ (P2169) │ 14 │ 18 │ — │
│ = delete("reason") (P2573) │ 15 │ 20 │ — │
│ #embed (P1967) │ 15 * │ 19 * │ — │
│ Structured bindings in conditions │ 15 │ 20 │ — │
│ (P0963) │ │ │ │
│ constexpr placement new (P2747) │ 15 │ — │ — │
│ Erroneous behaviour for │ 15 │ — │ — │
│ uninitialized reads (P2795) │ │ │ │
│ Pack indexing (P2662) │ 15 │ 19 │ — │
│ Deprecate comma in subscript (P2961) │ 15 │ 20 │ — │
│ static_assert message from │ 15 │ 20 │ — │
│ user-generated string (P2741) │ │ │ │
└─────────────────────────────────────────┴────────┴──────────┴────────┘
* = support partiel ou expérimental
— = pas encore supporté (à vérifier avec les dernières versions)
GCC est historiquement le compilateur le plus rapide à implémenter les nouvelles fonctionnalités du langage, suivi par Clang. MSVC rattrape généralement avec un décalage d'une à deux releases.
Les contrats sont une fonctionnalité de taille moyenne en termes de complexité d'implémentation — ils nécessitent de nouveaux mots-clés (pre, post, contract_assert), une infrastructure de violation handling, et des flags de compilation pour contrôler les sémantiques d'évaluation, mais pas de changement fondamental du modèle de compilation.
┌─────────────────────────────────────────┬────────┬──────────┬────────┐
│ Contrats │ GCC │ Clang │ MSVC │
├─────────────────────────────────────────┼────────┼──────────┼────────┤
│ Syntaxe pre / post / contract_assert │ Exp. │ Exp. * │ — │
│ Sémantiques enforce / ignore │ Exp. │ Exp. * │ — │
│ Sémantiques observe / quick_enforce │ Exp. │ Exp. * │ — │
│ Violation handler personnalisé │ Exp. │ Exp. * │ — │
└─────────────────────────────────────────┴────────┴──────────┴────────┘
Exp. = Expérimental (disponible via des flags spécifiques ou des branches)
* = Fork expérimental de Clang (Eric Fiselier) disponible sur Compiler Explorer
Des variantes expérimentales de GCC et de Clang supportant les contrats sont disponibles sur Compiler Explorer. L'implémentation a été décrite comme « peu complexe » par les auteurs de la proposition — l'ajout du support dans un build system comme CMake a pris moins d'une heure selon les retours des développeurs. Le support complet dans les versions de production est attendu dans les prochaines releases majeures (GCC 16, Clang 21).
La réflexion statique est la fonctionnalité la plus ambitieuse de C++26 en termes d'implémentation. Elle nécessite un nouveau type opaque (std::meta::info), un nouvel opérateur (^^), un nouvel opérateur de splice ([: :]), des expansion statements (template for), et un ensemble riche de fonctions consteval dans le header <meta>. C'est un changement profond du frontend du compilateur.
┌─────────────────────────────────────────┬────────┬──────────┬────────┐
│ Réflexion statique │ GCC │ Clang │ MSVC │
├─────────────────────────────────────────┼────────┼──────────┼────────┤
│ Opérateur ^^ (reflect) │ 16 * │ Fork * │ — │
│ Opérateur [: :] (splice) │ 16 * │ Fork * │ — │
│ std::meta::info │ 16 * │ Fork * │ — │
│ nonstatic_data_members_of, etc. │ 16 * │ Fork * │ — │
│ Expansion statements (template for) │ 16 * │ — │ — │
│ Consteval blocks (P3289) │ — │ Fork * │ — │
│ Annotations (P3394) │ — │ — │ — │
└─────────────────────────────────────────┴────────┴──────────┴────────┘
* GCC 16 = trunk/développement (pas encore release en mars 2026)
* Fork = Bloomberg/Clang-P2996 (fork expérimental, disponible sur Compiler Explorer)
L'état en mars 2026 est le suivant :
GCC — Le support de la réflexion a été fusionné dans le trunk de GCC (ce qui sera GCC 16). Les fonctionnalités fondamentales — ^^, [: :], les fonctions std::meta de base, et les expansion statements — sont implémentées. GCC est le premier compilateur de production à intégrer la réflexion dans son trunk principal.
Clang — Le fork Bloomberg/Clang-P2996 reste l'implémentation la plus complète de P2996. Il est activement développé et disponible sur Compiler Explorer. L'intégration dans Clang mainline n'est pas encore effective en mars 2026, mais le travail est en cours. Le frontend EDG (utilisé par le compilateur NVIDIA) dispose également d'un support substantiel.
MSVC — Pas de support annoncé en mars 2026. L'implémentation est attendue dans les futures versions de Visual Studio.
L'horizon réaliste pour un support complet et stable dans les trois compilateurs de production est 2027-2028. En attendant, les développeurs peuvent expérimenter sur Compiler Explorer avec les forks expérimentaux et le trunk GCC.
std::execution est une fonctionnalité de bibliothèque — elle ne nécessite pas de changements du langage mais un travail considérable dans les implémentations de la bibliothèque standard (libstdc++, libc++, MSVC STL).
┌─────────────────────────────────────────┬────────────┬──────────┬──────────┐
│ std::execution │ libstdc++ │ libc++ │ MSVC STL │
├─────────────────────────────────────────┼────────────┼──────────┼──────────┤
│ Concepts sender, receiver, scheduler │ En cours │ En cours │ En cours │
│ Algorithmes (then, when_all, etc.) │ En cours │ En cours │ En cours │
│ run_loop │ En cours │ En cours │ En cours │
│ system_context (P2079) │ — │ — │ — │
└─────────────────────────────────────────┴────────────┴──────────┴──────────┘
En mars 2026, aucune bibliothèque standard de production ne fournit encore std::execution. L'intégration est en cours dans les trois implémentations. Les développeurs qui souhaitent utiliser le modèle Sender/Receiver dès maintenant doivent passer par les implémentations de référence :
- stdexec (NVIDIA) — L'implémentation la plus complète et la plus active.
- libunifex (Meta) — Implémentation mature déployée en production.
- Beman Project — Implémentation communautaire visant la conformité C++26.
┌─────────────────────────────────────────┬────────────┬──────────┬──────────┐
│ Bibliothèque C++26 │ libstdc++ │ libc++ │ MSVC STL │
├─────────────────────────────────────────┼────────────┼──────────┼──────────┤
│ std::simd (P1928) │ En cours │ En cours │ — │
│ std::hive (P0447) │ — │ — │ — │
│ std::linalg (P1673) │ En cours │ — │ — │
│ <contracts> (violation handler) │ Exp. │ Exp. │ — │
│ <debugging> (P2546) │ — │ — │ — │
│ std::hazard_pointer (P2530) │ — │ — │ — │
│ std::rcu (P2545) │ — │ — │ — │
│ Hardening de la stdlib (P3471) │ Partiel │ Partiel │ — │
└─────────────────────────────────────────┴────────────┴──────────┴──────────┘
Les fonctionnalités de bibliothèque suivent un rythme d'implémentation plus lent que les fonctionnalités du langage, car elles nécessitent un travail d'ingénierie substantiel dans les implémentations de la bibliothèque standard, et les ressources des équipes sont limitées.
# Activer C++26 (expérimental)
g++ -std=c++2c main.cpp -o app
# Avec extensions GNU
g++ -std=gnu++2c main.cpp -o app
# Vérifier les fonctionnalités C++26 disponibles
g++ -std=c++2c -dM -E - < /dev/null | grep __cppLe flag deviendra -std=c++26 une fois le standard officiellement publié. Pour l'instant, -std=c++2c est la convention (« c++2c » pour « C++ two-c » → C++26, le standard dont le numéro finit en 6).
# Activer C++26 (expérimental)
clang++ -std=c++2c main.cpp -o app
# Avec la bibliothèque standard libc++
clang++ -std=c++2c -stdlib=libc++ main.cpp -o appPour les fonctionnalités spécifiques (réflexion, contrats), des forks expérimentaux sont disponibles sur Compiler Explorer avec des flags dédiés (-freflection, -fcontracts, -fpattern-matching).
# Activer les dernières fonctionnalités (inclut C++26 expérimental)
cl /std:c++latest main.cppcmake_minimum_required(VERSION 3.28)
project(my_project CXX)
# Demander C++26
set(CMAKE_CXX_STANDARD 26)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Alternative : utiliser target_compile_features
add_executable(app main.cpp)
target_compile_features(app PRIVATE cxx_std_26)
⚠️ CMake reconnaîtcxx_std_26dans les versions récentes (3.31+). Pour les versions antérieures, utiliserset(CMAKE_CXX_STANDARD 26)directement.
Compiler Explorer (godbolt.org) est l'outil indispensable pour tester les fonctionnalités C++26 avant qu'elles ne soient disponibles dans les compilateurs de production. Plusieurs variantes de compilateurs sont disponibles spécifiquement pour C++26 :
- x86-64 GCC (trunk) — Les dernières fonctionnalités intégrées dans le trunk GCC, incluant la réflexion.
- x86-64 Clang (p2996) — Le fork Bloomberg avec le support de la réflexion.
- x86-64 Clang (contracts) — Le fork avec le support des contrats.
- x86-64 Clang (pattern matching - P2688) — Le fork avec le pattern matching.
- EDG — Le frontend EDG avec support de la réflexion.
Ces variantes permettent d'expérimenter avec la syntaxe, de valider des snippets, et de se familiariser avec les fonctionnalités avant leur disponibilité dans les compilateurs installés localement.
L'histoire des standards précédents fournit une grille de lecture pour anticiper le rythme d'implémentation :
Fonctionnalités « petites » Fonctionnalités « majeures »
(placeholder _, #embed, (réflexion, contrats,
delete("reason"), etc.) std::execution)
C++20 : Concepts, Ranges C++20 : Modules, Coroutines
→ GCC 10, Clang 10 (2020) → Implémentation complète ~2024
C++23 : expected, print, flat_map C++23 : —
→ GCC 13-14, Clang 17-18 (pas de fonctionnalité majeure)
C++26 : _, #embed, structured C++26 : Réflexion, Contrats,
bindings in conditions std::execution
→ GCC 15, Clang 19-20 (2025) → Implémentation complète estimée
2027-2028
Le pattern est cohérent : les fonctionnalités de taille modérée sont implémentées dans l'année suivant leur adoption, parfois avant. Les fonctionnalités architecturales (modules, coroutines, réflexion) prennent 3 à 5 ans entre l'adoption dans le standard et une implémentation complète et stable dans les trois compilateurs.
Pour C++26, l'estimation raisonnable est :
- 2026 — Fonctionnalités petites largement disponibles. Contrats expérimentaux dans GCC et Clang. Réflexion disponible dans le trunk GCC et les forks Clang.
- 2027 — Contrats stables dans GCC 16 et Clang 21. Réflexion partielle dans Clang mainline et MSVC.
std::executiondans au moins une bibliothèque standard. - 2028 — Réflexion complète dans les trois compilateurs.
std::executionlargement disponible. Pattern matching (C++29) en cours d'implémentation.
Adopter les fonctionnalités petites dès maintenant. Le placeholder _, #embed, structured bindings dans les conditions, = delete("reason") — ces ajouts sont stables, bien supportés dans GCC 15 et Clang 20, et améliorent immédiatement la qualité du code.
Expérimenter avec les contrats sur Compiler Explorer. La syntaxe est simple et la courbe d'apprentissage douce. Se familiariser maintenant permet d'être prêt quand le support sera stable dans les compilateurs de production.
Expérimenter avec la réflexion sur Compiler Explorer. Le fork Bloomberg/Clang et le trunk GCC permettent de tester les patterns de base (enum-to-string, sérialisation). Le code écrit aujourd'hui sera fonctionnel avec les compilateurs de production quand le support arrivera.
Utiliser stdexec pour std::execution. Ne pas attendre l'intégration dans la bibliothèque standard — stdexec est mature, testée en production, et son API est alignée avec le standard.
Suivre cppstat.dev et cppreference.com. Le site cppstat.dev offre une vue en temps réel du support de chaque fonctionnalité par chaque compilateur. C'est la référence pour planifier l'adoption de fonctionnalités spécifiques.
Mettre à jour les compilateurs régulièrement. Chaque release de GCC et Clang apporte de nouvelles fonctionnalités C++26. Rester sur la dernière version maximise le support disponible.
Ne pas bloquer les projets sur C++26. La majorité du code C++ en production est en C++17 ou C++20. Les fonctionnalités de C++23 (expected, print, flat_map, generator) sont largement disponibles et apportent déjà des bénéfices considérables. Migrer vers C++23 en premier, puis adopter les fonctionnalités C++26 progressivement quand le support est disponible.