Melhorias de conformidade C/C++, alterações de comportamento e correções de bugs nas ferramentas de compilação do Microsoft C++ (MSVC)

O Microsoft C++ (MSVC) Build Tools faz melhorias de conformidade e correções de bugs em todas as versões. A partir do Visual Studio 2026 versão 18.0, as principais melhorias são organizadas pelo número de versão do MSVC Build Tools. Para ir diretamente para as alterações de uma versão específica, use os links Neste artigo na parte superior deste artigo.

Para alterações em versões anteriores do Visual Studio:

Melhorias de conformidade com C++, alterações de comportamento e correções de bugs no MSVC Build Tools v14.50

O MSVC Build Tools v14.50 introduz melhorias no compilador MSVC e na biblioteca padrão, incluindo melhor conformidade com os padrões C++23, confiabilidade aprimorada e correção aprimorada. Esta versão também inclui inúmeras correções de bugs e atualizações que beneficiam o desenvolvimento em C++ em grande escala.

Esta versão foi fornecida primeiro com o Visual Studio 2026 versão 18.0 e inclui a versão 19.50 do compilador MSVC.

Os principais destaques desta versão incluem:

• Suporte avançado a recursos C++23, incluindo auto(x) cópia por degradação e #warning diretiva.
• Melhorias abrangentes constexpr, particularmente para funções virtuais.
• Principais melhorias de estabilidade para módulos C++.
• Extensas correções de confiabilidade reduzindo erros internos do compilador.
• Suporte aprimorado a C++/CLI para cenários de código gerenciado.
• A biblioteca padrão do Microsoft C++ (MSVC STL) não suporta mais o direcionamento para Windows 7/Server 2008 R2, Windows 8/Server 2012 ou Windows 8.1/Server 2012 R2.
• O Windows 10/Server 2016 são os sistemas operativos mínimos suportados.

Para obter mais informações sobre melhorias de desempenho, correções de bugs e atualizações de conformidade na biblioteca padrão, consulte STL Changelog, que é atualizado regularmente.

Recursos do C++23

O MSVC Build Tools v14.50 adiciona suporte para vários recursos do C++23, aproximando o compilador da conformidade total com o C++23.

P0849R8: auto(x) - cópia de decaimento no idioma

P0849R8 introduz a sintaxe auto(x) para operações de decaimento-cópia diretamente na linguagem, oferecendo uma maneira mais concisa de expressar a semântica de decaimento-cópia.

Antes P0849R8, você precisava executar explicitamente operações de decaimento:

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

Depois de P0849R8, você pode usar a sintaxe mais simples auto(x) :

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

Esse recurso fornece uma maneira padronizada de executar operações de cópia de decaimento, tornando o código mais legível e reduzindo a necessidade de metaprogramação detalhada do modelo.

P2437R1: Diretiva C++23 #warning

P2437R1 implementa a diretiva de pré-processador C++23 #warning , fornecendo uma maneira padrão de emitir avisos durante a compilação.

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

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

A #warning diretiva permite que você emita mensagens de diagnóstico sem interromper a compilação, tornando-a útil para avisos de descontinuação e avisos de configuração. Para obter mais informações, consulte Diretiva #warning (C/C++).

CWG Issue 2586: Parâmetro de objeto explícito para atribuição e comparação

O CWG Issue 2586 permite parâmetros de objeto explícitos em operadores de atribuição e comparação, permitindo definições de operador mais flexíveis.

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

Essa alteração permite-lhe utilizar a sintaxe explícita do parâmetro de objeto (deduzindo this) em operadores de atribuição e comparação, proporcionando um uso mais consistente em diferentes tipos de funções membros.

P2266R1 : Movimento implícito mais simples

A introdução de P2266R1 pode fazer com que o código que anteriormente era tratado como um lvalue seja tratado como um xvalue ou um prvalue. Por exemplo:

#include <utility>

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

struct S { };

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

Em C++20 e anteriores, este código compilava porque, mesmo que o tipo fosse t, o uso de t em S&& é tratado como um glvalue e, assim, pode se vincular ao tipo de retorno.
Com C++23, é tratado como um xvalue e, portanto, t não pode se vincular a uma referência lvalue.
Uma correção é alterar o tipo de retorno da função de T& para T&&, mas isso pode afetar o código que chama essa função. Uma alternativa é usar a macro de teste de recurso associada a essa alteração. Por exemplo:

#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
}

Adicionar o cast significa que a categoria de valor da expressão de retorno agora é um lvalue e, portanto, pode ser vinculada ao tipo de retorno.

P2280R4: Referências a valores desconhecidos durante a avaliação constante

P2280R4 permite referências a valores desconhecidos durante a avaliação constante, relaxando as restrições na constexpr avaliação.

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.
}

Essa melhoria permite que mais código seja avaliado em tempo de compilação, particularmente ao lidar com parâmetros de função em contextos de modelo.

Melhorias de conformidade

