Améliorations de conformité C/C++, modifications de comportement et correctifs de bogues dans Microsoft C++ (MSVC) Build Tools

Microsoft C++ (MSVC) Build Tools apporte des améliorations de conformité et des correctifs de bogues dans chaque version. À compter de Visual Studio 2026 version 18.0, les principales améliorations sont organisées par le numéro de version msVC Build Tools. Pour accéder directement aux modifications d’une version spécifique, utilisez les liens Dans cet article en haut de cet article.

Pour les modifications apportées aux versions antérieures de Visual Studio :

Améliorations de conformité C++, modifications de comportement et correctifs de bogues dans MSVC Build Tools v14.50

MSVC Build Tools v14.50 introduit des améliorations apportées au compilateur MSVC et à la bibliothèque standard, notamment une meilleure conformité aux normes C++23, une fiabilité améliorée et une meilleure exactitude. Cette version inclut également de nombreux correctifs de bogues et mises à jour qui tirent parti du développement C++ à grande échelle.

Cette version est fournie en premier avec Visual Studio 2026 version 18.0 et inclut la version 19.50 du compilateur MSVC.

Les principaux points forts de cette version sont les suivants :

• Prise en charge avancée des fonctionnalités C++23, y compris auto(x) decay-copy et la directive #warning.
• Améliorations complètes constexpr , en particulier pour les fonctions virtuelles.
• Améliorations majeures de la stabilité pour les modules C++.
• Corrections de fiabilité étendues réduisant les erreurs internes du compilateur.
• Prise en charge améliorée de C++/CLI pour les scénarios de code managé.
• La bibliothèque standard Microsoft C++ (MSVC STL) ne prend plus en charge le ciblage de Windows 7/Server 2008 R2, Windows 8/Server 2012 ou Windows 8.1/Server 2012 R2.
• Windows 10/Server 2016 est le système d’exploitation minimum pris en charge.

Pour plus d’informations sur les améliorations des performances, les correctifs de bogues et les mises à jour de conformité dans la bibliothèque standard, consultez STL Changelog, qui est mis à jour régulièrement.

Fonctionnalités C++23

MSVC Build Tools v14.50 ajoute la prise en charge de plusieurs fonctionnalités C++23, ce qui rapproche le compilateur de la conformité complète C++23.

P0849R8 : auto(x) - décroissance-copie dans la langue

P0849R8 introduit la syntaxe auto(x) pour les opérations de copie par désintégration directement dans le langage, offrant un moyen plus concis d’exprimer la sémantique des copies par désintégration.

Avant P0849R8, vous devez effectuer explicitement des opérations de désintégration :

// Before P0849R8:
void pop_front_alike(auto& x)
{
    using T = std::decay_t<decltype(x.front())>;
    std::erase(x, T(x.front()));
}

Après P0849R8, vous pouvez utiliser la syntaxe plus simple auto(x) :

// After P0849R8:
void pop_front_alike(auto& x)
{
    std::erase(x, auto(x.front()));
}

Cette fonctionnalité offre un moyen standardisé de réaliser des opérations de copie de désintégration, ce qui améliore la lisibilité du code et réduit le besoin de métaprogrammation excessive avec des modèles.

P2437R1 : directive C++23 #warning

P2437R1 implémente la directive de préprocesseur C++23 #warning , fournissant un moyen standard d’émettre des avertissements pendant la compilation.

// Valid before C++23.
#error bad configuration...

// Valid after C++23.
#warning configuration deprecated...

La #warning directive vous permet d’émettre des messages de diagnostic sans arrêter la compilation et est donc utile pour les avis d'obsolescence et les avertissements de configuration. Pour plus d’informations, consultez #warning directive (C/C++).

Problème CWG 2586 : paramètre d’objet explicite pour l’affectation et la comparaison

Le problème CWG 2586 autorise les paramètres d’objet explicites dans les opérateurs d’affectation et de comparaison, ce qui permet des définitions d’opérateurs plus flexibles.