A melhor aderência aos padrões C++ inclui melhor manipulação de atributos, modelos e recursos C++20/C++23.

Suporte a atributos

• Adicionado suporte para on [[maybe_unused]] etiquetas.
• Corrigido o aviso C4102 (rótulo não referenciado) quando a única referência era proveniente de um ramo descartado if constexpr.

Correções de modelo e especialização

• Especializações explícitas de amigos malformados diagnosticados que foram aceites incorretamente no C++20 ou posterior.
• Adicionada /Zc:enumEncoding opção para codificar corretamente os parâmetros de modelo não tipo enum.
• Corrigidos problemas com diagnósticos de palavras-chave de 'modelo' ausentes

Recursos do C++20 e C++23

• Suporte multidimensional operator[] melhorado
• Melhor avaliação do conceito e das restrições

Atualizações de conformidade menores

O MSVC Build Tools v14.50 inclui várias melhorias de conformidade menores que melhoram a conformidade com o padrão C++:

• CWG2635: Suporte restrito a ligações estruturadas
• CWG2465: Parâmetros de co-rotina passados para prometer melhorias no construtor
• CWG2496: Qualificadores de referência e correções de sobreposição virtual
• CWG2506: Correções de ligações estruturadas e qualificadores cv de array
• CWG2507: Argumentos padrão para operator[] suporte
• CWG2585: Alinhamento do comportamento com os requisitos padrão
• CWG2521: Descontinuação do 'identificador literal de cadeia de caracteres do operador'
• CWG2528: Regras de conversão relaxadas para o operador da nave espacial
• P2360R0: Definição estendida de instrução init-statement para permitir declarações de alias
• P2290R3: Suporte a sequências de escape hexadecimal/octal delimitadas em C++23 em literais de string
• P2797R0: Resolução para CWG2692 em relação a funções de membro de objeto estático e explícito com as mesmas listas de tipos de parâmetros
• P2266R3: Semântica de movimento implícito mais simples

Correções de erros

Correções de bugs para módulos C++, constexpre outras correções foram feitas no MSVC Build Tools v14.50.

Para obter uma lista detalhada de correções de bugs, consulte Melhorias do compilador na v14.50.

Codificação de determinados argumentos de modelo não tipo corrigidos

Afeta /std:c++20 ou mais tarde.

Certos argumentos de modelo de tipo de ponteiro não-tipo envolvendo subobjetos podem levar a problemas de vinculação ou, em alguns casos, à geração silenciosa de código ruim, onde o que deveria ser especializações distintas colidem.

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'.
}

Com essa correção, as duas chamadas para f recebem codificações distintas, conforme necessário.

Migrando para MSVC Build Tools v14.50

Ao atualizar para o MSVC Build Tools v14.50, considere as seguintes possíveis alterações significativas e orientações de migração:

Adoção de caraterísticas do C++23

• Atualize o código para aproveitar a nova auto(x) sintaxe de cópia de decaimento para um código de modelo mais limpo
• Considere o uso #warning de diretivas para avisos de substituição em vez de compilação condicional propensa a erros
• Revise o uso explícito de parâmetros de objeto em operadores para melhorar a consistência

constexpr melhorias

• O código existente constexpr que anteriormente falhava agora pode ser compilado, particularmente com funções virtuais.
• Revise o código de avaliação constante para potenciais novas oportunidades de otimização
• Atualizar padrões CRTP que agora podem funcionar corretamente com membros constexpr estáticos

Migração de módulos

• Projetos que usam módulos C++20 devem ter estabilidade e compatibilidade aprimoradas
• As unidades de cabeçalho agora funcionam de forma mais confiável com grandes bases de código, como a Unreal Engine 5
• Considere migrar de cabeçalhos tradicionais para módulos para melhorar o desempenho da compilação

Diagnóstico do compilador

• Novos avisos podem aparecer para problemas não diagnosticados anteriormente
• Revise o uso do tipo enum se estiver usando /Zc:enumTypes
• Atualizar código que depende de conversões implícitas que agora podem ser sinalizadas

Atualizações de código C

• Os recursos do C23 estão disponíveis com /std:clatest
• typeof alterações de comportamento podem afetar o código existente
• Revise a utilização do pré-processador para verificar a nova __VA_OPT__ disponibilidade.

Fornecer comentários

Para obter as atualizações mais recentes e fornecer comentários, visite a Comunidade de desenvolvedores do Visual Studio ou entre em contato com a equipe em visualcpp@microsoft.com. Siga-nos no X @visualc ou BlueSky @msftcpp.bsky.social.

Se você encontrar problemas com o MSVC no Visual Studio 2026, informe-nos por meio da opção Relatar um problema , seja do instalador ou do próprio IDE do Visual Studio.

Consulte também

Conformidade com a linguagem Microsoft C/C++
O que há de novo no C++ no Visual Studio
Melhorias de conformidade C++ no Visual Studio 2022