struct S
{
  S& operator=(this S&, const S&) = default; // Valid after CWG2586.
  auto operator<=>(this const S&, const S&) = default; // Valid after CWG2586.
};

Cette modification vous permet d’utiliser la syntaxe de paramètre d’objet explicite (déduisant this) dans les opérateurs d’affectation et de comparaison, en fournissant une syntaxe plus cohérente entre différents types de fonctions membres.

P2266R1 : déplacement implicite plus simple

L’introduction de P2266R1 peut entraîner le traitement du code qui était auparavant considéré comme une valeur lvalue, et peut maintenant être traité comme une valeur xvalue ou prvalue. Par exemple:

#include <utility>

template<typename T>
T& f(T&& t)
{
   return t;
}

struct S { };

void g()
{
   S s1{ };
   S& s2 = f(std::move(s1));
}

Dans C++20 et les versions antérieures, ce code se compilait parce que, même si le type de t est S&&, l’utilisation de t dans return t est traitée comme une glvalue et peut donc être liée au type de retour.
Avec C++23, t est traité comme une valeur xvalue et ne peut donc pas être lié à une référence lvalue.
La correction consiste à modifier le type de retour de la fonction de T& à T&&, mais cela peut affecter le code qui appelle cette fonction. Une alternative consiste à utiliser la macro de test de fonctionnalités associée à cette modification. Par exemple:

#include <type_traits>

template<typename T>
T& f(T&& t)
{
#if defined(__cpp_implicit_move)
   return static_cast<std::remove_reference_t<T>&>(t);
#else
   return t;
#endif
}

L’ajout du cast signifie que la catégorie valeur de l’expression de retour est désormais une valeur lvalue et qu’elle peut donc être liée au type de retour.

P2280R4 : références à des valeurs inconnues lors de l’évaluation constante

P2280R4 permet des références à des valeurs inconnues lors de l’évaluation constante, en assouplissant les restrictions sur constexpr l’évaluation.

template <typename T, size_t N>
constexpr size_t array_size(T (&)[N])
{
    return N;
}

void check(int const (&param)[3])
{
    constexpr auto s2 = array_size(param); // Previously ill-formed, now accepted as a constant expression after P2280R4.
}

Cette amélioration permet d’évaluer davantage de code au moment de la compilation, en particulier lorsque vous traitez des paramètres de fonction dans des contextes de modèle.

Améliorations de la conformité

L’adhésion améliorée aux normes C++ inclut une meilleure gestion des attributs, des modèles et des fonctionnalités C++20/C++23.

Prise en charge des attributs

• Ajout de la prise en charge pour [[maybe_unused]] les étiquettes.
• Résolution de l’avertissement C4102 (étiquette non référencée) lorsque la seule référence provient d'une branche supprimée if constexpr.

Correctifs de modèle et de spécialisation

• Spécialisations explicites de `friend` mal formées diagnostiquées qui ont été incorrectement acceptées en C++20 ou version ultérieure.
• Ajout /Zc:enumEncoding d’un commutateur pour encoder correctement les paramètres de modèle non-type enum.
• Correction des problèmes liés aux diagnostics de mots clés « template » manquants

Fonctionnalités C++20 et C++23

• Prise en charge multidimensionnelle operator[] améliorée
• Amélioration du concept et de l’évaluation des contraintes

Mises à jour de conformité plus petites

MSVC Build Tools v14.50 inclut de nombreuses améliorations de conformité plus petites qui améliorent la conformité standard C++ :

• CWG2635 : Prise en charge des liaisons structurées restreintes
• CWG2465 : paramètres coroutine passés aux améliorations du constructeur promises
• CWG2496 : qualificateurs de référence et corrections de surcharge virtuelle
• CWG2506 : correctifs des liaisons de structure et des qualificateurs de cv de tableau
• CWG2507 : arguments par défaut pour le support operator[]
• CWG2585 : Alignement du comportement avec les exigences standard
• CWG2521 : dépréciation de 'operator string-littéral identifier'
• CWG2528 : règles de conversion assouplies pour l’opérateur de vaisseau spatial
• P2360R0 : définition d’instruction init étendue pour autoriser les déclarations d’alias
• P2290R3 : Prise en charge des séquences d'échappement délimitées hexadécimales/octales dans les littéraux de chaîne en C++23
• P2797R0 : Résolution de CWG2692 concernant les fonctions membres d’objet statiques et explicites avec les mêmes listes de types de paramètres
• P2266R3 : sémantique de déplacement implicite plus simple

Corrections de bugs

Des correctifs de bogues pour les modules constexprC++ et d’autres correctifs ont été effectués dans MSVC Build Tools v14.50.

Pour obtenir la liste détaillée des correctifs de bogues, consultez Améliorations du compilateur dans la version 14.50.

Encodage de certains arguments de modèle nontype corrigés

/std:c++20 Affecte ou version ultérieure.

Certains arguments de modèle pour des types de pointeurs non typés impliquant des sous-objets peuvent provoquer des problèmes de liaison, ou, dans certains cas, une génération de code défectueuse et silencieuse où des spécialisations distinctes devraient entrer en collision.

struct A
{
    int x;
};

struct B
{
    int y;
};

template <auto p> void f();

int main()
{
    static A a;
    static B b;
    constexpr auto px = &a.x;
    constexpr auto py = &b.y;
    f<px>(); // incorrect encoding of argument 'px'
    f<py>(); // incorrect encoding of argument 'py', collided with 'px'.
}

Avec ce correctif, les deux appels à f reçoivent des codages distincts, comme requis.

Migration vers MSVC Build Tools v14.50

Lors de la mise à niveau vers MSVC Build Tools v14.50, tenez compte des modifications potentielles et des conseils de migration suivants :

Adoption des fonctionnalités C++23

• Mettre à jour le code pour tirer parti de la nouvelle syntaxe de copie-atténuation auto(x) pour un code de modèle plus propre.
• Envisagez d’utiliser les directives #warning pour les avis de dépréciation au lieu de recourir à la compilation conditionnelle, qui est sujette aux erreurs.
• Passer en revue l’utilisation explicite des paramètres d’objet dans les opérateurs pour améliorer la cohérence

Améliorations constexpr

• Le code existant constexpr qui échouait précédemment peut maintenant être compilé, en particulier avec les fonctions virtuelles.
• Passer en revue le code d’évaluation constante pour connaître les nouvelles opportunités d’optimisation potentielles
• Mettre à jour les modèles CRTP qui peuvent maintenant fonctionner correctement avec les membres statiques constexpr

Migration des modules

• Les projets utilisant des modules C++20 doivent voir une stabilité et une compatibilité améliorées
• Les unités d’en-tête fonctionnent désormais de manière plus fiable avec de grandes bases de code comme Unreal Engine 5
• Envisagez de migrer des en-têtes traditionnels vers des modules pour améliorer les performances de compilation

Diagnostics du compilateur

• De nouveaux avertissements peuvent apparaître pour les problèmes précédemment non diagnostiqués
• Révisez l'utilisation du type d'énumération si vous utilisez /Zc:enumTypes
• Mettre à jour le code qui s’appuie sur des conversions implicites qui peuvent maintenant être marquées

Mises à jour du code C

• Les fonctionnalités C23 sont disponibles avec /std:clatest
• typeof les modifications de comportement peuvent affecter le code existant
• Passer en revue l’utilisation du préprocesseur pour la nouvelle __VA_OPT__ disponibilité

Fournir des commentaires

Pour obtenir les dernières mises à jour et fournir des commentaires, visitez la Communauté des développeurs Visual Studio ou contactez l’équipe à l’adresse visualcpp@microsoft.com. Suivez-nous sur X @visualc ou BlueSky @msftcpp.bsky.social.

Si vous rencontrez des problèmes avec MSVC dans Visual Studio 2026, veuillez nous informer via l’option Signaler un problème , à partir du programme d’installation ou de l’IDE Visual Studio lui-même.

Voir aussi

Conformité du langage Microsoft C/C++
Nouveautés de C++ dans Visual Studio
Améliorations de la conformité C++ dans Visual Studio 2022