Apostila C++

Contents
Microsoft C/C++ no Visual Studio

C++ no Visual Studio
Visão geral do desenvolvimento em C++ no Visual Studio
o que há de novo para C++ no Visual Studio 2019
Novidades do C++ no Visual Studio 2017
O que há de novo para documentos do Microsoft C++
melhorias de conformidade do C++ no Visual Studio 2019
Aprimoramentos de conformidade do C++ no Visual Studio 2017
Conformidade da linguagem C/C++ da Microsoft
Plataformas de destino com suporte
Ferramentas e funcionalidades do C++ em edições do Visual Studio
Instalar o suporte C11 e C17 no Visual Studio
Exemplos
Ajuda e comunidade
Como relatar um problema com o conjunto de ferramentas do Visual C++
Tutoriais do Visual Studio C++
Instalar o suporte ao C++ no Visual Studio
Criar e editar um projeto de aplicativo de console C++
Desenvolver e executar um projeto de aplicativo de console C++
Criar uma calculadora de console em C++
Criar um aplicativo UWP
Criar um aplicativo da área de trabalho do Windows
Criar um jogo DirectX
Sistemas de build e projetos
Ler e escrever código no Visual Studio
Desenvolvimento da área de trabalho do Windows
Desenvolvimento da UWP
Desenvolvimento de jogos
Desenvolvimento em Linux
Desenvolvimento móvel multiplataforma
Desenvolvimento .NET com C++/CLI
Programação de Nuvem e da Web
Portar e atualizar código C++
Práticas recomendadas de segurança para C++
Executar como membro do grupo de usuários
Como o UAC (Controle de Conta de Usuário) afeta seu aplicativo
Diretrizes para desenvolvedores de C++ para canais do lado de execução
especulativos
Referência
Linguagem C/C++ e Bibliotecas padrão
Referência de linguagens
Linguagens
Referência de linguagem C
Referência da linguagem C++
Referência de pré-processador C/C++
Intrínsecos do compilador e linguagem assembly
Intrínsecos do compilador
Referência do assembler ARM
Assembly embutido no MSVC
Referência do MASM (Microsoft Macro Assembler)
Extensões de componentes para .NET e UWP
Atributos C++ para COM e .NET
Referência de bibliotecas
Libraries
Referência da CRT (biblioteca em tempo de execução) C
Referência da Biblioteca Padrão C++
Biblioteca SafeInt
Biblioteca SafeInt
Classe SafeInt
Funções (SafeInt)
Classe SafeIntException
MFC/ATL
Bibliotecas paralelas
Bibliotecas de acesso a dados
03/07/2021 • 7 minutes to read
NOTE
Esta documentação do desenvolvedor se aplica Visual Studio 2019. Para ver a documentação de sua versão preferencial
do Visual Studio, use o controle Seletor de versão. Ele é encontrado na parte superior do conteúdo desta página.
Se você estiver procurando um pacote redistribuível do Microsoft Visual C++ 2019 para que possa executar um
programa, acesse a página Downloads do Microsoft Visual Studio site. Em Todos os Downloads , expanda a seção
Outras Ferramentas, Estruturas e Redistribuíveis. Selecione sua arquitetura de destino e, em seguida, escolha o
botão Baixar.
Para redistribuíveis mais antigos, abra a página Downloads mais antigos. Expanda a seção Outras Ferramentas,
Estruturas e Redistribuíveis. Encontre a versão redistribuível que você deseja baixar, selecione sua arquitetura de
destino e, em seguida, escolha o botão Baixar.
NOTE
Se você estiver procurando um pacote redistribuível Microsoft Visual C++ 2017 ou mais antigo para que possa executar
um programa, acesse a página Downloads mais antigos do site do Microsoft Visual Studio. Expanda a seção Outras
Ferramentas, Estruturas e Redistribuíveis. Encontre a versão redistribuível que você deseja baixar, selecione sua
arquitetura de destino e, em seguida, escolha o botão Baixar.
NOTE
Se você estiver procurando um pacote redistribuível Microsoft Visual C++ 2015 ou mais antigo para que possa executar
um programa, acesse a página Downloads mais antigos do site do Microsoft Visual Studio. Expanda a seção Outras
Ferramentas, Estruturas e Redistribuíveis. Encontre a versão redistribuível que você deseja baixar, selecione sua
arquitetura de destino e, em seguida, escolha o botão Baixar.
Microsoft Visual C++ (MSVC) refere-se às bibliotecas e ferramentas de desenvolvimento de linguagem de

assembly do C++, C e disponíveis como parte do Visual Studio no Windows. Essas ferramentas e bibliotecas
permitem que você crie aplicativos da UWP (Plataforma Universal do Windows), aplicativos de servidor e área
de trabalho Windows nativos, bibliotecas e aplicativos multiplataforma que são executados no Windows, Linux,
Android e iOS, bem como bibliotecas e aplicativos que usam o .NET Framework. Você pode usar o MSVC para
gravar qualquer coisa de aplicativos de console simples para os aplicativos mais sofisticados e complexos para a
área de trabalho do Windows, desde drivers de dispositivo e componentes do sistema operacional até jogos
multiplataz para dispositivos móveis e dos menores dispositivos IoT para computação de alto desempenho de
vários servidores na nuvem do Azure.
O Visual Studio 2015, 2017 e 2019 podem ser instalados lado a lado. Você pode usar o Visual Studio 2019
(compilador toolset v142) ou o Visual Studio 2017 (v141) para editar e compilar programas usando o toolset do
Visual Studio 2017 (v141) e Visual Studio 2015 (v140).
Histórico de novidades e de conformidade
Novidades do C++ no Visual Studio
Descubra as novidades no Visual Studio.
Novidades do C++ no Visual Studio 2003 a 2015
Descubra quais foram as novidades do C++ para cada versão do Visual Studio, de 2003 até 2015.
Melhorias de conformidade do C++ Visual Studio
Saiba mais sobre as melhorias de conformidade do C++ no Visual Studio.
Conformidade com a linguagem C/C++ da Microsoft
Encontre o status de conformidade da linguagem no nível do recurso MSVC compilador por Visual Studio
versão.
Histórico de alterações do Microsoft C/C++ 2003 – 2015
Saiba mais sobre as alterações significativas nas versões anteriores.
Instalar o Visual Studio e atualizar de versões anteriores

Instalar o suporte do C++ no Visual Studio
Baixe Visual Studio e instale o pacote de ferramentas do Microsoft C/C++.
Guia de porta e atualização do Microsoft C++
Diretrizes para portabilidade de código e para atualização de projetos para o Visual Studio 2015 ou posterior
para aproveitar a maior conformidade do compilador com o padrão do C++, além de tempos de compilação e
recursos de segurança muito aprimorados como a mitigação do Spectre.
Ferramentas e recursos do C++ em Visual Studio edições
Descubra as diferentes edições do Visual Studio.
Plataformas com suporte
Descubra quais plataformas o compilador do Microsoft C/C++ dá suporte.
Aprender sobre o C++

Bem-vindo de volta ao C++
Saiba mais sobre as técnicas de programação modernas do C++ com base no C++11 e versões posteriores que
permitem que você escreva código rápido e seguro e evite muitas armadilhas do estilo de programação em C.
C++ Padrão
Saiba mais sobre o C++, obtenha uma visão geral do C++ Moderno e encontre links para livros, artigos, links e
eventos
Saiba Visual Studio e faça seu primeiro projeto C++
Comece a aprender a escrever C++ em Visual Studio.
Visual Studio Exemplos do C++
Informações sobre os exemplos de código C++ fornecidos pela Microsoft.
Ferramentas de desenvolvimento do C++

Visão geral do desenvolvimento em C++ Visual Studio
Como usar o IDE do Visual Studio para criar projetos, editar código, vincular a bibliotecas, compilar, depurar,
criar testes de unidade, fazer análise estática, implantar e muito mais.
Projetos e sistemas de build
Como criar e configurar projetos do Visual Studio C++, projetos CMake e outros tipos de projetos com as
opções de compilador e vinculador do MSVC.
Escrevendo e refactorando código C++
Como usar os recursos de produtividade no editor do C++ para refatorar, navegar, entender e escrever código.
Depurando código nativo
Use o depurador do Visual Studio com projetos C++.
Visão geral da análise de código para C/C++
Use anotações de SAL ou os verificadores das Diretrizes Principais do C++ para executar análise estática.
Escrever testes de unidade para C/C++ Visual Studio
Crie testes de unidade usando a Estrutura de Teste de Unidade da Microsoft para C++, Google Test, Boost.Test ou
CTest.
Escrever aplicativos em C++

Aplicativos Windows Universal (C++)
Encontre guias e conteúdo de referência no Centro de Desenvolvedores do Windows. Para obter informações de
como desenvolver aplicativos UWP, confira Introdução à Plataforma Universal do Windows e Criar um app
"Hello world" em C++.
Aplicativos da área de trabalho (C++)
Saiba como criar aplicativos da área de trabalho tradicionais, nativos, em C++ para Windows.
Programação do .NET com C++/CLI
Saiba como criar DLLs que permitem a interoperabilidade entre programas nativos em C++ e no .NET escritos
em linguagens como C# ou Visual Basic.
Programação do Linux
Use o Visual Studio IDE para codificar e implantar em um computador Linux remoto para compilação com GCC.
Criar DLLs C/C++ em Visual Studio
Descubra como usar o Win32, o ATL e o MFC para criar DLLs de área de trabalho do Windows e fornece
informações sobre como compilar e registrar sua DLL.
Programação paralela
Saiba como usar a Biblioteca de Padrões Paralelos, C++ AMP, OpenMP e outros recursos que estão relacionados
ao multithreading no Windows.
Práticas recomendadas de segurança
Saiba como proteger aplicativos contra código mal-intencionado e de uso não autorizado.
Programação na nuvem e na Web
No C++ há várias opções para conectar-se com a Web e com a nuvem.
Acesso a dados
Conecte-se a bancos de dados usando ODBC e OLE DB.
Texto e cadeias de caracteres
Saiba mais sobre como trabalhar com formatos e codificações diferentes de texto e de cadeia de caracteres para
desenvolvimento local e internacional.
Referência de linguagens
O guia de referência para a implementação da Microsoft da linguagem de programação C++.
Referência do pré-processador C/C++
Uma referência comum ao pré-processador de linguagem C e C++ compartilhado.
Referência da linguagem C
O guia de referência para a implementação da Microsoft da linguagem de programação C.
Intrínsecos do compilador e linguagem de assembly
Guias para os intrínsecos do compilador com suporte ou implementados pelos compiladores do Microsoft
C/C++ em cada plataforma.
Bibliotecas do C++ no Visual Studio

As seções a seguir fornecem informações sobre as diferentes bibliotecas do C e C++ que estão incluídas no
Visual Studio.
Referência da biblioteca de runtime C
Inclui alternativas aprimoradas de segurança a funções que são conhecidas por impor problemas de segurança.
Biblioteca padrão C++
A Biblioteca Padrão do C++.
Active Template Library (ATL)
Compatibilidade com aplicativos e componentes COM.
Bibliotecas MFC (Microsoft Foundation Class)
Suporte para criação de aplicativos da área de trabalho com interfaces de usuário tradicionais ou no estilo
Office.
PPL (Parallel Patterns Library)
Algoritmos assíncronos e paralelos que são executados na CPU.
C++ AMP (C++ Accelerated Massive Parallelism)
Algoritmos totalmente paralelos que são executados na GPU.
Windows WRL (Biblioteca de Modelos de Runtime)
Aplicativos UWP (Plataforma Universal do Windows) e componentes.
Programação para o CLR (Common Language Runtime).
Bibliotecas C++ de software livre de terceiros

A ferramenta de linha de comando vcpkg multiplataforma simplifica bastante a descoberta e a instalação de
mais de 900 bibliotecas C++ de software livre. Para obter mais informações, consulte vcpkg.
Comentários e comunidade
Microsoft Docs Q&A
Microsoft Docs hospeda fóruns pesquisáveis para perguntas e respostas. Adicione uma C++ marca à sua
postagem para assistência da comunidade sobre problemas relacionados ao C++.
Como relatar um problema com o pacote de ferramentas do Microsoft C/C++
Saiba como criar relatórios de erros efetivos no microsoft C/C++ (compilador, linker e outras ferramentas) e
maneiras de enviar seu relatório.
Blog da equipe do Microsoft C++
Saiba mais sobre os novos recursos e as informações mais recentes dos desenvolvedores das ferramentas do
C++ no Visual Studio.
Visual Studio C++ Developer Community
Obter ajuda, arquivar bugs e fazer sugestões para C++ Visual Studio.
Visão geral do desenvolvimento em C++ no Visual
Studio
Como parte do IDE (Ambiente de Desenvolvimento Integrado) do Visual Studio, o MSVC (Microsoft C++)
compartilha muitas janelas e ferramentas com outras linguagens. Muitas delas, incluindo o Gerenciador de
Soluções , o editor de códigos e o depurador, estão documentadas no IDE do Visual Studio. Geralmente, uma
ferramenta ou uma janela compartilhada tem um conjunto de recursos ligeiramente diferente para o C++
comparado a outra linguagens. Algumas janelas ou ferramentas só estão disponíveis no Visual Studio
Professional ou nas edições do Visual Studio Enterprise.
Além das ferramentas compartilhadas no IDE do Visual Studio, o MSVC tem várias ferramentas especificamente
para o desenvolvimento de código nativo. Essas ferramentas também são listadas neste artigo. Para obter uma
lista de quais ferramentas estão disponíveis em cada edição do Visual Studio, confira Ferramentas e recursos do
C++ em edições do Visual Studio.
Criar projetos
Um projeto é basicamente um conjunto de arquivos de código-fonte e recursos, como imagens ou arquivos de
dados que são compilados em um programa ou biblioteca executável.
O Visual Studio dá suporte a qualquer sistema de projeto ou ferramenta de build personalizada que você deseje
usar, com suporte total para IntelliSense, navegação e depuração:
O MSBuild é o sistema de projeto nativo para o Visual Studio. ao selecionar arquivo > novo > Project
no menu principal, você verá muitos tipos de modelos de projeto de MSBuild que o ajudarão a
desenvolver rapidamente diferentes tipos de aplicativos em C++.
Em geral, você deve usar esses modelos para novos projetos, a menos que esteja usando projetos CMake
ou outro sistema de projeto. Para saber mais, confira Criar e gerenciar projetos baseados no MSBuild.
o CMake é um sistema de build de plataforma cruzada que é integrado ao IDE Visual Studio quando
você instala o desenvolvimento de Desktop com a carga de trabalho do C++. É possível usar o modelo de
projeto CMake para novos projetos ou simplesmente abrir uma pasta com um arquivo CMakeLists.txt.
Para saber mais, confira Projetos CMake no Visual Studio.
Qualquer outro sistema de compilação C++, incluindo uma coleção flexível de arquivos, tem suporte por
meio do recurso abrir pasta . Crie arquivos JSON simples para invocar o programa de build e
configurar sessões de depuração. Para saber mais, veja Projetos Open Folder para C++.
Adicionar ao controle do código-fonte

O controle do código-fonte permite coordenar o trabalho entre diversos desenvolvedores, isolar o trabalho em
andamento do código de produção e fazer backup do código-fonte. O Visual Studio é compatível com o Git e o
TFVC (Controle de Versão do Team Foundation) por meio da janela Team Explorer .
Para saber mais sobre a integração do Git com repositórios no Azure, confira Compartilhar código com o Visual
Studio 2017 e o Git do Azure Repos. Para saber mais sobre a integração do Git com o GitHub, confira Extensão
do GitHub para Visual Studio.
Obter bibliotecas
Use o gerenciador de pacotes vcpkg para obter e instalar bibliotecas de terceiros. No momento, mais de 900
bibliotecas open-source estão disponíveis no catálogo.
Criar interfaces do usuário com designers

Se o programa tiver uma interface do usuário, você poderá usar um designer para populá-lo rapidamente com
controles como botões, caixas de listagem e assim por diante. Ao arrastar um controle da janela de ferramentas
e soltá-lo na superfície de design, o Visual Studio gerará os recursos e o código necessários para fazer tudo
funcionar. Em seguida, você escreverá o código para personalizar a aparência e o comportamento.
para obter mais informações sobre como criar uma interface do usuário para um aplicativo Plataforma
Universal do Windows, consulte Design e iu.
Para obter mais informações sobre como criar uma interface do usuário para um aplicativo MFC, confira
Aplicativos da área de trabalho do MFC. Para obter informações sobre programas Windows Win32, confira
Aplicativos da área de trabalho do Windows.
Escrever código
Depois que você cria um projeto, todos os arquivos de projeto são exibidos na janela Gerenciador de
Soluções . (Uma solução é um contêiner lógico para um ou mais projetos relacionados.) Quando você clica em
um arquivo. h ou. cpp em Gerenciador de soluções , o arquivo é aberto no editor de código.
O editor de códigos é um processador de texto especializado para código-fonte C++. Ele codifica por cores os
nomes de palavras-chave, de métodos e de variáveis da linguagem e outros elementos do código para tornar o
código mais legível e mais fácil de ser entendido. Ele também fornece ferramentas para refatoração de código,
navegação entre diferentes arquivos e noções básicas sobre como o código é estruturado. Para saber mais,
confira Escrever e refatorar código.
Adicionar e editar recursos

um programa ou DLL de Windows geralmente inclui alguns recursos, como caixas de diálogo, ícones, imagens,
cadeias de caracteres localizáveis, telas de abertura, cadeias de conexão de banco de dados ou qualquer dado
arbitrário. Visual Studio inclui ferramentas para adicionar e editar recursos. Para obter mais informações,
consulte trabalhando com arquivos de recursos.
Build (compilar e vincular)

Escolha criar > solução de compilação na barra de menus ou insira a combinação de teclas Ctrl + Shift + B
para compilar e vincular um projeto. Erros e avisos de compilação são relatados no Lista de Erros (Ctrl + \ , e ).
A janela saída (ALT + 2 ) mostra informações sobre o processo de compilação.
Para saber mais sobre como configurar builds, confira Como trabalhar com Propriedades de Projeto e Projetos e
sistemas de build.
Use também o compilador (cl.exe) e muitas outras ferramentas autônomas relacionadas a build, como NMAKE e
LIB, diretamente na linha de comando. Para obter mais informações, confira Compilar o código C/C++ na linha
de comando e Referência de build do C/C++.
Depurar
É possível iniciar a depuração pressionando F5 . A execução pausa em todos os pontos de interrupção que você
definiu (pressionando F9 ). Você também pode percorrer o código uma linha por vez (F10 ), exibir os valores das
variáveis ou dos registros e, mesmo em alguns casos, fazer alterações no código e continuar a depuração sem
precisar compilá-la novamente. A ilustração a seguir mostra uma sessão de depuração em que a execução é
pausada no ponto de interrupção. Os valores dos membros da estrutura de dados são visíveis na janela
Inspeção .
Para obter mais informações, consulte Depuração no Visual Studio.
Teste
O Visual Studio inclui o Microsoft Unit Test Framework para C++, além de suporte para Boost.Test, Google Test e
CTest. Execute os testes na janela do Gerenciador de Testes :
Para saber mais, confira Verificar código usando testes de unidade e Gravar testes de unidade para C/C++ no
Visual Studio.
Analisar
O Visual Studio inclui ferramentas de análise de código estático que podem detectar possíveis problemas no
código-fonte. Essas ferramentas incluem uma implementação dos verificadores de regras das Diretrizes
Principais do C++. Para obter mais informações, confira Visão geral da análise de código do C/C++.
Implantar aplicativos concluídos

É possível implantar os aplicativos tradicionais de área de trabalho e os aplicativos da UWP para os clientes por
meio da Microsoft Store. A implantação do CRT é manipulada automaticamente em segundo plano. Para obter
mais informações, confira Publicar aplicativos e jogos do Windows.
Você também pode implantar uma área de trabalho C++ nativa em outro computador. Para obter mais
informações, confira Implantando aplicativos da área de trabalho.
Para obter mais informações sobre como implantar um programa do C++/CLI, confira Guia de Implantação
para Desenvolvedores.
Próximas etapas
Explore ainda mais o Visual Studio seguindo um dos seguintes artigos introdutórios:
Saiba como usar o editor de códigos
Saiba mais sobre projetos e soluções
Novidades do C++ no Visual Studio
O Visual Studio 2019 traz muitas atualizações e correções para o ambiente do Microsoft C++. Corrigimos vários
bugs e problemas no compilador e nas ferramentas. Muitos deles enviados pelos clientes pelas opções Relatar
um Problema e Fornecer uma Sugestão em Enviar Comentários . Obrigado por relatar bugs!
Para saber mais sobre todas as novidades do Visual Studio, visite Novidades no Visual Studio 2019. Para saber
mais sobre novidades de C++ no Visual Studio 2017, confira Novidades de C++ no Visual Studio 2017. Para
saber mais sobre as novidades de C++ no Visual Studio 2015 e em versões anteriores, confira O que há de
novo no Visual C++ de 2003 a 2015. Para obter informações sobre as novidades nos documentos do C++,
consulte Microsoft C++ docs: What ' s New.
O que há de novo para C++ no Visual Studio versão 16,9

Para obter um resumo dos novos recursos e correções de bugs no Visual Studio versão 16,9, consulte novidades
do visual studio 2019 versão 16,9.
Limpeza de endereço:
Nosso suporte para limpeza de endereço no Windows está fora do modo experimental e atingiu a
disponibilidade geral.
Suporte expandido RtlAllocateHeap , corrigido um problema de compatibilidade com
RtlCreateHeap RtlAllocateHeap interceptadores ao criar pools de memória executáveis.
Suporte adicionado para as funções herdadas GlobalAlloc e da LocalAlloc família de memória.
Você pode habilitar esses interceptadores definindo o sinalizador de ambiente
ASAN_OPTIONS=windows_hook_legacy_allocators=true .
Atualização das mensagens de erro para intercalação de memória de sombra e falha de

interceptação para tornar os problemas e as resoluções explícitos.
A integração do IDE agora pode lidar com a coleção completa de exceções que o ASan pode
relatar.
O compilador e o vinculador irão sugerir a emissão de informações de depuração se detectarem
que você está criando com ASan, mas não emitindo informações de depuração.
Agora você pode direcionar a versão LLVM do tempo de execução de OpenMP com a nova opção CL
/openmp:llvm . Isso adiciona suporte para a lastprivate cláusula em #pragma omp seções e variáveis de
índice não assinadas em for loops paralelos. No /openmp:llvm momento, o comutador está disponível
apenas para o destino AMD64 e ainda é experimental.
Os projetos do Visual Studio CMake agora têm suporte de primeira classe para o desenvolvimento
remoto do Windows. Isso inclui a configuração de um projeto do CMake para direcionar o Windows
ARM64, a implantação do projeto em um computador remoto com Windows e a depuração do projeto
em um computador Windows remoto do Visual Studio.
A versão do Ninja fornecida com o Visual Studio no Windows foi atualizada para a versão 1.10. Para
obter mais informações sobre o que está incluído, consulte as notas de versão do Ninja 1,10.
A versão do CMake fornecida com o Visual Studio foi atualizada para a versão 3.19. Para obter mais
informações sobre o que está incluído, consulte as notas de versão do CMake 3,19.
Foram marcados vários tipos de bloqueio/proteção na STL nodiscard como .
IntelliSense:
Melhoria da estabilidade e da funcionalidade de fornecer módulos importados e conclusão de
unidades de cabeçalho no IntelliSense.
Adição de ir para definição em importações de módulo, suporte à indexação export {...} e
referência de módulo mais preciso para módulos com o mesmo nome.
Melhoram a conformidade com o idioma do C++ IntelliSense adicionando suporte para cópia-
inicialização de temporário em referência Direct-Initialization __builtin_memcpy e
__builtin_memmove , corrigindo inconsistências entre constexpr consteval funções e, temporaries
estendidas de tempo de vida em expressões constantese associações de referência e tipos
semelhantes.
Adição de conclusão para make_unique, make_shared, emplace e emplace_back que fornece a
conclusão com base no parâmetro de tipo especificado.
O MSVC agora determina os runtimes do Address Sanitizer corretos necessários para seus binários. Seu
projeto do Visual Studio receberá automaticamente as novas alterações. Ao usar o limpador de endereço
na linha de comando, agora você só precisa passar /fsanitize=address para o compilador.
O Gerenciador de Conexões do Visual Studio agora dá suporte a chaves privadas usando o algoritmo de
chave pública de ECDSA.
Atualização das versões do LLVM e do Clang fornecidas em nosso instalador para a v11. Leia as notas
sobre a versão do LLVM e do Clang para obter mais informações.
Agora o Visual Studio usará as variáveis do CMake de arquivos de cadeia de ferramentas para configurar
o IntelliSense. Isso proporcionará uma experiência melhor para desenvolvimentos inseridos e do
Android.
Implementação da proposta mais contêineres Constexpr, que permite que destruidores e novas
expressões sejam constexpr . Isso abre a maneira de utilitários como constexpr std::vector e
std::string .
Suporte estendido para IntelliSense de módulos C++20, incluindo Ir para Definição, Ir para Módulo e
conclusão de membro.
Agora há suporte para modelos de função abreviados no compilador MSVC.

Agora há suporte para as corotinas do c++ 20 no /std:c++latest e no <coroutine> cabeçalho.
O IntelliSense agora fornece suporte para <concepts> do C++20 e cabeçalhos <ranges>, além de
renomeação e navegação para definições de conceito.
Nosso STL agora é compatível com a maioria dos Intervalos do C++20.
As funções condicionalmente triviais de membros especiais agora são compatíveis com o MSVC.
O C11 e o C17 agora têm suporte nas opções /std:c11 e /std:c17 .
Melhorias de STL adicionais incluem suporte completo std::atomic_ref para std::midpoint std::lerp ,
e e std::execution::unseq , otimizações para e std::reverse_copy muito mais.
Atualização da versão do CMake fornecida com o Visual Studio para CMake 3.18.
Nossas ferramentas de análise de código agora são compatíveis com o padrão SARIF 2.1: o formato
padrão de log de análise estática do setor.
As ferramentas de build ausentes nos projetos do Linux emitirão um aviso na barra de ferramentas e
uma descrição clara das ferramentas ausentes na lista de erros.
Agora é possível depurar os despejos de núcleo do Linux em um sistema Linux remoto ou no WSL
diretamente do Visual Studio.
Para a geração de comentários do C++ Doxygen, adicionamos opções de estilo de comentário adicionais
( /*! e //! ).
Anúncios de vcpkgadicionais.
Suporte do compilador para lambdas em contextos não avaliados.
/DEBUG:FULL desempenho de link melhorado pela criação de multithreading PDB. Vários aplicativos
grandes e jogos AAA apresentam vinculação duas a quatro vezes mais rápida.
O depurador do Visual Studio agora tem suporte para char8_t .
Suporte para projetos ARM64 usando clang-cl.
Suporte de intrínsecos do Intel AMX.

Nosso suporte remoto ao C++ agora é compatível com uma maior variedade de distribuições e shells do
Linux, incluindo sh, csh, bash, tsch, ksh, zsh e dash. Você pode substituir a escolha de um shell para uma
conexão remota modificando a nova propriedade "shell" por meio de ConnectionManager.exe. Esse
suporte foi testado com projetos do Linux baseados no MSBuild e projetos CMake visando um sistema
Linux remoto ou WSL.
Agora você pode usar o Ninja (um sistema de build que avalia builds incrementais muito rapidamente)
para aprimorar tempos de build incrementais para projetos do Linux baseados em MSBuild. Você pode
aceitar esse recurso definindo "Habilitar Build Incremental" como "Com o Ninja" na Página de
Propriedades Gerais. O Ninja (ninja-build) precisa ser instalado em seu sistema Linux remoto ou WSL.
Novos recursos de biblioteca padrão do C++20 foram implementados. Veja o Log de mudanças de STL
no GitHub para uma lista detalhada.
Agora você pode editar e definir conexões SSH remotas padrão no Gerenciador de Conexões. Isso
significa que você pode editar uma conexão remota existente (por exemplo, se seu endereço IP foi
alterado) e definir conexões padrão a serem consumidas em CMakeSettings.jse launch.vs.jsem. As
conexões SSH remotas permitem que você compile e depure projetos C++ em um sistema Linux remoto
diretamente do Visual Studio.
Suporte aprimorado do IntelliSense para Clang no Windows (clang-cl) no Visual Studio. O caminho de
inclusão do Clang agora inclui as bibliotecas do Clang. Aprimoramos a exibição de rabiscos no editor ao
usar a biblioteca padrão e adicionamos suporte para C++2a no modo de Clang.
agora você pode testar os erros de código subjacentes e ver as correções rápidas mais sugeridas em
projetos C++. Habilite esse recurso em ferramentas > opções > editor de texto > C/C++ >
experimental . Defina desabilitar o pano de código experimental como falso. Saiba mais no Blog
da Equipe do C++.
Adicionamos quatro novas regras de análise de código para incorporar recursos de segurança adicionais
em C++ : C26817, C26818, C26819 e C26820.
Adicionamos suporte de primeira classe para depurar projetos CMake em sistemas remotos com
gdbserver.
Encontre erros de corrupção de memória facilmente com uma implementação experimental do
AddressSanitizer para C++ no Visual Studio, agora disponível para projetos nativos x64. Agora, também
damos suporte ao uso de tempos de execução de depuração ( /MTd , /MDd , /LDd ).
O IntelliSense agora tem suporte básico para conceitos, inicializadores designados e vários outros
recursos do C++20.
.ixx e .cppm os arquivos agora são reconhecidos como C++ e são tratados como tal pelo realce de
sintaxe e pelo IntelliSense.

Geração de comentários Doxygen/XML aprimorada: Gere automaticamente stubs de comentário
de documento Doxygen ou XML digitando as /// /** funções ou acima. Eles agora são exibidos em
dicas de ferramentas de Informações Rápidas também.
Supor te do Ninja para CMake para Linux/WSL: use o Ninja como o gerador subjacente ao criar
projetos do CMake no WSL ou em um sistema remoto. O Ninja agora é o gerador padrão ao adicionar
uma nova configuração do Linux ou do WSL.
Modelos de depuração para depuração remota de CMake : simplificamos os modelos de
depuração de projetos CMake em um sistema Linux remoto ou WSL com o gdb.
Supor te inicial para conceitos do C++20: O IntelliSense agora reconhece conceitos do C++ 20 e
sugere o uso deles na lista de membros.

Supor te para variáveis de modelo e membro de preenchimentos de equipe do IntelliCode:
Os desenvolvedores de C++ agora podem treinar modelos IntelliCode em suas próprias bases de código.
Chamamos isso de modelo de Conclusões da Equipe, porque você se beneficia das práticas da sua
equipe. Além disso, aprimoramos as sugestões de variáveis de membro do IntelliCode.
Aprimoramentos do IntelliSense:
Agora o IntelliSense exibe nomes de tipo mais legíveis ao lidar com a Biblioteca Padrão.
Adicionamos a capacidade de alternar entre Enter , espaço e função de Tabulação como caracteres
de confirmação e para alternar se a guia é usada para inserir trecho de código. Encontre essas
configurações em ferramentas > opções > editor de texto > C/C++ > Advanced >
IntelliSense .
Gerenciador de conexões na linha de comando: Agora você pode interagir com as conexões
remotas armazenadas na linha de comando. Ele é útil para tarefas como o provisionamento de uma nova
máquina de desenvolvimento ou a configuração do Visual Studio na integração contínua.
Depurar e implantar para WSL: Use o suporte nativo do Visual Studio para WSL para separar o
sistema de compilação do seu sistema de implantação remota. Agora você pode criar nativamente no
WSL e implantar os artefatos de compilação em um segundo sistema remoto para depuração. Esse fluxo
de trabalho é compatível com projetos CMake e projetos Linux baseados em MSBuild.
Supor te para o modo de conformidade FIPS 140-2: O Visual Studio agora dá suporte ao modo de
conformidade FIPS 140-2 ao desenvolver aplicativos C++ destinados a um sistema Linux remoto.
Ser viços de linguagem para arquivos de idiomas CMake e melhor manipulação de projetos
de CMake:
A cópia do arquivo de origem para projetos CMake que direcionam um sistema Linux remoto foi
otimizada. Agora o Visual Studio mantém um "arquivo de impressão digital" do último conjunto
de origens copiado remotamente e otimiza o comportamento com base no número de arquivos
que foram alterados.
A navegação de código, como Ir para a Definição e Localizar Todas as Referências, agora é
compatível com as funções, as variáveis e os destinos nos arquivos de script do CMake.
Adicione, remova e renomeie arquivos de origem e destinos em seus projetos CMake no IDE sem
editar manualmente seus scripts do CMake. Quando você adicionar ou remover arquivos com o
Gerenciador de Soluções, o Visual Studio editará automaticamente seu projeto CMake. Você
também pode adicionar, remover e renomear os destinos do projeto na Exibição de Destinos do
Gerenciador de Soluções.
Aprimoramentos do projeto do Linux: Os projetos do Linux do Visual Studio agora têm um
IntelliSense mais preciso e permitem controlar a sincronização de cabeçalho remoto em uma base
projeto por projeto.

Agora, a análise de código dá suporte nativamente Clang-Tidy para projetos MSBuild e CMake,
independentemente de você estar usando um conjunto de ferramentas Clang ou MSVC. As verificações
do clang-tidy podem ser executadas como parte da análise de código em segundo plano, ser exibidas
como avisos no editor (rabiscos) e ser exibidas na Lista de Erros.
Os projetos CMake do Visual Studio agora têm páginas de Visão geral para ajudar você a começar a usar
o desenvolvimento multiplataforma. Essas páginas são dinâmicas e ajudam você a se conectar com um
sistema Linux e adicionar uma configuração do Linux ou do WSL ao seu projeto do CMake.
O menu suspenso de inicialização para projetos CMake agora exibe os destinos usados mais
recentemente e pode ser filtrado.
O C++/a CLI agora dá suporte à interoperabilidade com o .NET Core 3.1 (ou versão superior) no
Windows.
Agora você pode habilitar o ASan para projetos compilados com o MSVC no Windows para
instrumentação do runtime do código C++ que ajuda na detecção de erros de memória.
Atualizações da Biblioteca Padrão C++ do MSVC:
C++17: Precisão geral to_chars() implementada, concluindo P0067R5 Conversões de cadeia de
caracteres elementares (charconv). Isso conclui a implementação de todos os recursos de biblioteca
no C++17 Standard.
C++20: Implementado P1754R1 Renomear conceitos para standard_case. Para incluir recursos de
visualização do rascunho de trabalho mais recente do C++, use a /std:c++latest opção do
compilador. A opção também pode ser definida nas Propriedades de configuração > C/C++ >
página de propriedades do projeto de linguagem usando a propriedade padrão da linguagem C++
.
Uma nova coleção de ferramentas denominada C++ Build insights já está disponível. Para obter mais
informações sobre o comunicado, consulte o blog da equipe do C++.

Os desenvolvedores de C++ agora podem alternar comentários de linha usando o atalho de teclado Ctrl
+ K , Ctrl +/ .
As listas de membros do IntelliSense agora são filtradas com base em qualificadores de tipo, por
exemplo, const std::vector agora filtra métodos como push_back .
Adicionamos estes recursos de visualização da biblioteca padrão do C++ 20 (disponíveis em
/std:c++latest ):
P0487R1: Resolvendo operator>>(basic_istream&, CharT*)

P0616R0: Usando move() em <numeric>
P0758R1: is_nothrow_convertible
P0734R0: Extensões C++ para Conceitos
P0898R3: Conceitos da Biblioteca Padrão
P0919R3: Pesquisa Heterogênea por Contêineres Não Ordenados
Novas verificações de diretrizes principais do C++, incluindo as novas regras do conjunto de regras
"regras de enumeração" e as mais básicas const , enum e de tipos.
Um novo esquema de colorização semântico padrão permite que os usuários entendam melhor seu
código em um relance, a janela pilha de chamadas pode ser configurada para ocultar argumentos de
modelo e o IntelliCode C++ é ativado por padrão.
Configure destinos de depuração e tarefas personalizadas com variáveis de ambiente usando
CMakeSettings.json ou CppProperties.json ou a nova marca "env" em destinos e tarefas individuais em
launch.vs.json e tasks.vs.json.
Os usuários agora podem usar uma ação rápida nos pacotes vcpkg ausentes para abrir automaticamente
um console e instalar na instalação padrão do vcpkg.
A cópia de cabeçalho remoto feita por projetos do Linux (CMake e MSBuild) foi otimizada e agora é
executada em paralelo.
O suporte nativo do Visual Studio para WSL agora dá suporte a builds paralelos para projetos do Linux
baseados em MSBuild.
Os usuários agora podem especificar uma lista de saídas de build locais para implantar em um sistema
remoto com projetos Makefile do Linux.
A definição de descrições no Editor de Configurações do CMake agora contém mais contexto e links para
a documentação útil.
O modelo base C++ para IntelliCode agora está habilitado por padrão. É possível alterar essa
configuração em Ferramentas > Opções > IntelliCode .
Para projetos locais do CMake configurados com Clang, agora a Análise de Código executa verificações
de clang-tidy, sendo exibidas como parte da análise de código em segundo plano como avisos no editor
(linhas ondulantes) e na Lista de Erros.
Atualizamos o cabeçalho <charconv> das conversões de cadeia de caracteres elementar P0067R5 do
C++17:
Adicionamos sobrecargas to_chars() de ponto flutuante para oferecer precisão a
chars_format::fixed e a chars_format::scientific ( chars_format::general precision é a única parte
ainda não implementada)
chars_format::fixed otimizado mais curto
Adicionados estes recursos de visualização da biblioteca padrão do C++ 20:
Disponível em /std:c++latest :
P0020R6: atomic<floating-point>
P0463R1: enumeração endian
P0482R6: char8_t tipo para caracteres e cadeias de caracteres UTF-8
P0653R2: to_address() para converter um ponteiro em um ponteiro bruto
Disponível em /std:c++17 e /std:c++latest :
P0600R1: [[nodiscard]] na biblioteca
Disponível incondicionalmente:
P0754R2: <version> cabeçalho
P0771R1: std::function o construtor de movimentação deve ser noexcept
O SDK do Windows não é mais uma dependência dos componentes CMake para Windows e CMake para
Linux.
Melhorias no Vinculador de C++ para melhorar significativamente os tempos de build de iteração para a
maior das entradas. /DEBUG:FAST e /INCREMENTAL os horários são em média duas vezes mais rápido, e
/DEBUG:FULL agora é de três a seis vezes mais rápido.

compilador C++
Esses recursos de visualização do C++ 20 foram implementados no compilador C++, disponível em
/std:c++latest :
Maior capacidade de localizar os modelos de função por meio de pesquisa dependente de argumento
para expressões de chamada de função com argumentos de modelo explícitos (P0846R0).
Inicialização designada (P0329R4), que permite que membros específicos sejam selecionados na
inicialização de agregação, por exemplo, usando a Type t { .member = expr } sintaxe.
O suporte a lambda foi revisado, resolvendo um grande número de bugs de longa data. Essa alteração é
habilitada por padrão ao usar o /std:c++latest . No /std:c++17 modo de linguagem e no modo padrão
( /std:c++14 ), o novo analisador pode ser habilitado usando /experimental:newLambdaProcessor , por
exemplo, /std:c++17 /experimental:newLambdaProcessor .
Melhorias da biblioteca padrão do C++
Esses recursos de visualização do C++ 20 foram adicionados à nossa implementação da biblioteca padrão
do C++, disponível em /std:c++latest :
starts_with e ends_with para basic_string e basic_string_view .
contains para contêineres associativos.
remove , remove_if , e unique para list e forward_list agora retornam size_type .
shift_left e shift_right adicionados a <algorithm> .
C++ IDE
IntelliCode paraC++
O IntelliCode agora é fornecido como um componente opcional na carga de trabalho Desenvolvimento para
desktop com C++ . Para saber mais, confira IntelliCode aprimorado para C++ agora vem com o Visual Studio
2019.
O IntelliCode usa seu próprio treinamento extensivo e seu contexto de código para colocar o que você mais
provavelmente usará na parte superior da sua lista de conclusão. Frequentemente, ele é capaz de eliminar a
necessidade de rolar para baixo na lista. Para C++, o IntelliCode oferece a maior ajuda quando você está usando
bibliotecas populares como a biblioteca padrão.
Os recursos de visualização do IntelliCode (modelos personalizados, suporte a C++ e inferência de
EditorConfig) estão desabilitados por padrão. Para habilitá-los, acesse ferramentas > opções > IntelliCode
> geral . Esta versão do IntelliCode tem precisão melhorada e inclui suporte para funções gratuitas. Para obter
mais informações, consulte Sugestões de preenchimento de código auxiliadas por IA para C++ usando
IntelliCode.
Aprimoramentos de informações rápidas
A dica de ferramenta Informações Rápidas agora respeita a colorização semântica do seu editor. Ela também
apresenta um novo link para Pesquisa Online , que pesquisará documentos online que traga mais
informações sobre o constructo de código focalizado. O link fornecido pelas informações rápidas para
código vermelho-ondulado procurará o erro online. Dessa forma, você não precisa digitar a mensagem
novamente no navegador. Para obter mais informações, consulte melhorias de informações rápidas no Visual
Studio 2019: colorização e pesquisa online.
Aprimoramentos gerais
A Barra de Modelo pode preencher o menu suspenso com base em instanciações desse modelo em sua
base de código.
Lâmpadas para diretivas ausentes #include que o vcpkg pode instalar e preenchimento automático de
pacotes disponíveis para a find_package diretiva CMake.
A página de propriedades geral para projetos C++ foi revisada. Algumas opções agora estão listadas em
uma nova página avançada . A página avançado também inclui novas propriedades para sua
arquitetura de conjunto de ferramentas preferida, bibliotecas de depuração, a versão secundária do
conjunto de ferramentas MSVC e compilações de Unity (Jumbo).
Suporte para CMake
Atualizamos a versão do CMake que acompanha o Visual Studio para 3,14. Esta versão adiciona suporte
interno para geradores de MSBuild direcionados a projetos do Visual Studio 2019, bem como APIs de
integração de IDE baseado em arquivo.
Adicionamos melhorias ao editor de configurações do CMake, incluindo suporte para o WSL (subsistema
do Windows para Linux) e configurações de caches existentes, alterações nas raízes de compilação e
instalação padrão e suporte para variáveis de ambiente nas configurações do Linux CMake.
As conclusões e as informações rápidas para comandos, variáveis e propriedades de CMake internas
facilitam a edição dos CMakeLists.txt arquivos.
Integramos o suporte para edição, criação e depuração de projetos CMake com Clang/LLVM. Para saber
mais, veja Suporte a Clang/LLVM no Visual Studio.
Linux e o Subsistema do Windows para Linux
Agora, damos suporte a AddressSanitizer (ASan) em projetos de plataforma cruzada Linux e CMake. Para
saber mais, confira AddressSanitizer (ASan) para carga de trabalho do Linux no Visual Studio 2019.
Integramos o suporte do Visual Studio ao uso do C++ com o subsistema do Windows para Linux (WSL).
Agora você pode usar sua instalação local do subsistema do Windows para Linux (WSL) com o C++
nativamente no Visual Studio sem configuração adicional ou uma conexão SSH. Para saber mais, confira
C++ com Visual Studio 2019 e subsistema Windows para Linux (WSL).
Análise de Código
Foram adicionadas novas correções rápidas para verificações de variáveis não inicializadas. Avisos de análise
de código C6001: usando < variáveis > de memória não inicializadas e C26494 VAR_USE_BEFORE_INIT estão
disponíveis no menu de lâmpada em linhas relevantes. Eles estão habilitados por padrão no conjunto de
regras de tipo de conjunto de regras mínimo nativo da Microsoft e Verificação Principal do C++,
respectivamente. Para saber mais, confira Novas correções rápidas de análise de código para memória não
inicializada (C6001) e avisos de uso antes da inicialização (C26494).
Builds remotos
Agora os usuários podem separar computadores de build remoto de computadores de depuração
remota ao direcionar para Linux, em projetos do MSBuild e do CMake.
O log aprimorado para conexões remotas torna mais fácil diagnosticar problemas no desenvolvimento
de plataforma cruzada.

compilador C++
Suporte aprimorado para recursos e correções exatas do C++17, além de suporte experimental para
recursos de C++20, como módulos e corrotinas. Para obter informações detalhadas, consulte
Aprimoramentos de conformidade do C++ no Visual Studio 2019.
A /std:c++latest opção agora inclui os recursos do c++ 20 que não estão necessariamente completos,
incluindo suporte inicial para o operador do c++ 20 <=> ("espaço") para comparação de três vias.
Agora, a opção de compilador C++ /Gm foi preterida. Considere desabilitar a /Gm opção em seus scripts
de compilação se ela estiver definida explicitamente. No entanto, você também pode ignorar com
segurança o aviso de substituição para o /Gm , porque ele não é tratado como um erro ao usar "tratar
avisos como erros" ( /WX ).
Como MSVC começa a implementar recursos do rascunho do C++ 20 Standard sob o /std:c++latest
sinalizador, /std:c++latest agora é incompatível com /clr (todos os tipos), /ZW e /Gm . No Visual
Studio 2019, use os modos /std:c++17 ou /std:c++14 ao compilar com /clr , /ZW ou /Gm (mas
consulte marcador anterior).
Cabeçalhos pré-compilados não são mais gerados por padrão para aplicativos para desktop e de console
do C++.
Geração de código, segurança, diagnóstico e controle de versão
Análise aprimorada com /Qspectre para fornecer assistência de mitigação para Spectre variante 1 (CVE-2017-
5753). Para obter mais informações, consulte Mitigações do Spectre no MSVC.
Melhorias da biblioteca padrão do C++
Implementação de correções exatas e recursos de biblioteca adicionais do C++17 e do C++20. Para obter
informações detalhadas, consulte Aprimoramentos de conformidade do C++ no Visual Studio 2019.
Clang-Format aplicado aos cabeçalhos da biblioteca padrão de C++ para mais facilidade de leitura.
Como o Visual Studio agora dá suporte a Apenas Meu Código para C++, a biblioteca padrão não precisa
mais fornecer maquinário personalizado para que std::function e std::visit cheguem ao mesmo
efeito. A remoção desse mecanismo não tem efeitos visíveis pelo usuário. Uma exceção é que o
compilador não produzirá mais diagnósticos que indiquem problemas na linha 15732480 ou 16707566
do <type_traits> ou <variant> .
Melhorias de desempenho/taxa de transferência no compilador e na biblioteca padrão
Melhorias de produtividade de build, incluindo a forma como o vinculador manipula a E/S de Arquivo e o
tempo de vinculação na criação e mesclagem de tipo PDB.
Adicionamos suporte básico para vetorização de SIMD OpenMP. Você pode habilitá-lo usando a nova
opção de compilador /openmp:experimental . Esta opção permite que loops anotados com
#pragma omp simd sejam potencialmente vetorizados. A vetorização não é garantida. Um aviso será
relatado para loops anotados, mas não vetorizados. Não há suporte para cláusulas SIMD, elas são
ignoradas com um aviso relatado.
Adicionada uma nova opção de linha de comando de inalinhamento /Ob3 , que é uma versão mais
agressiva do /Ob2 . /O2 (otimizar o binário para velocidade) ainda implica /Ob2 por padrão. Se você
achar que o compilador não está embutido agressivamente suficiente, considere a possibilidade de
passar /O2 -Ob3 .
Adicionamos suporte para funções intrínsecas de SVML (biblioteca matemática de vetores). Essas
funções calculam os equivalentes do vetor de 128 bits, 256 bits ou 512 bits. Nós os adicionamos para dar
suporte à vetorização à mão de loops com chamadas para funções de biblioteca de matemática e outras
operações como divisão de inteiros. Consulte o Guia intrínseco Intel para obter definições das funções
compatíveis.
Novas e aprimoradas otimizações:
Avaliação de constantes e simplificações aritméticas para expressões usando intrínsecos de vetor
de SIMD, tanto para formulários float quanto integer.
Uma análise mais eficiente para extrair informações do fluxo de controle (instruções if/else/switch)
para remover branches que comprovadamente sempre resultam em true ou false.
Desenrolamento aprimorado de memset para usar as instruções do vetor SSE2.
Remoção aprimorada de cópias de classe/struct inúteis, especialmente para programas do C++
que passam por valor.
Aprimorada a otimização de códigos que usam memmove , como as construções std::copy ou
std::vector e std::string .
Otimizado o design físico de biblioteca padrão para evitar a compilação de partes da biblioteca padrão
não incluídas diretamente. Essa alteração reduz o tempo de compilação de um arquivo vazio que inclui
apenas <vector> na metade. Como consequência, talvez você precise adicionar diretivas #include aos
cabeçalhos que foram incluídos anteriormente de maneira indireta. Por exemplo, o código que usa
std::out_of_range agora pode precisar de #include <stdexcept> . O código que usa um operador de
inserção de fluxo agora pode precisar de #include <ostream> . O benefício é que apenas as unidades de
tradução que realmente usam <stdexcept> ou <ostream> componentes pagam o custo da taxa de
transferência para compilá-las.
if constexpr foi aplicado em mais lugares na biblioteca padrão para aumento da taxa de transferência e
redução do tamanho do código em operações de cópia, em permutações como reverter e girar, e na
biblioteca de algoritmos paralelos.
A biblioteca padrão agora usa if constexpr internamente para reduzir os tempos de compilação,
mesmo no modo C++14.
A detecção de vinculação dinâmica do runtime para a biblioteca de algoritmos paralelos não usa mais
uma página inteira para armazenar a matriz do ponteiro de função. Marcar essa memória como somente
leitura deixou de ser considerado relevante para fins de segurança.
O std::thread Construtor não aguarda mais que o thread seja iniciado e não insere mais tantas
camadas de chamadas de função entre a biblioteca C subjacente _beginthreadex e o objeto chamável
fornecido. Anteriormente std::thread , colocamos seis funções entre _beginthreadex o e o objeto
chamável fornecido. Esse número foi reduzido para apenas três, dois dos quais são apenas std::invoke .
Essa alteração também resolve um bug de tempo obscuro, onde um std::thread Construtor deixaria de
responder se o relógio do sistema fosse alterado no momento exato em std::thread que estava sendo
criado.
Correção de uma regressão de desempenho em std::hash que introduzimos ao implementar
std::hash<std::filesystem::path> .
A biblioteca padrão usa destruidores em vez de blocos catch em diversos lugares para chegar à exatidão.
Essa alteração resulta em melhor interação do depurador: exceções que você joga pela biblioteca padrão
nos locais afetados agora aparecem como sendo geradas de seu site de lançamento original, em vez de
nossa Rethrow. Nem todos os blocos de captura de biblioteca padrão foram eliminados. Esperamos que o
número de blocos catch seja reduzido em versões posteriores do MSVC.
A CodeGen subideal em std::bitset causado por uma jogada condicional dentro de uma noexcept
função foi corrigida por meio da fatoração do caminho de lançamento.
A família std::list e std::unordered_* usa iteradores de não depuração internamente em mais locais.
Vários membros std::list foram alterados para reutilizar os nós da lista onde possível, em vez de
desalocá-los e realocá-los. Por exemplo, considerando list<int> que já tenha um tamanho de 3, uma
chamada para assign(4, 1729) agora substitui os int valores nos três primeiros nós da lista e aloca um
novo nó de lista com o valor 1729.
Todas as chamadas da biblioteca padrão para erase(begin(), end()) foram alteradas para clear() .
Agora, std::vector inicializa e apaga os elementos com mais eficiência em determinados casos.
Melhorias em std::variant para torná-lo mais adequado para otimizadores, resultando na geração de
códigos melhores. O inlining de código agora está agora muito melhor com std::visit .
C++ IDE
Suporte de Live Share para C++
Agora, o Live Share dá suporte a C++, permitindo que desenvolvedores usem o Visual Studio ou o Visual Studio
Code para colaborar em tempo real. Para obter mais informações, consulte anunciando o Live share para C++:
Real-Time compartilhamento e colaboração
IntelliSense de modelo
A Barra de Modelo agora utiliza a interface do usuário de Janela de Inspeção em vez de uma janela modal,
dá suporte a modelos aninhados e pré-popula eventuais argumentos padrão na Janela de Inspeção . Para
obter mais informações, veja Melhorias de IntelliSense de modelo para Visual Studio 2019 versão prévia 2. Uma
lista suspensa Usados recentemente na Barra de Modelo permite alternar rapidamente entre conjuntos
anteriores de argumentos de exemplo.
Nova experiência de janela iniciar
Ao iniciar o IDE, uma nova janela inicial é exibida. Ele tem opções para abrir projetos recentes, clonar código do
controle do código-fonte, abrir código local como uma solução ou uma pasta ou criar um novo projeto. A caixa
de diálogo Novo Projeto também foi aprimorada para uma experiência de pesquisa que pode ser filtrada.
Novos nomes para alguns modelos de projeto
Modificamos vários nomes e descrições de modelo de projeto de acordo com a caixa de diálogo Novo Projeto
atualizada.
Diversos aprimoramentos de produtividade
O Visual Studio 2019 inclui os seguintes recursos que o ajudarão a tornar a codificação mais fácil e intuitiva:
Correções rápidas para:
Adicionar ausente #include
NULL em nullptr
Adicionar ponto e vírgula ausente
Resolver namespace ou escopo ausente
Substituir operandos de indireção inválidos ( * to & e & to * )
Informações rápidas para um bloco passando o mouse sobre a chave de fechamento
Espiar Cabeçalho / Arquivo de Código
Ir para definição em #include abre o arquivo
Para obter mais informações, veja Aprimoramentos de produtividade do C++ no Visual Studio 2019 Versão
Prévia 2.
Suporte para CMake
Suporte para CMake 3.14
O Visual Studio agora pode abrir caches do CMake existentes gerados por ferramentas externas, como o
CMakeGUI, ou por sistemas de metabuild personalizados ou scripts de build que invocam cmake.exe eles
mesmos.
Desempenho aprimorado de IntelliSense.
Um novo editor de configurações fornece uma alternativa para editar o arquivo CMakeSettings.json
manualmente e oferece alguma paridade com CMakeGUI.
O Visual Studio ajuda a impulsionar o desenvolvimento de C++ com o CMake no Linux, detectando se
você tem uma versão compatível do CMake em seu computador Linux. Caso contrário, ele oferece
instalá-lo para você.
As incompatibilidades de configuração no CMakeSettings, como arquiteturas incompatíveis ou
configurações incompatíveis do gerador de CMake, mostram linhas irregulares no editor JSON e erros na
Lista de Erros.
A cadeia de ferramentas do vcpkg é detectada automaticamente e habilitada para projetos do CMake que
são abertos no IDE após vcpkg integrate install ser executado. Esse comportamento pode ser
desativado especificando-se um arquivo de cadeia de ferramentas vazio no CMakeSettings.
Projetos do CMake agora permitem depuração Apenas Meu Código por padrão.
Os avisos de análise estática agora são processados em segundo plano e exibidos no editor para projetos
CMake.
Mensagens 'begin' e 'end' mais claras de build e de configuração para projetos do CMake e suporte à
interface do usuário de progresso do build do Visual Studio. Além disso, agora há uma configuração de
detalhes de CMake em Ferramentas > Opções para personalizar o nível de detalhe das mensagens de
build e configuração do CMake na Janela de Saída.
A configuração cmakeToolchain agora é compatível com o CMakeSettings.json para especificar cadeias
de ferramentas sem modificar manualmente a linha de comando do CMake.
Um novo atalho de menu Compilar Tudo****Ctrl + Shift + B .
Integração de IncrediBuild
O IncrediBuild foi incluído como um componente opcional na carga de trabalho Desenvolvimento para
desktop com C++ . O Monitor de Compilação do IncrediBuild foi totalmente integrado no IDE do Visual Studio.
Para obter mais informações, consulte Visualizar sua compilação com o monitor de compilação do IncrediBuild
e o Visual Studio 2019.
Depuração
Para aplicativos C++ em execução no Windows, os arquivos PDBs agora são carregados em um processo
separado de 64 bits. Essa alteração resolve uma variedade de falhas causadas pelo depurador com
memória insuficiente. Por exemplo, ao depurar aplicativos que contêm um grande número de módulos e
arquivos PDB.
A pesquisa está habilitada nas janelas Inspeção , Autos e Locais .
Desenvolvimento da Área de Trabalho do Windows com C++
Estes assistentes do C++ ATL/MFC não estão mais disponíveis:
Assistente de componente de COM+ 1.0 da ATL
Assistente do componente Active Server Page da ATL
Assistente de provedor OLE DB da ATL
Assistente de página de propriedades da ATL
Assistente de consumidor OLE DB da ATL
Consumidor ODBC do MFC
Classe MFC em Controle ActiveX
Classe MFC em TypeLib.
O código de exemplo para essas tecnologias está arquivado em Microsoft Docs e no repositório GitHub
VCSamples.
O SDK (Software Development Kit) do Windows 8.1 não está mais disponível no instalador do Visual
Studio. Recomendamos atualizar seus projetos em C++ para o SDK do Windows 10 mais recente. Se
você tiver uma dependência forte no 8.1, poderá baixá-la do arquivo do SDK do Windows.
O direcionamento do Windows XP não estará mais disponível para o conjunto de ferramentas do C++
mais recente. O direcionamento do XP com bibliotecas e o compilador MSVC no nível do VS 2017 ainda
é compatível e pode ser instalado por meio de "Componentes individuais".
Nossa documentação desencoraja ativamente o uso de módulos de mesclagem para a implantação do
Runtime do Visual C++. Estamos realizando, nesta versão, a etapa extra de marcar nossos MSMs como
preteridos. Considere migrar sua implantação central do VCRuntime de MSMs para o pacote
redistribuível.
Desenvolvimento móvel com C++ (Android e iOS )
A experiência do Android C++ agora usa por padrão o SDK do Android 25 e o NDK do Android 16b.
Conjunto de ferramentas de plataforma Clang/C2
O componente experimental Clang/C2 foi removido. Use o conjunto de ferramentas do MSVC para
conformidade total de padrões C++ com /permissive- e /std:c++17 ou a cadeia de ferramentas Clang/LLVM
para Windows.
Análise de código
A análise de código agora é executada automaticamente em segundo plano. Avisos são exibidos como
linhas irregulares verdes no editor conforme você digita. Para obter mais informações, consulte Análise
de código no editor no Visual Studio 2019 Versão Prévia 2.
Novas regras experimentais de ConcurrencyCheck para tipos de biblioteca padrão conhecidos do
<mutex> cabeçalho. Para obter mais informações, consulte Análise de código de simultaneidade no
Visual Studio 2019.
Uma implementação parcial atualizada do Verificador de perfil de tempo de vida, que detecta referências
e ponteiros pendentes. Para obter mais informações, consulte Atualização de perfil de tempo de vida no
Visual Studio 2019 Versão Prévia 2.
Mais verificações relacionadas a corrotinas, incluindo C26138, C26810, C26811e a regra experimental
C26800. Para obter mais informações, consulte Novas verificações de análise de código no Visual Studio
2019: uso após movimentação e corrotina.
Teste de unidade
O modelo de projeto de teste do C++ gerenciado não está mais disponível. Você pode continuar usando a
estrutura de teste do C++ gerenciado em seus projetos existentes. Para novos testes de unidade, considere usar
uma das estruturas de teste nativas para as quais o Visual Studio fornece modelos (MSTest, Google Test) ou o
modelo de projeto de teste de C# gerenciado.
O Visual Studio 2017 traz muitas atualizações e correções para o ambiente do C++. Corrigimos mais de 250
bugs e relataram problemas no compilador e nas ferramentas. Muitos foram enviados por clientes por meio do
relatório de um problema e fornecem uma sugestão de opções em enviar comentários . Obrigado por relatar
bugs!
Para saber mais sobre todas as novidades do Visual Studio, visite Novidades no Visual Studio 2017. Para saber
mais sobre novidades de C++ no Visual Studio 2019, confira Novidades de C++ no Visual Studio. Para saber
mais sobre as novidades de C++ no Visual Studio 2015 e em versões anteriores, confira O que há de novo no
Visual C++ de 2003 a 2015. Para obter informações sobre as novidades nos documentos do C++, consulte
Microsoft C++ docs: What ' s New.
compilador Visual Studio de 2017 de C++

Aprimoramentos de conformidade do C++
Atualizamos o compilador C++ e a biblioteca padrão nesta versão com suporte aprimorado para os recursos
C++ 11 e C++ 14. Ele também inclui suporte preliminar para determinados recursos que devem estar no
padrão C++ 17. Para obter informações detalhadas, consulte Aprimoramentos de conformidade do C++ no
Visual Studio 2017.
Vi su a l St u d i o 2 0 1 7 v e r sã o 1 5 .5
O compilador dá suporte a cerca de 75% dos recursos que são novos no C++ 17, incluindo associações
estruturadas, constexpr lambdas, if constexpr variáveis embutidas, expressões de dobra e adição noexcept
ao sistema de tipos. Esses recursos estão disponíveis na /std:c++17 opção. para obter mais informações,
consulte melhorias de conformidade do C++ no Visual Studio 2017
Agora, o conjunto de ferramentas do compilador do MSVC no Visual Studio versão 15.7 é compatível com o
padrão do C++. para obter mais informações, consulte anunciando: MSVC está em conformidade com a
compatibilidade de linguagem c++ Standard e Microsoft C/C++.
a /experimental:preprocessor opção de compilador habilita o novo pré-processador de MSVC experimental

que, eventualmente, estará em conformidade com todos os padrões de C e C++ aplicáveis. para obter mais
informações, consulte MSVC visão geral do novo pré-processador.
Novas opções do compilador
/permissive- : Habilite todas as opções de compilador de conformidade de padrões estritos e desabilite a
maioria das extensões de compilador específicas da Microsoft (mas não __declspec(dllimport) , por
exemplo). Essa opção está ativada por padrão no Visual Studio 2017 versão 15.5. O /permissive- modo
de conformidade inclui suporte para pesquisa de nome de duas fases. Para obter mais informações,
consulte melhorias de conformidade do C++ em Visual Studio.
/diagnostics : Habilita a exibição do erro de diagnóstico ou local de aviso de três maneiras diferentes:
apenas o número de linha, o número de linha e a coluna, ou o número de linha e coluna, com um cursor
sob a linha de código incorreto.
/debug:fastlink: habilite até 30% mais rápido de tempo de link incremental (vs. Visual Studio 2015), não
copiando todas as informações de depuração no arquivo PDB. Em vez disso, o arquivo PDB aponta para
as informações de depuração para os arquivos de biblioteca e de objeto usados para criar o executável.
consulte ciclo de compilação C++ mais rápido em VS "15 /Debug:fastlink " com e Recomendações para
acelerar as compilações do C++ no Visual Studio.
Visual Studio 2017 permite usar /sdl com /await . Removemos a /RTC limitação com corrotinas.
/std:c++14 e /std:c++latest : essas opções de compilador permitem que você aceite versões
específicas da linguagem de programação ISO C++ em um projeto. A maioria dos novos recursos padrão
de rascunho é protegida pela /std:c++latest opção.
/std:c++17 habilita o conjunto de recursos C++ 17 implementados pelo compilador. Esta opção
desabilita o suporte do compilador e da biblioteca padrão para recursos após C++ 17: aqueles que são
alterados ou novos em versões posteriores do rascunho de trabalho e atualizações de defeito do padrão
C++. Para habilitar esses recursos, use /std:c++latest .
Geração de código, segurança, diagnóstico e controle de versão
Esta versão apresenta várias melhorias na otimização, na geração de código, no controle de versão do conjunto
de ferramentas e nos diagnósticos. Alguns aprimoramentos importantes incluem:
Melhor geração de código de loops: suporte para vetorização automática da divisão de inteiros constantes,
melhor identificação de padrões de memset.
Segurança de código aprimorada: emissão aprimorada de diagnóstico de compilador de saturação de buffer
e /guard:cf agora protege instruções de switch que geram tabelas de salto.
Controle de versão: o valor da macro de pré-processador interna _ MSC _ Ver agora está sendo atualizado
de forma monotônico em cada atualização de conjunto de ferramentas Visual C++. Para obter mais
informações, consulte Versão do compilador do Visual C++.
Novo layout do conjunto de ferramentas: o compilador e as ferramentas de build relacionadas têm um novo
local e nova estrutura de diretório em seu computador de desenvolvimento. O novo layout habilita
instalações lado a lado de várias versões do compilador. Para saber mais, confira Layout de ferramentas do
compilador no Visual Studio 2017.
Diagnósticos aprimorados: a janela de saída agora mostra a coluna em que ocorre um erro. Para obter mais
informações, consulte melhorias do diagnóstico do compilador do C++ em vs "15" Preview 5.
Ao usar corrotinas, a palavra-chave experimental yield (disponível na /await opção) foi removida. Em vez
disso, seu código deve ser atualizado para usar co_yield . Para obter mais informações, consulte yield
palavra-chave para se tornar co_yield em vs 2017.
Aprimoramentos adicionais para o diagnóstico no compilador. Para saber mais, confira Aperfeiçoamentos de
diagnóstico no Visual Studio 2017 15.3.0.
Visual C++ o desempenho do tempo de execução continua a melhorar por meio da melhor qualidade de código
gerada. Agora você pode simplesmente recompilar o código e o aplicativo será executado mais rapidamente.
Algumas das otimizações do compilador são totalmente novas, como a vetorização de repositórios escalares
condicionais, a combinação de chamadas sin(x) e cos(x) em um novo sincos(x) e a eliminação de
instruções redundantes do otimizador de SSA. Outras otimizações de compilador são melhorias na
funcionalidade existente, como a heurística vetorizador automático para expressões condicionais, otimizações
de loop melhores e CodeGen flutuante mín/máx. O vinculador tem uma implementação nova e mais rápida
/OPT:ICF , que pode resultar em até 9% de aumentos de tempo de vinculação, e há outras correções de
desempenho na vinculação incremental. Para obter mais informações, consulte /OPT (Otimizações) e
/INCREMENTAL (Vincular de maneira incremental).
O compilador do Microsoft C++ dá suporte ao AVX-512 da Intel. Ele tem instruções de comprimento de vetor
que trazem novas funções em AVX-512 a registros de largura de 128 bits e 256 bits.
A /Zc:noexceptTypes- opção pode ser usada para reverter para a versão c++ 14 do noexcept ao usar o modo
c++ 17 em geral. Essa opção permite que você atualize seu código-fonte para estar em conformidade com a
C++17 sem precisar reescrever todo o código throw() ao mesmo tempo. Para obter mais informações,
consulte Remoção de especificação de exceção dinâmica e noexcept.
Novo compilador switch /Qspectre para ajudar a mitigar contra ataques de canal lateral de execução
especulativa. Para obter mais informações, consulte mitigações Spectre em MSVC.
Novo aviso de diagnóstico da mitigação do Spectre. Para saber mais, confira Diagnóstico do Spectre no
Visual Studio 2017 versão 15.7 versão prévia 4.
Um novo valor para/ZC, /Zc:__cplusplus , permite a emissão de relatórios corretos do suporte standard do
C++. Por exemplo, quando a opção é definida e o compilador está no /std:c++17 modo, o valor expande
para 201703L . Para saber mais, confira Agora o MSVC relata corretamente __cplusplus.
Biblioteca padrão C++

Melhorias de correção
Vi su a l St u d i o 2 0 1 7 R T M (v e r sã o 1 5 .0 )
Melhorias de diagnóstico secundárias basic_string _ITERATOR_DEBUG_LEVEL != 0 . Quando uma verificação

de IDL é ultrapassada em uma máquina de cadeia de caracteres, ela agora relatará o comportamento
específico que causou a viagem. Por exemplo, em vez de "não é possível desreferenciar o iterador de cadeia
de caracteres", você verá "não é possível desreferenciar o iterador de cadeia de caracteres porque ele está
fora do intervalo (por exemplo, um iterador de fim)".
O operador de atribuição de mudança std::promise foi corrigido, pois anteriormente poderia causar
bloqueio indefinido no código.
Erros de compilador corrigidos, com a conversão implícita de atomic<T*> em T* .
pointer_traits<Ptr> agora detecta Ptr::rebind<U> corretamente.
Foi corrigido um const qualificador ausente no move_iterator operador de subtração.
Corrigido o gerador de código inválido silencioso para alocadores definidos pelo usuário com estado
solicitando propagate_on_container_copy_assignment e propagate_on_container_move_assignment .
atomic<T> agora tolera o operator&() sobrecarregado.
Pequena melhoria no diagnóstico do compilador para chamadas bind() incorretas.
há mais melhorias na biblioteca standard no Visual Studio 2017 RTM. Para obter uma lista completa, consulte a
entrada de blog da equipe do C++ correções de biblioteca padrão no VS 2017 RTM.
Os contêineres da biblioteca padrão agora fixam o max_size() ao numeric_limits<difference_type>::max()

em vez do max() de size_type . Essa alteração garante que o resultado de distance() nos iteradores do
contêiner seja representável no tipo de retorno de distance() .
Especialização auto_ptr<void> ausente corrigida.
Os for_each_n() generate_n() algoritmos , e falharam anteriormente na search_n() compilação se o
argumento length não fosse um tipo integral. Agora, eles tentam converter comprimentos não integrais para
o dos difference_type iteradores.
normal_distribution<float> não emite mais avisos na biblioteca padrão sobre o estreitamento de double
para float.
Corrigidas algumas operações basic_string que usavam npos em vez de max_size() durante a verificação
de estouro de tamanho máximo.
condition_variable::wait_for(lock, relative_time, predicate) aguardaria o tempo relativo inteiro se
houvesse um a wake desapertado. Agora, ele aguarda apenas um único intervalo do tempo relativo.
future::get() agora invalida o future , como o padrão exige.
iterator_traits<void *> era um erro de hardware porque tentava formar void& ; agora claramente torna-se
um struct vazio para permitir o uso de iterator_traits em condições SFINAE "is iterator".
Alguns avisos relatados por Clang -Wsystem-headers foram corrigidos.
Também foi corrigida a "especificação de exceção na declaração não corresponder à declaração anterior"
relatada por Clang -Wmicrosoft-exception-spec .
Também corrigidos os avisos de ordenação mem-initializer-list relatados por Clang e C1XX.
Os contêineres não ordenados não trocavam funções de hash ou predicados quando os próprios contêineres
eram trocados. Agora eles fazem isso.
Muitas operações de permuta de contêiner agora estão marcadas (pois nossa biblioteca padrão nunca
pretende lançar uma exceção ao detectar a condição de comportamento não igual a alocador noexcept
propagate_on_container_swap indefinido).
Muitas vector<bool> operações agora estão marcadas como noexcept .
A biblioteca padrão agora imporá o alocador de correspondência value_type (no modo C++17) com uma
hachura de escape de recusa.
Corrigidas algumas condições em que self-range-insert em basic_string misturaria o conteúdo das cadeias
de caracteres. (Observação: self-range-insert em vectors ainda é proibido pelo Standard.)
basic_string::shrink_to_fit() não é mais afetado pelo propagate_on_container_swap do alocador.
std::decay agora lida com tipos de função abomináveis, ou seja, tipos de função qualificados por cv, ref-
qualified ou ambos.
Alteradas as diretivas de inclusão para usar diferenciação adequada de maiúsculas e minúsculas e barras
invertidas, melhorando a portabilidade.
Corrigido o aviso C4061 "enumerador 'enumerador' na opção de enumeração 'enumeração' não é
manipulado explicitamente por um rótulo case". Esse aviso é desativado por padrão e foi corrigido como
uma exceção à política geral da biblioteca padrão para avisos. (A biblioteca padrão /W4 está limpa, mas não
tenta ser /Wall limpa. Muitos avisos fora do padrão são normalmente barulhentos e não se destinam a
serem usados regularmente.)
Melhoria nas verificações de depuração de std::list . Os iteradores de lista agora verificam operator->() e
list::unique() agora marca os iteradores como invalidados.
Corrigida a metaprogramação de uses-allocator em tuple .
std::partition agora chama os tempos de N predicado em vez N + 1 de vezes, como o padrão exige.
As tentativas de evitar estáticas mágicas na versão 15.3 foram reparadas na versão 15.5.
std::atomic<T> não requer mais que T seja construível por padrão.
Algoritmos de heap que levam tempo logarítmico se comportam de maneira diferente quando a depuração
do iterador está habilitada. Eles não fazem mais uma declaração de tempo linear de que a entrada é, na
verdade, um heap.
__declspec(allocator) agora é protegido apenas para C1XX a fim de evitar avisos do Clang que não
entendem esse declspec.
basic_string::npos agora está disponível como uma constante de tempo de compilação.
std::allocator no modo C++17 agora lida corretamente com a alocação de tipos sobrelinhados, ou seja,
tipos cujo alinhamento é maior que , a menos que desabilitado max_align_t por /Zc:alignedNew- . Por
exemplo, vetores de objetos com alinhamento de 16 ou de 32 bytes agora serão corretamente alinhados
para instruções SSE e AVX.
Aprimoramentos de conformidade
Adicionamos <any> , , , <string_view> apply() make_from_tuple() .
Adicionado <optional> , , e <variant> shared_ptr::weak_type <cstdalign> .
Habilitado C++14 constexpr min(initializer_list) em , e , e max(initializer_list) ,
minmax(initializer_list) e min_element() max_element() minmax_element() .
Para obter mais informações, consulte Conformidade da linguagem C/C++ da Microsoft.

Vários recursos adicionais do C++17 foram implementados. Para obter mais informações, consulte Tabela de
conformidade da linguagem C++ da Microsoft.
Implementado P0602R0 "variante e opcional devem propagar a trivialidade copiar/mover".
A biblioteca padrão agora oficialmente tolera RTTI dinâmico sendo desabilitado por meio da opção /GR-. E
dynamic_pointer_cast() rethrow_if_nested() exigem inerentemente dynamic_cast , portanto, a biblioteca
padrão agora os marca como =delete em /GR- .
Mesmo quando o RTTI dinâmico foi desabilitado por meio de , "RTTI estático" na forma de ainda está
disponível e alimenta /GR- typeid(SomeType) vários componentes de biblioteca padrão. A biblioteca padrão
agora dá suporte à desabilitação desse recurso também, por meio de /D_HAS_STATIC_RTTI=0 . Esse sinalizador
também desabilitará std::any , as funções membro target() e target_type() de std::function e a função
membro amigável get_deleter() de std::shared_ptr e de std::weak_ptr .
A biblioteca padrão agora usa C++14 constexpr incondicionalmente, em vez de macros definidas
condicionalmente.
A biblioteca padrão agora usa modelos de alias internamente.
A biblioteca padrão agora usa nullptr internamente, em vez de nullptr_t{} . (O uso interno de NULL foi
erradicado. O uso interno de 0-as-null está sendo eliminado gradualmente.)
A biblioteca padrão agora usa std::move() internamente, em vez de usar std::forward() de maneira
estilística indevidamente.
static_assert(false, "message") foi alterado por #error message . Essa alteração melhora o diagnóstico do
compilador porque #error interrompe imediatamente a compilação.
A biblioteca padrão não marca mais funções como __declspec(dllimport) . A tecnologia moderna de
vinculador não exige mais isso.
SFINAE extraído para argumentos de modelo padrão, o que reduzia a desordem em comparação com tipos
de retorno e tipos de argumento de função.
As verificações de depuração no agora usam o computador normal da biblioteca padrão, em vez da função
interna , que <random> _Rng_abort() chamou fputs() stderr . A implementação dessa função foi mantida
para compatibilidade binária. Vamos removê-lo na próxima versão incompatível binária da biblioteca padrão.
Vários recursos de biblioteca padrão foram adicionados, preterido ou removidos de acordo com o padrão
C++17. Para obter mais informações, consulte Melhorias de conformidade do C++ no Visual Studio.
Suporte experimental para os seguintes algoritmos paralelos:
all_of
any_of
for_each
for_each_n
none_of
reduce
replace
replace_if
sort
As assinaturas para os algoritmos paralelos a seguir são adicionadas, mas não paralelizadas no momento. A
criação de perfil não mostrou nenhum benefício na paralelização de algoritmos que apenas movem ou
permute elementos:
copy
copy_n
fill
fill_n
move
reverse
reverse_copy
rotate
rotate_copy
swap_ranges
<memory_resource>
Princípios básicos da biblioteca V1
Exclusão da atribuição polymorphic_allocator
Melhorias na dedução de argumento de modelo de classe
Suporte a algoritmos paralelos não é mais experimental

Uma nova implementação de <filesystem>
Conversões elementares de cadeia de caracteres (parcial)
std::launder()
std::byte
hypot(x,y,z)
Evitar decaimento desnecessário
Funções matemáticas especiais
constexpr char_traits
Guias de dedução da biblioteca padrão
Para obter mais informações, consulte Conformidade da linguagem C/C++ da Microsoft.
Correções de desempenho e taxa de transferência
Fez sobrecargas basic_string::find(char) chamar traits::find apenas uma vez. Anteriormente, isso era
implementado como uma pesquisa de cadeia de caracteres geral para de uma cadeia de caracteres de
comprimento 1.
basic_string::operator== agora verifica o tamanho da cadeia de caracteres antes de comparar o conteúdo
das cadeias de caracteres.
Removido o acoplamento de controle em basic_string , que dificultava a análise do otimizador do
compilador. Para todas as cadeias de caracteres curtas, chamar reserve ainda não tem certo custo por não
fazer nada.
std::vector foi reformulado para a correção e o desempenho: o alias durante as operações de inserção e
inserção agora é tratado corretamente conforme exigido pelo Padrão, a garantia de exceção forte agora é
fornecida quando exigido pelo Padrão por meio de e outra lógica e inserir fazem menos operações de
move_if_noexcept() elemento.
A biblioteca padrão do C++ agora evita desreferenciar ponteiros nulos sofisticados.
Desempenho de weak_ptr::lock() aprimorado.
Para aumentar a taxa de transferência do compilador, os cabeçalhos da biblioteca padrão do C++ agora
evitam incluir declarações para intrínsecos do compilador que são desnecessários.
Aumento mais de três vezes do desempenho dos construtores de movimento std::string e std::wstring .
Trabalhou em torno de interações com , o que impedia a inlining da implementação em noexcept funções
que usam o SEH (Tratamento de std::atomic Exceção Estruturada).
Alterada a função interna _Deallocate() da biblioteca padrão para ser otimizada em código menor,
permitindo que ele seja embutido em outros locais.
Alterado std::try_lock() para usar a expansão de pacote em vez de recursão.
O algoritmo de impedimento de deadlock std::lock() foi melhorado para usar operações lock() em vez
de girar em try_lock() em todos os bloqueios.
Habilitada a otimização de valor retornado nomeado em system_category::message() .
conjunction e disjunction agora insinuam N + 1 tipos, em vez de 2N + 2 tipos.
std::function não instancia mais máquinas de suporte de alocador para cada chamável apagado por tipo,
melhorando a taxa de transferência e reduzindo o tamanho de .obj em programas que passam vários
lambdas distintos para std::function .
allocator_traits<std::allocator> contém operações std::allocator manualmente embutidas, o que reduz
o tamanho do código que interage com std::allocator apenas por meio de allocator_traits (ou seja, no
maioria dos códigos).
A interface de alocador mínima C++11 agora é manipulada pela biblioteca padrão chamando
allocator_traits diretamente, em vez de encapsular o alocador em uma classe interna _Wrap_alloc . Isso
reduz o tamanho do código gerado compatível com o alocador, melhora a capacidade do otimizador de
raciocinar sobre contêineres da Biblioteca Padrão em alguns casos e fornece uma melhor experiência de
depuração (porque agora você pode ver o tipo de alocador, em vez de _Wrap_alloc<your_allocator_type> no
depurador).
Remoção da metaprogramação para allocator::reference personalizados, que os alocadores não têm
permissão para personalizar. (Os alocadores podem fazer contêineres usarem ponteiros sofisticados, mas
não referências sofisticadas.)
O front-end do compilador foi ensinado a descompactar iteradores de depuração em loops for baseados em
intervalo, melhorando o desempenho de compilações de depuração.
O caminho de redução interna de basic_string para shrink_to_fit() e para reserve() não está mais no
caminho das operações de realocação, o que reduz o tamanho do código para todos os membros de
mutação.
O caminho de crescimento interno basic_string não está no caminho de shrink_to_fit() .
As operações de mutação de basic_string agora são fatoradas em funções de caminho rápido de não
alocação e de caminho lento de alocação, aumentando a probabilidade de o caso comum de não realocação
ser embutido em chamadores.
As basic_string operações de mutação agora constróem buffers realocados no estado preferencial, em vez
de reizing in-loco. Por exemplo, uma inserção no início de uma cadeia de caracteres agora move o conteúdo
após a inserção exatamente uma vez. Ele foi movido para baixo ou para o buffer recém-alocado. Ele não é
mais movido duas vezes no caso de realocação, primeiro para o buffer recém-alocado e, em seguida, para
baixo.
As operações que chamam a biblioteca padrão C <string> no agora armazenam em cache errno o
endereço para remover a interação repetida com o TLS.
Implementação is_pointer simplificada.
Foi concluída a alteração da Expressão SFINAE baseada em função struct para e com base em void_t .
Os algoritmos de biblioteca padrão agora evitam iteradores de pós-incrementação.
Corrigidos os avisos de truncamento ao usar alocadores de 32 bits em sistemas de 64 bits.
A atribuição de movimentação std::vector agora é mais eficiente para o caso de alocador não igual a não
POCMA reutilizando o buffer quando possível.
basic_string<char16_t> agora aciona o mesmo memcmp , memcpy e otimizações semelhantes que acionam
basic_string<wchar_t> .
Uma limitação do otimizador que impedia os ponteiros de função de serem embutidos e que foi exposta
pelo nosso trabalho "evitar a cópia de funções" no Visual Studio 2015 Atualização 3 foi solucionada,
restaurando o desempenho de lower_bound(iter, iter, function pointer) .
A sobrecarga da verificação da ordem de entradas da depuração do iterador para includes , set_difference ,
set_symmetric_difference e set_union foi reduzida desencapsulando iteradores antes de verificar a ordem.
std::inplace_merge agora ignora elementos que já estão no lugar.
Construir std::random_device agora não constrói e, em seguida, destrói um std::string .
std::equal e std::partition tinham uma passagem de otimização de jump-threading que salvava uma
comparação de iterador.
Quando for passado ponteiros em std::reverse para T facilmente copiado, ele agora enviará uma
implementação vetorizada manuscrita.
std::fill , std::equal e std::lexicographical_compare foram ensinados a enviar a memset e a memcmp
para std::byte e para gsl::byte (e outras classes de enumeração e enumerações similares a char). Como
std::copy envia usando is_trivially_copyable , ele não precisa de nenhuma alteração.
A biblioteca padrão não contém mais destruidores com chaves vazias cujo único comportamento era tornar
os tipos em não facilmente destrutíveis.
Outras bibliotecas
Suporte à biblioteca de software livre
Vcpkg é uma ferramenta de linha de comando de software livre que simplifica bastante o processo de aquisição
e de compilação de bibliotecas estáticas e de DLLS de software livre do C++ no Visual Studio. Para obter mais
informações, consulte vcpkg.
CPPRest SDK 2.9.0
A CPPRestSDK, uma API da Web de plataforma cruzada para o C++, foi atualizada para a versão 2.9.0. Para
obter mais informações, consulte CppRestSDK 2.9.0 está disponível no GitHub.
ATL
Ainda outro conjunto de correções de compatibilidade de pesquisa de nome

Construtores de movimentação e operadores de atribuição existentes são agora corretamente marcados
como sem lançamento
Não suprimir aviso C4640 válido sobre a inicialização segura de thread de estatísticas locais no atlstr.h
A inicialização thread-safe de estáticas locais foi desligada automaticamente no grupo de ferramentas XP ao
usar a ATL para criar uma DLL. Agora não é. Você pode /Zc:threadSafeInit- adicionar em suas Project
configurações de configuração se não quiser inicialização thread-safe.
runtime do Visual C++
Novo cabeçalho "cfguard.h" para símbolos de proteção de fluxo de controle.
Visual Studio IDE do C++ 2017

Agora, o desempenho de alteração de configuração é melhor para projetos nativos C++ e muito melhor para
projetos C++/CLI. Quando uma configuração de solução for ativada pela primeira vez, depois ela será mais
rápida, e todas as ativações subsequentes dessa configuração de solução serão quase instantâneas.
Vários assistentes de código e de projeto foram reescritos no estilo de caixa de diálogo de assinatura.
Adicionar Classe agora inicia o assistente Adicionar Classe diretamente. Todos os outros itens que estavam
anteriormente aqui agora estão disponíveis em Adicionar > Novo Item .
Os projetos Win32 agora estão na categoria Windows Desktop na caixa de diálogo Project Novo.
Os modelos Windows Console e Aplicativo de Área de Trabalho agora criam os projetos sem exibir um
assistente. Há um novo Assistente de Área de Trabalho do Windows na mesma categoria que exibe as
mesmas opções que o antigo assistente Aplicativo de Console do Win32 .
Diversas operações C++ que usam o mecanismo IntelliSense para refatoração e navegação de código são
executadas muito mais rápido. Os números a seguir se baseiam na solução do Visual Studio Chromium com
3500 projetos:
REC URSO M EL H O RIA DE DESEM P EN H O
Renomear 5.3x
Alterar assinatura 4.5x
Localizar Todas as Referências 4.7x
O C++ agora é compatível com Ctrl + Clique em Ir para Definição , facilitando a navegação do mouse para
definições. O Visualizador de Estrutura do pacote de Ferramentas Avançadas de Produtividade agora também
está incluído no produto por padrão.
IntelliSense
O novo mecanismo de banco de dados com base em SQLite agora está sendo usado por padrão. O novo
mecanismo acelera as operações de banco de dados, como Ir para Definição e Encontrar Todas as
Referências. Ele melhora significativamente o tempo de análise da solução inicial. A configuração foi
movida para Ferramentas > Opções > Editor de Texto > C/C++ > Avançado. (Ele estava
anteriormente em ... C/C++ > Experimental.)
Melhoramos o desempenho do IntelliSense em projetos e arquivos que não estão usando cabeçalhos
pré-compilados – um Cabeçalho Pré-Compilado Automático será criado para os cabeçalhos no arquivo
atual.
Adicionamos filtragem de erros e ajuda para erros do IntelliSense e na lista de erros. Agora, ao clicar na
coluna de erro é possível filtrar. Além disso, clicar em erros específicos ou pressionar F1 iniciará uma
pesquisa online sobre a mensagem de erro.
Adicionada a capacidade de filtrar por tipo os itens da Lista de Membros.

Adicionado um novo recurso experimental Predictive IntelliSense, que fornece filtragem ciente de
contexto daquilo que aparece na Lista de Membros. Para saber mais, confira Melhorias do IntelliSense no
C++ – IntelliSense Preditivo e Filtragem.
Agora, Encontrar Todas as Referências (Shift+F12) ajuda você a se deslocar facilmente, mesmo em
bases de código complexas. Ela fornece agrupamento, filtragem, classificação e pesquisa avançada nos
resultados e, para algumas linguagens, colorização, para que você obtenha uma compreensão clara de
suas referências. Para o C++, a nova interface do usuário inclui informações sobre se estamos lendo de
uma variável ou gravando em uma variável.
O recurso Dot-to-Arrow IntelliSense passou de experimental a avançado e agora está habilitado por
padrão. Os recursos do editor Expand Scopes e Expand Precedence também foram movidos de
experimental para avançado.
Os recursos de refação experimental Alterar Assinatura e Extrair Função agora estão disponíveis por
padrão.
Adicionada uma funcionalidade experimental "Carregamento de projeto mais rápido" para projetos C++.
Na próxima vez que você abrir um projeto C++, ele será carregado mais rapidamente e, depois disso, ele
será carregado muito mais rapidamente!
Alguns desses recursos são comuns a outras linguagens e alguns são específicos do C++. Para saber
mais sobre essas novas funcionalidades, veja Anúncio do Visual Studio "15" Preview 5.
Foi adicionado o suporte a ClangFormat. Para obter mais informações, veja Suporte a ClangFormat no Visual
Studio 2017.
Projetos não MSBuild com Abrir Pasta

Visual Studio 2017 apresenta o recurso abrir pasta . Ele permite que você codifique, crie e depure em uma
pasta que contém o código-fonte sem a necessidade de criar soluções ou projetos. Agora ficou muito mais fácil
começar a usar o Visual Studio, mesmo que seu projeto não seja um projeto do MSBuild. A pasta aber ta
oferece acesso a recursos avançados de compreensão, edição, criação e depuração de código. eles são os
mesmos que Visual Studio já fornece para projetos MSBuild. Para saber mais, veja Projetos Open Folder para
C++.
Melhorias na experiência de Abrir Pasta. Você pode personalizar a experiência por meio destes arquivos .json:
CppProperties.json para personalizar a experiência de navegação e do IntelliSense.
Tasks.json para personalizar as etapas de build.
Launch.json para personalizar a experiência de depuração.
Suporte aprimorado para ambientes de compilação e compiladores alternativos como MinGW e Cygwin.
Para saber mais, veja Usando MinGW e Cygwin com Visual C++ e Abrir Pasta.
Adicionado compatibilidade para definir variáveis de ambiente globais e específicas de configuração em
CppProperties.json e em CMakeSettings.json. Essas variáveis de ambiente podem ser consumidas por
configurações de depuração definidas em launch.vs.json e em tarefas em tasks.vs.json. Para saber mais, veja
Personalizando seu ambiente com o Visual C++ e Abrir Pasta.
Suporte aprimorado para o gerador Ninja do CMake, incluindo a capacidade de direcionar facilmente
plataformas de 64 bits.
Suporte a CMake através do Open Folder

O Visual Studio 2017 apresenta suporte ao uso de projetos CMake sem a conversão para arquivos de projeto
MSBuild (.vcxproj). Para saber mais, confira Projetos CMake no Visual Studio. Abrir projetos do CMake com a
pasta aber ta configura automaticamente o ambiente para edição, criação e depuração de C++.
O C++ IntelliSense funciona sem a necessidade de criar um arquivo CppProperties.json na pasta raiz.
Também adicionamos uma nova lista suspensa para permitir aos usuários mudar facilmente entre as
configurações fornecidas pelos arquivos CppProperties.json e CMake.
Há suporte para configurações adicionais por meio de um arquivo CMakeSettings.json que reside na
mesma pasta que o arquivo CMakeLists.txt.
Suporte adicionado para o gerador Ninja do CMake.

Suporte adicionado para importação de caches de CMake existentes.

Suporte adicionado para CMake 3.11, análise de código em projetos CMake, exibição de destinos no
Gerenciador de Soluções, opções de geração de cache e compilação de arquivo único. Para obter mais
informações, confira Suporte a CMake no Visual Studio e Projetos CMake no Visual Studio.
Desenvolvimento da área de trabalho do Windows

Agora, fornecemos uma experiência de instalação mais granular da carga de trabalho original do C++.
Adicionamos componentes selecionáveis que permitem a instalação apenas das ferramentas das quais você
precisa. Os tamanhos de instalação indicados para os componentes listados na interface do usuário do
instalador estão incorretos e subestimam o tamanho total.
Para criar projetos Win32 com êxito na carga de trabalho de área de trabalho C++, é necessário instalar um
conjunto de ferramentas e um SDK do Windows. Instalar os componentes recomendados (selecionados)
Conjunto de ferramentas do VC++ 2017 v141 (x86, x64) e SDK do Windows 10 (10.0.nnnnn)
garantirá que isso funcionará. Se as ferramentas necessárias não estiverem instaladas, os projetos não serão
criados com êxito e o assistente deixará de responder.
As Ferramentas de Build do Visual C++ (anteriormente disponíveis como um produto autônomo) agora estão
incluídas como uma carga de trabalho no Instalador do Visual Studio. Essa carga de trabalho instala somente as
ferramentas necessárias para compilar projetos C++ sem instalar o IDE do Visual Studio. Ambos os conjuntos
de ferramentas v140 e v141 estão incluídos. O conjunto de ferramentas v141 contém as melhorias mais
recentes do Visual Studio 2017 versão 15.5. Para obter mais informações, consulte As Ferramentas de Build do
Visual Studio agora incluem o VS2017 e Conjuntos de Ferramentas do VS2015 MSVC.
Desenvolvimento de Linux com C++

A extensão popular Visual C++ para Desenvolvimento no Linux agora faz parte do Visual Studio. Essa instalação
fornece tudo o que você precisa para desenvolver e depurar aplicativos em C++, em execução em um ambiente
Linux.
Foram feitas melhorias na visualização de tipo e no compartilhamento de código multiplataforma. Para saber
mais, veja Aprimoramentos do C++ para Linux para compartilhamento de código entre plataformas e
visualização de tipo.
A carga de trabalho do Linux adicionou suporte para rsync como uma alternativa ao SFTP para sincronizar
arquivos com computadores Linux remotos.
Foi adicionado suporte compilação cruzada direcionada a microcontroladores ARM. Para habilitar isso na
instalação, escolha a carga de trabalho Desenvolvimento para Linux com C++ e selecione a opção para
Desenvolvimento Incorporado e de IoT . Essa opção adiciona as ferramentas de compilação cruzada do
ARM GCC e Make à sua instalação. Para obter mais informações, consulte Compilação cruzada do ARM GCC
no Visual Studio.
Foi adicionado o suporte a CMake. Agora, você pode trabalhar em sua base de código existente do CMake
sem precisar convertê-la em um projeto do Visual Studio. Para obter mais informações, consulte Configurar
um projeto do Linux CMake.
Foi adicionado suporte à execução de tarefas remotas. essa funcionalidade permite executar qualquer
comando em um sistema remoto definido no gerenciador de conexões do Visual Studio. As tarefas remotas
também fornecem a capacidade de copiar arquivos para o sistema remoto. Para obter mais informações,
consulte Configurar um projeto do Linux CMake.
Várias melhorias para cenários de carga de trabalho do Linux. Para obter mais informações, veja Melhorias
na carga de trabalho do Linux C++ para o Sistema de Projeto, para a Janela de Console do Linux, para rsync
e para Anexar ao Processo.
IntelliSense para cabeçalhos em conexões remotas do Linux. Para obter mais informações, veja IntelliSense
para cabeçalhos remotos do Linux e Configurar um projeto CMake do Linux.
Desenvolvimento de jogos com C++

Use todo o poder do C++ para compilar jogos profissionais com DirectX ou Cocos2d.
Desenvolvimento móvel com C++ para Android e iOS

Agora, você pode criar e depurar aplicativos móveis usando o Visual Studio, que pode ser destinado ao Android
e iOS.
Aplicativos universais do Windows

O C++ é fornecido como um componente opcional para a carga de trabalho do Aplicativo Universal do
Windows. No momento, você deve atualizar os projetos C++ manualmente. você pode abrir um projeto de
Plataforma Universal do Windows direcionado ao v140 no Visual Studio 2017. no entanto, você precisa
selecionar o conjunto de ferramentas da plataforma v141 nas páginas de propriedades do projeto se não tiver o
Visual Studio 2015 instalado.
Novas opções para C++ na UWP (Plataforma Universal do Windows)

agora você tem novas opções para escrever e empacotar aplicativos C++ para o Plataforma Universal do
Windows e a Windows Store: a infraestrutura de Ponte de Desktop permite empacotar seu aplicativo de área de
trabalho existente ou objeto COM para implantação por meio do armazenamento Windows. Ou, para
implantação por meio de seus canais existentes por meio de carregamento colateral. Novos recursos no
Windows 10 permitem que você adicione a funcionalidade UWP para seu aplicativo de área de trabalho de
várias maneiras. Para saber mais, veja Ponte de Desktop.
Foi adicionado um modelo de projeto do Projeto de Empacotamento de Aplicativo do Windows , que

simplifica muito o empacotamento de aplicativos de área de trabalho usando a Ponte de Desktop. Ele está
disponível em Arquivo | Novo | Projeto | Instalado | Visual C++ | Plataforma Universal do Windows .
Para saber mais, veja Empacotar um aplicativo usando o Visual Studio (Ponte de Desktop).
Ao escrever código novo, você pode usar a C++/WinRT, uma projeção de linguagem C++ padrão para o
Windows Runtime implementada exclusivamente em arquivos de cabeçalho. ele permite consumir e criar
Windows Runtime APIs usando qualquer compilador C++ compatível com padrões. A C++/WinRT foi
concebida para oferecer aos desenvolvedores em C++ um acesso de primeira classe à moderna API do
Windows. Para obter mais informações, consulte C++/WinRT.
a partir do build 17025 do SDK do Windows insider Preview, o C++/WinRT está incluído na SDK do Windows.
Para obter mais informações, consulte C++/WinRT agora está incluído no SDK do Windows.
O conjunto de ferramentas da plataforma Clang/C2

o conjunto de ferramentas Clang/C2 fornecido com o Visual Studio 2017 agora dá suporte ao /bigobj
comutador, que é crucial para a criação de projetos grandes. Ele também inclui várias correções de bug
importantes, tanto no front-end do compilador quanto no back-end.
Análise de código C++

Os verificadores principais do C++ para impor as principais diretrizes do C++ agora são distribuídas com o
Visual Studio. Habilita os verificadores na Code Analysis extensões nas páginas de propriedades do projeto.
As extensões são incluídas quando você executar a análise de código. Para saber mais, veja Uso dos
verificadores de diretrizes de núcleo do C++.
Adicionada compatibilidade com regras relacionadas ao gerenciamento de recursos.

Novas Diretrizes Principais do C++ verificações abrangem a correção do ponteiro inteligente, o uso
correto de inicializadores globais e a sinalização de usos de constructos como goto e de casts ruins.
Alguns números de aviso que podem ser encontrados na 15.3 não estão mais disponíveis no 15.5. Esses
avisos foram substituídos por verificações mais específicas.
Suporte adicionado para análise de arquivo único e melhorias no desempenho de tempo de execução de
análise. Para obter mais informações, veja Melhorias de análise estática do C++ para Visual Studio 2017 15.6
versão prévia 2
Suporte adicionado para /analyze:ruleset , que permite especificar as regras de análise de código a
executar.
Suporte adicionado para regras de Diretrizes Principais do C++ adicionais. Para saber mais, veja Uso dos
verificadores de diretrizes de núcleo do C++.
Teste de unidade no Visual Studio 2017

Google Test Adaptador e Adaptador Boost.Test agora estão disponíveis como componentes da carga de trabalho
Desenvolvimento para Área de Trabalho com C++. Eles são integrados ao Test Explorer. O suporte a CTest é
adicionado para projetos do CMake (usando Abrir Pasta), embora a integração completa com o Explorador de
Testes ainda não está disponível. Para obter mais informações, consulte Escrevendo testes de unidade para
C/C++.
Suporte adicionado para suporte Boost.Test à biblioteca dinâmica.

Um Boost.Test modelo de item agora está disponível no IDE.
Para obter mais informações, consulte Boost.Test Teste de unidade: suporte à Biblioteca Dinâmica e Novo
Modelo de Item.
Suporte de CodeLens adicionado para projetos de teste de unidade do C++. Para obter mais informações, veja
Apresentação do CodeLens para teste de unidade do C++.
Diagnóstico de gráficos do Visual Studio

Visual Studio Diagnóstico de Gráficos: você pode usá-las para registrar e analisar problemas de renderização e
desempenho em aplicativos Direct3D. Use-os em aplicativos executados localmente em seu computador
Windows, em um emulador Windows dispositivo ou em um computador remoto ou dispositivo.
Entrada & saída para sombreadores de vér tice e geometria: A capacidade de exibir a entrada e a
saída de sombreadores de vértice e sombreadores de geometria foi um dos recursos mais solicitados.
Agora há suporte para ele nas ferramentas. Selecione o estágio VS ou GS na exibição Estágios do Pipeline
para começar a inspecionar sua entrada e saída na tabela abaixo.
Pesquisa e filtro na tabela de objetos: fornece uma maneira rápida e fácil de localizar os recursos
que você está procurando.
Histórico de Recursos: esse novo modo de exibição fornece uma maneira simplificada de ver todo o
histórico de modificações de um recurso, enquanto ele foi usado durante a renderização de um quadro
capturado. Para invocar o histórico de qualquer recurso, clique no ícone de relógio ao lado de qualquer
hiperlink de recurso.
Ele exibe a nova janela da ferramenta Histórico de Recursos, preenchida com o histórico de alterações
do recurso.
Você pode capturar quadros com a captura de pilha de chamada completa habilitada. Isso permite
deduzir rapidamente o contexto de cada evento de alteração e inspecioná-lo em seu Visual Studio
projeto. De definir a opção de captura de pilha completa na caixa Visual Studio ferramentas > opções
em Diagnóstico de Gráficos .
Estatísticas de API: exibir um resumo de alto nível do uso da API em seu quadro. É útil para descobrir
chamadas que você pode não perceber que está fazendo ou chamadas que está fazendo com muita
frequência. Essa janela está disponível por meio de Exibir > estatísticas de API no Visual Studio
Graphics Analyzer.
Estatísticas de memória: Exibir a memória alocada pelo driver para os recursos que você cria no
quadro. Essa janela está disponível por meio de Exibir > estatísticas de memória no Visual Studio
Graphics Analyzer . Para copiar dados para um arquivo CSV para exibição em uma planilha, clique com
o botão direito do mouse e escolha Copiar Tudo.
Validação de Quadro: a nova lista de erros e avisos fornece uma maneira fácil de navegar em sua lista
de eventos com base em problemas potenciais detectados pela camada de depuração Direct3D. Clique
em Exibir > Validação de Quadro Visual Studio Graphics Analyzer para abrir a janela. Em seguida,
clique em Executar Validação para iniciar a análise. Pode levar vários minutos para a análise ser
concluída, dependendo da complexidade do quadro.
Análise de quadro para D3D12: Use a Análise de Quadro para analisar o desempenho de chamada de
desenho com experimentos direcionados de "what-if". Mudar para a guia de Análise de Quadros e
executar uma análise para exibir o relatório. Para obter mais detalhes, assista ao vídeo GoingNative 25:
Análise de Quadros de Gráficos do Visual Studio.
Melhorias de uso de GPU: Os rastreamentos abertos podem ser feitos por meio do Visual Studio de
uso de GPU com a Exibição de GPU ou a ferramenta WPA (Windows Performance Analyzer) para análise
mais detalhada. Se você tiver o Windows performance Toolkit instalado, haverá dois hiperlinks: um para
WPA e outro para Exibição de GPU, na parte inferior direita da visão geral da sessão.
Os rastreamentos abertos na Exibição de GPU por meio deste link são suportados pelo zoom e pelo
panorâmico sincronizado do VS e da Exibição de GPU. Uma caixa de seleção no VS controla se a
sincronização está habilitada ou não.
Microsoft C++ docs: novidades para junho de 2021
Este artigo lista as principais alterações nos documentos do Microsoft C++ até junho de 2021.
Consulte o histórico de novidades para obter informações sobre as novidades nos meses anteriores.
veja o que há de novo para o C++ no Visual Studio para obter informações sobre as novidades do Visual
Studio.
consulte melhorias de conformidade do c++ em Visual Studio para obter o status de conformidade C e C++
mais recente.
Insights de build
Novos ar tigos
Classe HeaderUnit
Classe de módulo
Classe PrecompiledHeader
TRANSLATION_UNIT_TYPE enum
TRANSLATION_UNIT_TYPE_DATA enum
Classe TranslationUnitType
Ar tigos atualizados
SDK do build Insights do c++: tabela de eventos – adicionar novos eventos de compilação do C++ Insights
introdução ao c++ build Insights -adicionar novos eventos de compilação do c++ Insights
Linguagem C
_Static_assert palavra-chave e static_assert macro (C11) – atualizar o SDK para usar
Alinhamento (C11) – atualize o SDK para usar
Seleção genérica (C11) – atualizar o SDK para usar
Biblioteca de runtime C
Além das alterações abaixo, muitos artigos foram atualizados para evitar a tradução automática de elementos
de código.
_cprintf_p, _cprintf_p_l, _cwprintf_p, _cwprintf_p_l - printf() alteração de comportamento de
arredondamento
_cprintf_s, _cprintf_s_l, _cwprintf_s, _cwprintf_s_l - printf() alteração de comportamento de
arredondamento
_cprintf, _cprintf_l, _cwprintf, _cwprintf_l - printf()alteração de comportamento de arredondamento
_fprintf_p, _fprintf_p_l, _fwprintf_p, _fwprintf_p_l - printf() alteração de comportamento de
arredondamento
_get_printf_count_output - printf() alteração de comportamento de arredondamento
_printf_p, _printf_p_l, _wprintf_p, _wprintf_p_l - printf() alteração de comportamento de
arredondamento
_scprintf_p, _scprintf_p_l, _scwprintf_p, _scwprintf_p_l - printf() alteração de comportamento de
arredondamento
_scprintf, _scprintf_l, _scwprintf, _scwprintf_l - printf() alteração de comportamento de
arredondamento
_vcprintf_p, _vcprintf_p_l, _vcwprintf_p, _vcwprintf_p_l - printf() alteração de comportamento de
arredondamento
_vcprintf_s, _vcprintf_s_l, _vcwprintf_s, _vcwprintf_s_l - printf() alteração de comportamento de
arredondamento
_vscprintf, _vscprintf_l, _vscwprintf, _vscwprintf_l - printf() alteração de comportamento de
arredondamento
_vsprintf_p, _vsprintf_p_l, _vswprintf_p, _vswprintf_p_l - printf() alteração de comportamento de
arredondamento
_snprintf_s , _snprintf_s_l , _snwprintf_s , _snwprintf_s_l - printf() alteração de comportamento de
arredondamento
errno constantes -melhorar a legibilidade
fprintf , _fprintf_l , fwprintf , _fwprintf_l - printf() alteração de comportamento de
arredondamento
freopen_s , _wfreopen_s -novos sinalizadores de C11
freopen , _wfreopen -sinalizadores de C11 adicionados
,-observação alterar para a partir do vs 2015 atualização 1 pow powf powl pow(T,int)
printf_s , _printf_s_l , wprintf_s , _wprintf_s_l - printf() alteração de comportamento de
arredondamento
setlocale , _wsetlocale -modo de cadeia de caracteres UTF-8 esclarecido
sprintf , _sprintf_l , swprintf , _swprintf_l , __swprintf_l alteração de comportamento de - printf()
arredondamento
cprintf - printf() alteração de comportamento de arredondamento
fprintf_s, _fprintf_s_l, fwprintf_s, _fwprintf_s_l - printf() alteração de comportamento de
arredondamento
sprintf_s, _sprintf_s_l, swprintf_s, _swprintf_s_l - printf() alteração de comportamento de
arredondamento
strcpy_s, wcscpy_s, _mbscpy_s, _mbscpy_s_l -exemplos de código fixo
strncat_s, _strncat_s_l, wcsncat_s, _wcsncat_s_l, _mbsncat_s, _mbsncat_s_l - printf() alteração de
comportamento de arredondamento
Tipo-matemática genérica -atualização da versão do SDK a ser usada
vprintf, _vprintf_l, vwprintf, _vwprintf_l - printf() alteração de comportamento de arredondamento
vsprintf_s, _vsprintf_s_l, vswprintf_s, _vswprintf_s_l - printf() alteração de comportamento de
arredondamento

_variant_t::operator= -adicionar comentários para operator= e tornar o artigo mais fácil de ler.
Classes abstratas (C++) -adicionar informações de extensão específicas da Microsoft para o Destruidor
virtual puro embutido
Atributos em C++ -adicione erros e avisos ausentes: C7000-C7999, C4834
Char, wchar_t, char8_t, char16_t, char32_t -esclarece se Char está assinado ou não
Guia de atualização e portabilidade do C++

introdução ao Microsoft C++ para UNIX usuários -Visual Studio atualizações 16,10 para conformidade com
o C17
Visual C++ o que's New 2003 a 2015 -Observe a mudança para pow(T,int) iniciar no vs 2015 atualização 1
Erros e avisos de ferramentas e compiladores do C/C++

Novos ar tigos
Erro de linha de comando D8048
Erro do compilador C7510
Erro do compilador C7536
Erros de compilador C7000 por meio de C7499
Erros de compilador C7500 por meio de C7999
Aviso do compilador (erro) C4597
Aviso do compilador (nível 1) C4834
Aviso do compilador C5037
Erro fatal C1090
Erro do compilador C2139 -adicionou alguns diagnósticos da versão 2017
Erro do compilador C2276 -Update C2276
Erro do compilador C2855 -adicionar comentários sobre como resolver esse erro
Erros do compilador C2000-C3999, C7000-C7999 -adicionar erros e avisos ausentes: C7000-C7999, C4834
Erros do compilador C7500 por meio de C7999 -adicionou alguns diagnósticos da versão 2017; Adicionar
erro C7510; adicionar erros e avisos ausentes: C7000-C7999, C4834
Aviso do compilador (nível 1) C4179 -adicionou alguns diagnósticos da versão 2017
Aviso do compilador (nível 1) C5208 e erro C7626 -adicionar erros e avisos ausentes: C7000-C7999, C4834
Aviso do compilador (nível 4) C4189 -adicionou alguns diagnósticos da versão 2017
Aviso do compilador C5038 -adicionou alguns diagnósticos da versão 2017
avisos do compilador por versão do compilador -atualização Visual Studio 16,10 melhorias de conformidade
e novos avisos; Adicionar novos avisos 16,10, informações de versão; atualizar cadeias de caracteres de
versão para Visual Studio 16,8, 16,9 e 16,10
avisos do compilador C4400 por meio de C4599 -adicionou alguns Visual Studio diagnósticos da versão
2017
avisos do compilador C4800 por meio de C5999 -update Visual Studio melhorias de conformidade do 16,10
e novos avisos; Adicionar novos avisos 16,10, informações de versão; foram adicionados alguns diagnósticos
da versão 2017; adicionar erros e avisos ausentes: C7000-C7999, C4834
Mensagens vetorizador automático e paralelizador automático -adicionar motivo de falha de vetorizador
automático 505; Adicionar o código de motivo 1204
Linguagem de assembly e intrínsecores do compilador C/C++

Microsoft Macro Assembler BNF gramática – formatação de limpeza e problemas de tradução automática
visão geral do C/C++ no Visual Studio

Novos ar tigos
melhorias de conformidade do C++, alterações de comportamento e correções de bugs no Visual Studio
2017
Microsoft C++ docs: o que há de novo para o Visual Studio 16,8
2017 -adicionado diagnóstico de versão 2017
2019 -Visual Studio atualizações 16,10 para C17 conformidade; atualizar melhorias de conformidade 16,10 e
novos avisos; Adicionar erro C7510; adicionar erros e avisos ausentes: C7000-C7999, C4834; atualizar
documentos de conformidade para 16,9
C++ em atualizações de Visual Studio Visual Studio 16,10 para conformidade com o C17
instalar o suporte a C11 e C17 nas atualizações do Visual Studio Visual Studio 16,10 para a conformidade do
C17
conformidade da linguagem C/C++ da Microsoft por Visual Studio versão -Visual Studio 16,10 atualizações
para conformidade com o C17; atualizar tabela de conformidade para Visual Studio 16,10 e Visual Studio
16,9
Microsoft C++ docs: o que há de novo para Visual Studio 16,8 -Visual Studio atualizações 16,10 para
conformidade com o C17
o que há de novo para C++ em Visual Studio 2017 -Visual Studio 16,10 atualizações para C17 conformidade;
atualizar documentos de conformidade de versão do Visual Studio 16,9

avisos do compilador que estão desativados por padrão -atualização Visual Studio melhorias de
conformidade 16,10 e novos avisos; foram adicionados alguns diagnósticos da versão 2017
macros predefinidas -adicionar novos avisos Visual Studio 16,10, informações de versão; atualizar cadeias de
caracteres de versão para Visual Studio 16,8, 16,9 e 16,10
Projetos C/C++ e sistemas de compilação

Novos ar tigos
/external (Diagnóstico de cabeçalhos externos)
/headerName (Criar uma unidade de cabeçalho a partir do cabeçalho especificado)
/sourceDependencies:directives (Listar dependências de unidade de cabeçalho e de módulo)
CMakePresets.json e CMakeUserPresets.json mapas de fornecedores da Microsoft
Configurar e compilar com predefinições de CMake no Visual Studio
Classe HeaderUnit
Classe de módulo
Classe PrecompiledHeader
TRANSLATION_UNIT_TYPE enum
TRANSLATION_UNIT_TYPE_DATA enum
Classe TranslationUnitType
Walkthrough: criar e importar unidades de cabeçalho no Microsoft Visual C++
Walkthrough: importar bibliotecas STL como unidades de cabeçalho
/experimental: módulo (habilitar suporte a módulo) -novo conteúdo para unidades de cabeçalho
/Qspectre -atualização do vs 2019
/Y (cabeçalhos pré-compilados) -novo conteúdo para unidades de cabeçalho
/analyze (Análise de código) – atualizar com a lista de opções atualizadas, adicionar mais informações e
reestruturar para uma melhor organização das opções relacionadas
/await (habilitar suporte de corotina) -adicionar /await:strict para Visual Studio 16,10
/clr (Compilação do Common Language Runtime) – incluir a versão para o suporte da /clr:netcore
opção
/exportHeader (Criar unidades de cabeçalho) -adicionar novo conteúdo relacionado a unidades de cabeçalho
/external (Diagnóstico de cabeçalhos externos) - /external não experimental no Visual Studio 16,10
/F (Definir tamanho da pilha) -atualização para vs 2019
/FC (Caminho completo do arquivo de código-fonte no diagnóstico) – classificar comportamento por
versão.
/GL (Otimização do programa inteiro) – corrigir problema de Loc no/GL docs
/headerUnit (Usar unidade de cabeçalho IFC) -novo conteúdo para unidades de cabeçalho
/INTEGRITYCHECK (Exigir verificação de assinatura) -diretrizes de assinatura atualizadas para integritycheck
binários
/openmp (Habilitar suporte de OpenMP) -adicionar/OpenMP: documentos do comutador LLVM do
compilador
/reference (Usar módulo de nome IFC) -novo conteúdo para unidades de cabeçalho
/sourceDependencies (Listar todas as dependências de nível de origem) -novo conteúdo para unidades de
cabeçalho
/std (especificar versão padrão do idioma) -Visual Studio atualizações 16,10 para conformidade com o C17
/translateInclude (Converter incluir diretivas em diretivas de importação) -novo conteúdo para unidades
de cabeçalho
página de propriedades avançada – adicione Windows propriedade compatível com a área de trabalho para
Visual Studio 16,10; adicionar opção de versão do conjunto de ferramentas LLVM para Visual Studio 16,9
Manipulação de exceção do ARM – corrigir ComputeXdataSize amostras para ARM/ARM64
Tratamento de exceção ARM64 – corrigir ComputeXdataSize amostras para ARM/ARM64
SDK do build Insights do c++: tabela de eventos -adicionar novos eventos de compilação do c++ Insights à
documentação
suporte a Clang/LLVM em projetos de Visual Studio – adicione a opção de versão do LLVM toolset para
Visual Studio 16,9; atualizar clang-support-msbuild.md
projetos CMake no Visual Studio -adicionar detalhes avançados sobre como usar o CMake de arquivo-api
Opções de compilador listadas em ordem alfabética – novo conteúdo para unidades de cabeçalho
Opções de compilador listadas por categoria – novo conteúdo para unidades de cabeçalho
configurar e compilar com predefinições de CMake no Visual Studio -melhorar a legibilidade
página de propriedades geral (Project) – adicione Windows propriedade compatível com a área de trabalho
para Visual Studio 16,10
introdução ao c++ build Insights -adicionar novos eventos de compilação de c++ Insights à documentação
Como modificar a estrutura de destino e o conjunto de ferramentas de plataforma -melhorar a legibilidade
abrir o suporte de pasta para sistemas de compilação C++ em Visual Studio -fix CppProperties.jsno
conteúdo de MinGW-w64
Suporte a Unicode no compilador e vinculador – adicione informações sobre como salvar usando uma
codificação diferente
Usar o conjunto de ferramentas do Microsoft C++ da linha de comando – atualizado para vs 2019
Walkthrough: compilar um programa C na linha de comando -Visual Studio 16,10 atualizações para
conformidade com o C17
Walkthrough: Compilando um programa C++ nativo no comportamento da linha de comando -
esclarecimento do bloco de notas ao abrir o arquivo de origem
Referência da STL (biblioteca padrão do C++)

Novos ar tigos
<ranges>
day classe
month_day_last classe
month_day classe
month_weekday_last classe
month_weekday classe
year_month classe
bitset classe -melhor legibilidade
digitação de ortografia de vector classe no código de exemplo
Qualidade do código
Novos ar tigos
C6389: MARK_INTERNAL_OR_MISSING_COMMON_DECL
C6031 -adicionar observação sobre ignorar o valor de retorno de uma função
C26432 DEFINE_OR_DELETE_SPECIAL_OPS -exemplos de código de atualização
C26497 USE_CONSTEXPR_FOR_FUNCTION -adicionar observação sobre quando o aviso não será emitido
Linux com C++ no Visual Studio

Conexão ao seu sistema Linux de destino em Visual Studio -adicionar seção sobre a verificação de chave de
host
referência de ConnectionManager -adicione observação sobre os sinalizadores de impressão digital da chave
de host adicionados no Visual Studio 16,10.
Visão geral de programação do Windows no C++
determinando quais DLLs redistribuídas -atualizadas para Visual Studio 2019
Programação paralela em C++ no Visual Studio

C++ AMP visão geral -adicionar observação sobre a substituição da biblioteca de C++ AMP
Walkthrough: depurando um aplicativo C++ AMP de exemplo de código fixo
Colaboradores da Comunidade
As pessoas a seguir contribuíram para os documentos C++, C e Assembler durante esse período. Obrigado!
Consulte visão geral do guia do colaborador do Microsoft docs se você gostaria de aprender como contribuir.
0xbadfca11 (1)
bclehmann -Benjamin Lehmann (1)
Brian-Taylor8 (1)
cartwrightluke (2)
ccawley2011 -Cameron Cawley (1)
EddieBreeveld -Edward Breeveld (1)
FrankAtHexagon -Frank Edwards (1)
fsb4000 -Igor Zhukov (1)
Jaiganeshkumaran -Jaiganesh Kumaran (2)
jayvient -Jayvien (1)
KishkinJ10 (1)
kokosxD -Kokos (1)
langemol -Jacco mol (1)
MUzairS15 (1)
nadavsu -Nadav (1)
NegiAkash890 -Akash Negi (1)
pjessesco -Jino Park (1)
pramodkirchki (1)
Radfordhound -Graham Scott (1)
sapant-MSFT (1)
sebgod -Sebastián Godelet (1)
seedkar1 (1)
ShamanCoder (1)
Sheila-Stewart (1)
softmac (1)
Thieum -Matthieu penant (2)
tjs137 (1)
urmyfaith -ZX (1)
ValZapod -Valerii Zapodovnikov (1)
westinn -Nicolas Westin (1)
Histórico de novidades
a seção a seguir fornece os meses anteriores de novidades no Visual Studio docs.
Fevereiro de 2021
Linguagem C
Novos ar tigos
_Noreturn palavra-chave e noreturn macro (C11)
_Static_assert palavra-chave e static_assert macro (C11)
Operadores de atribuição C -atualização de gramática lexical para C17
Declarações de enumeração C – gramática léxica fixa
Palavras-chave C -atualização de gramática lexical para C17
C gramática lexical -atualização lexical de gramática para C17
Analisando argumentos c Command-Line -exceções de documento para as regras de análise de argumentos
c
Resumo de instruções C – atualizado para __leave , __try palavras-chave
Resumo de declarações -atualização lexical de gramática para C17
Resumo de expressões -atualização de gramática lexical para C17
Qualificadores de tipo -adicionados restrict
Novos ar tigos
Matemática do tipo genérico
_cwait -exemplo de código fixo
assert Macro, _assert, _wassert -Comportamento de declaração de esclarecimento
qsort -foi adicionada uma observação sobre a estabilidade
realloc -notas de conformidade do C99 adicionadas
round, roundf, roundl -Exemplo de código de arredondamento esclarecido
setlocale, _wsetlocale -informações de suporte do C Runtime UTF-8 adicionadas
vsnprintf_s, _vsnprintf_s, _vsnprintf_s_l, _vsnwprintf_s, _vsnwprintf_s_l -Valores de retorno esclarecidos
Compatibilidade -notas de conformidade do C99 adicionadas
Recursos da biblioteca CRT -C99 de notas de conformidade adicionadas
Visão geral da família de funções – operador adicionado new e delete
visão geral do novo pré-processador de MSVC -conteúdo do pré-processador atualizado
macros predefinidas – atualizadas para Visual Studio notas de versão 16,8, suporte a C11/C17 /std e
documentos de instalação do SDK
Qualidade do código
Novos ar tigos
C33001 -VC Code Analysis-adicionar para novas regras no Visual Studio 16,8
C6262 -address cpp-docs. zh-Taiwan problema 20
C26401 DONT_DELETE_NON_OWNER -foram adicionados um link de exemplo e diretrizes principais para C26401
C26402DONT_HEAP_ALLOCATE_MOVABLE_RESULT -exemplo adicionado para C26402
C26408 NO_MALLOC_FREE -foram adicionados um link de exemplo e diretrizes principais para C26408
C26409 NO_NEW_DELETE -exemplo adicionado para C26409
C26432 DEFINE_OR_DELETE_SPECIAL_OPS -exemplo adicionado para C26432
C26434 DONT_HIDE_METHODS -exemplo adicionado para C26434
C26436 NEED_VIRTUAL_DTOR -foram adicionados um link de exemplo e diretrizes principais para C26436
C26439 SPECIAL_NOEXCEPT -adição de exemplo e link para as diretrizes principais para C26439
C26440 DECLARE_NOEXCEPT -adição de exemplo e link para as diretrizes principais para C26440
C26446 USE_GSL_AT -foi adicionado um exemplo para C26446
C26447 DONT_THROW_IN_NOEXCEPT -adicionando exemplo a C26447
C26460 USE_CONST_REFERENCE_ARGUMENTS -adição de descrição e exemplo para C26460
C26461 USE_CONST_POINTER_ARGUMENTS: -adição de descrição e exemplo para C26461
C26462 USE_CONST_POINTER_FOR_VARIABLE -adição de descrição e exemplo para C26462
C26465 NO_CONST_CAST_UNNECESSARY -adicionado o exemplo a C26465
C26466 NO_STATIC_DOWNCAST_POLYMORPHIC -adicionado o exemplo a C26466
C26471 NO_REINTERPRET_CAST_FROM_VOID_PTR -adicionado o exemplo a C26471
C26474 NO_IMPLICIT_CAST -atualizado para esclarecer casos de base/derivados
C26482 NO_DYNAMIC_ARRAY_INDEXING -adicionado o exemplo a C26482
C26483 STATIC_INDEX_OUT_OF_RANGE -adicionado o exemplo a C26483
C26490 NO_REINTERPRET_CAST -adicionado o exemplo a C26490
C26492 NO_CONST_CAST -adicionado o exemplo a C26492
C26493 NO_CSTYLE_CAST -adicionado o exemplo a C26493
C26494 VAR_USE_BEFORE_INIT – exemplo adicionado a C26494
C26495 MEMBER_UNINIT – exemplos e links atualizados no C26495
C26496 USE_CONST_FOR_VARIABLE – exemplo adicionado a C26496
C26497 USE_CONSTEXPR_FOR_FUNCTION – exemplo adicionado a C26497
Linux com Microsoft C++ em Visual Studio

Novos ar tigos
Configurar um projeto do Linux CMake no Visual Studio
Configurar um projeto CMake do Linux no Visual Studio – atualizado para refletir a interface do usuário mais
recente
Referência de ConnectionManager – comandos adicionados para modificar, limpar
Criar um projeto do Linux MSBuild C++ em Visual Studio instruções atualizadas para criar um projeto do
Linux
Implantar, executar e depurar seu projeto de MSBuild Linux – adicionado GDB Path
Erros e avisos do compilador C/C++ e das ferramentas
Novos ar tigos
Aviso do compilador (nível 4) C4388 – adicionado aviso C4388, Visual Studio avisos 16.7
Erro do compilador C3381 – endereço cpp-docs 2493; atualizar comentários e exemplo
Aviso do compilador (nível 3) C4018 – avisos Visual Studio 16.7 atualizados
Aviso do compilador (nível 4) C4389 – avisos Visual Studio 16.7 atualizados
Avisos do compilador por versão do compilador – atualização Visual Studio avisos da versão 16.7
Avisos do compilador C4800 a C5999 – avisos Visual Studio 16.7 atualizados
Intrínsecos do compilador C/C++ e linguagem de assembly
Melhorias de conformidade do C++ no Visual Studio – atualizadas para Visual Studio de versão 16.8
C++ em Visual Studio - atualização do DevCom e Microsoft Docs links de&A
Ajuda e comunidade do Microsoft C/C++ – atualização do DevCom e Microsoft Docs de&A
Conformidade com a linguagem C/C++ da Microsoft – tabela de conformidade da biblioteca C++20
atualizada, tabela de recursos de linguagem de atualização Visual Studio 16.7
__restrict
union – snippet de código fixo
Instrução if-else (C++) – adicionada descrição para if/else gramática
Projetos e sistemas de build do C/C++
Novos ar tigos
.vcxproj arquivos e curingas
/headerUnit (Usar a unidade de header IFC)
/module:exportHeader (Criar unidades de header)
/module:reference (Usar o módulo nomeado IFC)
/translateInclude (Converter diretivas de inclusão em diretivas de importação)
/Zc:preprocessor (Habilitar o modo de conformidade do pré-processador)
/clr (Compilação do Common Language Runtime) – adicionada descrição para /clr
/permissive- (Conformidade com padrões) – atualizado para Visual Studio notas de versão 16.8
Importando dados __declspec(dllimport) usando – exemplo atualizado
pgosweep – adicionadas mais opções pgosweep
Guia de porta e atualização do C++
Como usar código C++ existente em um aplicativo da Plataforma universal Windows – retrabalho para
maior clareza e exemplos atualizados
Referência da STL (Biblioteca Padrão) do C++
Novos ar tigos
<bit>
<bit> Funções
endian Enum
<bit> functions – sintaxe nodiscard atualizada
<ios> typedefs – exemplo atualizado
basic_string_view Classe – starts_with() adicionada, ends_with()
basic_string Classe – _starts_with() adicionada, ends_with()
ios_base Class
map classe
multimap Classe – adicionada contains()
multiset Classe – adicionada contains()
set Classe – adicionada contains()
unordered_map Classe – adicionada contains()
unordered_multimap Classe – adicionada contains()
unordered_multiset Classe – adicionada contains()
unordered_set Classe – adicionada contains()
Colaboradores da Comunidade
As pessoas a seguir contribuíram para os documentos C++, C e Assembler durante esse período. Obrigado!
Confira Microsoft Docs visão geral do guia do colaborador se você quiser saber como contribuir.
EdFish - Da ltda B. (1)
codevenkat (1)
definedrisk – Ben (3)
eltociear – Ikko Ashimine (1)
fsb4000 – Igor Korkov (1)
Jaesheshkumaran – Jaeshesh Ltdan (1)
jogo- (1)
justanotheranonymoususer (1)
matrohin - Dmitry Matrokhin (1)
mhemmit (1)
MSDN-WhiteK operação – MSDN. WhiteK ltda (1)
FranciscoTemple – Temple DeIa (1)
r00tdr4g0n – r00tdr4g0n (1)
sebkraemer – Krümer (1)
vtjnash – Jameson Ltda (1)
yecril71pl – Ye yenecton
Youssef1313 – Youssef Paulo (1)
zecozephyr – Allan Ltda (1)
Melhorias de conformidade do C++, alterações de
comportamento e correções de bugs Visual Studio
2019
O Microsoft C/C++ no Visual Studio (MSVC) faz melhorias de conformidade e correções de bugs em cada
versão. Este artigo lista as melhorias por versão principal e depois pela versão. Para ir diretamente para as
alterações de uma versão específica, use a lista abaixo neste ar tigo .
Este documento lista as alterações no Visual Studio 2019. Para ver um guia sobre as alterações no Visual Studio
2017, confira Melhorias de conformidade do C++ no Visual Studio 2017. Para ver uma lista completa das
melhorias de conformidade anteriores, Visual C++ Novidades de 2003 a 2015.
Melhorias de conformidade Visual Studio RTW 2019 (versão 16.0)

Visual Studio RTW 2019 contém as seguintes melhorias de conformidade, correções de bugs e alterações de
comportamento no compilador do Microsoft C++.
NOTE
Os recursos do C++20 estão disponíveis no modo até que a implementação do C++20 seja concluída para o
/std:c++latest compilador e o IntelliSense. Nesse momento, apresentaremos o modo /std:c++20 do compilador.
Os módulos aprimorados dão suporte a modelos e à detecção de erros

Agora os módulos estão oficialmente no padrão C++20. O suporte aprimorado foi adicionado no Visual Studio
2017 versão 15.9. Para saber mais, confira Melhor detecção de erro e de suporte de modelo em Módulos do
C++ com o MSVC 2017 versão 15.9.
Especificação modificada de tipo de agregação
A especificação de um tipo de agregação foi alterada no C++20 (confira Proibir agregações com construtores
declarados pelo usuário). No Visual Studio 2019, em , uma classe com qualquer construtor declarado pelo
usuário (por exemplo, incluindo um construtor declarado ou ) não /std:c++latest = default é uma = delete
agregação. Anteriormente, somente os construtores fornecidos pelo usuário desqualificariam uma classe de
uma agregação. Essa alteração coloca mais restrições sobre como esses tipos podem ser inicializados.
O código a seguir é compilado sem erros no Visual Studio 2017, mas gera erros C2280 e C2440 no Visual
Studio 2019 em /std:c++latest :
struct A
{
A() = delete; // user-declared ctor
};
struct B
{
B() = default; // user-declared ctor
int i = 0;
};
A a{}; // ill-formed in C++20, previously well-formed

B b = { 1 }; // ill-formed in C++20, previously well-formed
Suporte parcial para operator <=>
P0515R3 O C++20 apresenta o operador de comparação de três vias <=> , também conhecido como o
"operador espaçonave". Visual Studio 2019 no modo introduz suporte parcial para o operador, ingando erros de
sintaxe que agora não /std:c++latest é permitido. Por exemplo, o código a seguir é compilado sem erros no
Visual Studio 2017, mas gera vários erros no Visual Studio 2019 em /std:c++latest :
struct S
{
bool operator<=(const S&) const { return true; }
};
template <bool (S::*)(const S&) const>

struct U { };
int main(int argc, char** argv)

{
U<&S::operator<=> u; // In Visual Studio 2019 raises C2039, 2065, 2146.
}
Para evitar os erros, insira um espaço na linha incorreta antes do colchete angular final: U<&S::operator<= > u; .
Referências a tipos sem qualificadores CV incompatíveis
Anteriormente, o MSVC permitia associação direta de uma referência a partir de um tipo com qualificadores CV
incompatíveis abaixo do nível superior. Essa associação poderia permitir a modificação de dados const
supostamente mencionados pela referência. Agora, o compilador cria um temporário, conforme exigido pelo
padrão. No Visual Studio 2017, o código a seguir é compilado sem avisos. No Visual Studio 2019, o compilador
gera o aviso C4172:
struct X
{
const void* const& PData() const
{
return _pv;
}
void* _pv;
};
int main()
{
X x;
auto p = x.PData(); // C4172 <func:#1 "?PData@X@@QBEABQBXXZ"> returning address of local variable or
temporary
}
reinterpret_cast de uma função sobrecarregada
O argumento para não é um dos contextos em que o endereço de uma função sobrecarregada
reinterpret_cast é permitido. O código a seguir é compilado sem erros no Visual Studio 2017, mas, no Visual
Studio 2019, ele gera o erro C2440:
int f(int) { return 1; }

int f(float) { return .1f; }
using fp = int(*)(int);
int main()
{
fp r = reinterpret_cast<fp>(&f); // C2440: cannot convert from 'overloaded-function' to 'fp'
}
Para evitar o erro, use uma conversão permitida para esse cenário:
int f(int);
int f(float);
using fp = int(*)(int);
int main()
{
fp r = static_cast<fp>(&f); // or just &f;
}
Fechamentos lambda
No C++ 14, os tipos de fechamento lambda não são literais. A principal consequência dessa regra é que um
lambda não pode ser atribuído a uma constexpr variável. O código a seguir é compilado sem erros no Visual
Studio 2017, mas no Visual Studio 2019 ele gera o erro C2127:
int main()
{
constexpr auto l = [] {}; // C2127 'l': illegal initialization of 'constexpr' entity with a non-constant
expression
}
Para evitar o erro, remova o constexpr qualificador ou altere o modo de conformidade para /std:c++17 .
Códigos de falha de std::create_directory
P1164 implementado de C++20 incondicionalmente. Isso altera std::create_directory para verificar se o

destino já foi um diretório em caso de falha. Anteriormente, todos os erros do tipo ERROR_ALREADY_EXISTS
foram convertidos em códigos de êxito, mas não criados pelo diretório.
operator<<(std::ostream, nullptr_t)
Por LWG 2221, adicionado operator<<(std::ostream, nullptr_t) para a escrita em nullptr fluxos.
Mais algoritmos paralelos
Novas versões paralelas de is_sorted , is_sorted_until , is_partitioned , set_difference , set_intersection ,
is_heap e is_heap_until .
inicialização atômica
P0883 "Corrigindo a inicialização atômica" muda para inicializar o contido em vez de std::atomic T inicializá-
lo por padrão. A correção é habilitada ao usar o Clang/LLVM com a biblioteca padrão da Microsoft. Atualmente,
ele está desabilitado para o compilador do Microsoft C++, como uma solução alternativa para um bug
constexpr no processamento.
remove_cvref e remove_cvref_t
Implementação das características de tipo remove_cvref e remove_cvref_t de P0550. Elas removem a

capacidade de referência e a qualificação CV de um tipo sem funções e matrizes decrescentes para ponteiros
(diferentemente de std::decay e std::decay_t ).
Macros de teste de recurso
P0941R2 – macros de teste de recurso está concluído, com suporte para __has_cpp_attribute . Macros de teste
de recurso têm suporte em todos os modos padrão.
Proibir agregações com construtores declarados pelo usuário
C++20 P1008R1 – a proibição de agregações com construtores declarados pelo usuário foi concluída.
reinterpret_cast em uma constexpr função
Um reinterpret_cast é ilegal em uma constexpr função. O compilador do Microsoft C++ rejeitaria
reinterpret_cast anteriormente apenas se fosse usado em um constexpr contexto. No Visual Studio 2019, em
todos os modos de padrões de linguagem, o compilador diagnostica corretamente um na definição
reinterpret_cast de uma constexpr função. O código a seguir agora produz C3615:
long long i = 0;
constexpr void f() {
int* a = reinterpret_cast<int*>(i); // C3615: constexpr function 'f' cannot result in a constant
expression
}
Para evitar o erro, remova o constexpr modificador da declaração de função.

Diagnóstico correto para o construtor do intervalo basic_string
No Visual Studio 2019, o construtor de intervalo não suprime mais o basic_string diagnóstico do compilador
com static_cast . O código a seguir é compilado sem avisos Visual Studio 2017, apesar da possível perda de
dados de wchar_t para char ao inicializar out :
std::wstring ws = /* . . . */;
std::string out(ws.begin(), ws.end()); // VS2019 C4244: 'argument': conversion from 'wchar_t' to 'const
_Elem', possible loss of data.
Visual Studio 2019 gera corretamente o aviso C4244. Para evitar o aviso, você pode inicializar std::string o
conforme mostrado neste exemplo:
std::wstring ws = L"Hello world";

std::string out;
for (wchar_t ch : ws)
{
out.push_back(static_cast<char>(ch));
}
Chamadas += incorretas para -= e em ou agora são /clr /ZW detectadas corretamente

Um bug foi introduzido no Visual Studio 2017 que fez com que o compilador ignorassem silenciosamente os
erros e não gerassem nenhum código para as chamadas inválidas para e em += -= ou /clr /ZW . O
seguinte código é compilado sem erros no Visual Studio 2017, mas, no Visual Studio 2019, gera corretamente o
erro C2845:
public enum class E { e };
void f(System::String ^s)

{
s += E::e; // in VS2019 C2845: 'System::String ^': pointer arithmetic not allowed on this type.
}
Para evitar o erro neste exemplo, use o += operador com o método : ToString() s += E::e.ToString(); .
Inicializadores de membros de dados estáticos embutidos
Os acessos de membro inline inválidos dentro static constexpr dos inicializadores e agora são detectados
corretamente. O exemplo a seguir compila sem erro no Visual Studio 2017, mas no Visual Studio 2019 no modo
, ele gera o erro /std:c++17 C2248:
struct X
{
private:
static inline const int c = 1000;
};
struct Y : X
{
static inline int d = c; // VS2019 C2248: cannot access private member declared in class 'X'.
};
Para evitar o erro, declare o membro X::c como protegido:
struct X
{
protected:
static inline const int c = 1000;
};
C4800 restabelecido
MSVC costumava ter um aviso de desempenho C4800 sobre conversão implícita em bool . Ele era muito
barulhento e não pôde ser suprimido, levando-nos a removê-lo Visual Studio 2017. No entanto, durante o ciclo
de vida do Visual Studio 2017, recebemos muitos comentários sobre os casos úteis que ele estava resolvendo.
No Visual Studio 2019, estamos retornando um C4800 cuidadosamente ajustado com o C4165 explicativo.
Ambos os avisos são fáceis de suprimir: usando uma cast explícita ou por comparação com 0 do tipo
apropriado. C4800 é um aviso de nível 4 off-by-default e C4165 é um aviso de nível 3 off-by-default. Ambos
podem ser descobertos usando a opção /Wall do compilador .
O exemplo a seguir gera C4800 e C4165 em /Wall :
bool test(IUnknown* p)
{
bool valid = p; // warning C4800: Implicit conversion from 'IUnknown*' to bool. Possible information
loss
IDispatch* d = nullptr;
HRESULT hr = p->QueryInterface(__uuidof(IDispatch), reinterpret_cast<void**>(&d));
return hr; // warning C4165: 'HRESULT' is being converted to 'bool'; are you sure this is what you want?
}
Para evitar os avisos no exemplo anterior, é possível escrever o código da seguinte maneira:
bool test(IUnknown* p)
{
bool valid = p != nullptr; // OK
IDispatch* d = nullptr;
HRESULT hr = p->QueryInterface(__uuidof(IDispatch), reinterpret_cast<void**>(&d));
return SUCCEEDED(hr); // OK
}
A função de membro de classe local não tem um corpo

No Visual Studio 2017, o aviso C4822 é gerado somente quando a opção do /w14822 compilador é definida
explicitamente. Ele não é mostrado com /Wall . No Visual Studio 2019, o C4822 é um aviso off-by-default, que
o torna inabrável em sem precisar definir /Wall /w14822 explicitamente.
void example()
{
struct A
{
int boo(); // warning C4822: Local class member function doesn't have a body
};
}
Corpos de modelo de função que if constexpr contêm instruções

No Visual Studio 2019 em , os corpos de função de modelo que têm instruções têm verificações adicionais
/std:c++latest if constexpr relacionadas à análise habilitadas. Por exemplo, no Visual Studio 2017, o código a
seguir produzirá C7510 somente se /permissive- a opção estiver definida. No Visual Studio 2019, o mesmo
código gera erros mesmo quando a /permissive opção é definida:
// C7510.cpp
// compile using: cl /EHsc /W4 /permissive /std:c++latest C7510.cpp
#include <iostream>
template <typename T>

int f()
{
T::Type a; // error C7510: 'Type': use of dependent type name must be prefixed with 'typename'
// To fix the error, add the 'typename' keyword. Use this declaration instead:
// typename T::Type a;
if constexpr (a.val)
{
return 1;
}
else
{
return 2;
}
}
struct X
{
using Type = X;
constexpr static int val = 1;
};
int main()
{
std::cout << f<X>() << "\n";
}
Para evitar o erro, adicione a typename palavra-chave à declaração de a : typename T::Type a; .
Não há suporte ao código do assembly embutido em uma expressão lambda
A equipe do Microsoft C++ foi recentemente consciente de um problema de segurança no qual o uso de
Assembler embutido em um lambda poderia causar a corrupção de ebp (o registro do endereço de retorno)
em tempo de execução. Um invasor mal-intencionado possivelmente poderia tirar proveito desse cenário. O
Assembler embutido só tem suporte no x86, e a interação entre o Assembler embutido e o restante do
compilador é ruim. Considerando esses fatos e a natureza do problema, a solução mais segura para esse
problema foi não permitir o Assembler embutido dentro de uma expressão lambda.
O único uso do assembler embutido em uma expressão lambda que encontramos “em condições naturais” era
capturar o endereço de retorno. Nesse cenário, é possível capturar o endereço de retorno em todas as
plataformas usando simplesmente um _ReturnAddress() intrínseco do compilador.
o código a seguir produz C7552 no Visual Studio 2017 15,9 e no Visual Studio 2019:
#include <cstdio>
int f()
{
int y = 1724;
int x = 0xdeadbeef;
auto lambda = [&]

{
__asm { // C7552: inline assembler is not supported in a lambda
mov eax, x
mov y, eax
}
};
lambda();
return y;
}
Para evitar o erro, mova o código do assembly para uma função nomeada conforme mostrado no exemplo a
seguir:
#include <cstdio>
void g(int& x, int& y)

{
__asm {
mov eax, x
mov y, eax
}
}
int f()
{
int y = 1724;
int x = 0xdeadbeef;
auto lambda = [&]
{
g(x, y);
};
lambda();
return y;
}
int main()
{
std::printf("%d\n", f());
}
Depuração do iterador e std::move_iterator
O recurso de depuração do iterador foi ensinado a desencapsular adequadamente o std::move_iterator . Por

exemplo, agora
std::copy(std::move_iterator<std::vector<int>::iterator>, std::move_iterator<std::vector<int>::iterator>,
int*)
pode envolver o caminho memcpy rápido.
Correções para <xkeycheck.h> imposição de palavra-chave
A imposição da biblioteca padrão no <xkeycheck.h> para macros que substitui uma palavra-chave foi corrigida.
A biblioteca agora emite a palavra-chave do problema real detectada em vez de uma mensagem genérica. Ela
também dá suporte a palavras-chave do C++20 e evita enganar o IntelliSense dizendo que palavras-chave são
macros.
Tipos de alocador não mais preteridos
std::allocator<void> , std::allocator::size_type e std::allocator::difference_type não são mais preteridos.
Aviso correto para restringir conversões de cadeia de caracteres
Removeu um falso static_cast de std::string que não foi chamado pelo padrão e que suprimiva
acidentalmente os avisos de restrição de C4244. As tentativas de chamar
std::string::string(const wchar_t*, const wchar_t*) agora emitem corretamente o C4244 sobre restringir um
wchar_t em um char .
Várias correções para <filesystem> exatidão

Correção de std::filesystem::last_write_time falha ao tentar alterar a hora da última gravação do diretório.
O construtor std::filesystem::directory_entry agora armazena um resultado com falha, em vez de gerar
uma exceção, quando um caminho de destino não existente é fornecido.
A versão de dois parâmetros std::filesystem::create_directory foi alterada para chamar a versão de um
parâmetro, pois a função CreateDirectoryExW subjacente usaria copy_symlink quando existing_p fosse um
symlink.
std::filesystem::directory_iterator não falha mais quando um symlink corrompido é encontrado.
std::filesystem::space agora aceita caminhos relativos.
std::filesystem::path::lexically_relative não é mais confundido com barras à direita, relatado como LWG
3096.
Solução de CreateSymbolicLinkW que rejeitava caminhos com barras à esquerda em
std::filesystem::create_symlink .
trabalhou na função do modo de exclusão do POSIX delete que existia no Windows 10 LTSB 1609, mas não
podia realmente excluir arquivos.
O std::boyer_moore_searcher e std::boyer_moore_horspool_searcher copiar construtores e operadores de
atribuição de cópia agora copiam coisas.
Algoritmos paralelos no Windows 8 e posterior
A biblioteca de algoritmos paralelos agora usa devidamente a família WaitOnAddress real no Windows 8 e
posterior, em vez de sempre usar o Windows 7 e versões falsas anteriores.
Espaço em branco em std::system_category::message()
std::system_category::message() agora corta o espaço em branco à direita da mensagem retornada.

Divisão por zero em std::linear_congruential_engine
Algumas condições que poderiam fazer std::linear_congruential_engine disparar a divisão por 0 foram
corrigidas.
Correções para desencapsulamento do iterador
algumas máquinas de iterador-desencapsulamento foram expostas primeiro para a integração de usuário do
programador no Visual Studio 2017 15,8. Ele foi descrito no artigo do blog da equipe do C++ recursos STL e
correções no VS 2017 15,8. Essa maquina não desenvolve mais os iteradores derivados dos iteradores de
biblioteca padrão. Por exemplo, um usuário derivado de std::vector<int>::iterator e que tenta personalizar o
comportamento agora obtém seu comportamento personalizado ao chamar algoritmos de biblioteca padrão,
em vez do comportamento de um ponteiro.
Agora, a função reserve de contêiner não ordenada na verdade reserva N elementos, conforme descrito em
LWG 2156.
Manipulação de tempo
Anteriormente, alguns valores temporais que eram passados para a biblioteca de simultaneidade
estourariam, por exemplo, condition_variable::wait_for(seconds::max()) . Agora corrigidos, os estouros
mudaram o comportamento em um ciclo aparentemente aleatório de 29 dias (quando uint32_t
milissegundos aceitos pelas APIs do Win32 subjacentes estouravam).
O <ctime> cabeçalho agora declara timespec e timespec_get no namespace corretamente std e
também os declara no namespace global.
Várias correções de contêineres
Muitas funções de contêiner interno de biblioteca padrão foram feitas private para uma experiência
aprimorada do IntelliSense. Mais correções para marcar Membros como private são esperadas em
versões posteriores do MSVC.
Corrigimos problemas de correção de segurança de exceção que faziam com que contêineres baseados
em nó, como list , map e unordered_map , se tornem corrompidos. Durante uma
propagate_on_container_copy_assignment propagate_on_container_move_assignment operação ou
reatribuição, liberamos o nó Sentinel do contêiner com o alocador antigo, fazemos a atribuição de
POCCA/POCMA sobre o alocador antigo e, em seguida, tentamos adquirir o nó Sentinel do novo
alocador. Se essa alocação falhou, o contêiner estava corrompido. Ele não poderia até ser destruído, pois
a propriedade de um nó Sentinela é uma invariável de estrutura de dados rígido. Esse código foi
corrigido para criar o novo nó Sentinel usando o alocador do contêiner de origem antes de destruir o nó
sentinela existente.
Os contêineres foram corrigidos para alocadores sempre copiar/mover/trocar de acordo com
propagate_on_container_copy_assignment , propagate_on_container_move_assignment e
propagate_on_container_swap , mesmo para alocadores declarados is_always_equal .
Foram adicionadas sobrecargas para mesclagem de contêiner e extração de funções de membro que
aceitam contêineres rvalue. para obter mais informações, consulte P0083 "da união Mapas And Sets"
std::basic_istream::read processamento de \r\n`` => \n'
std::basic_istream::read foi corrigido para não gravar em partes do buffer fornecido temporariamente como
parte do \r\n \n processamento. Essa alteração perde um pouco da vantagem de desempenho que foi obtida
no Visual Studio 2017 15.8 para leituras com mais de 4 K. No entanto, as melhorias na eficiência evitando três
chamadas virtuais por caractere ainda estão presentes.
Construtor std::bitset
O construtor std::bitset não lê mais os numerais um e zero em ordem inversa em conjuntos de bits grandes.
Regressão de std::pair::operator=
Correção de uma regressão no std::pair operador de atribuição introduzida ao implementar LWG 2729
"SFINAE ausente em std::pair::operator= ";. Ele agora aceita corretamente tipos conversíveis em std::pair
novamente.
Contextos não deduzidos para add_const_t
Correção de um bug de características de tipo secundário, em que add_const_t e funções relacionadas devem
ser um contexto não deduzido. Em outras palavras, add_const_t deve ser um alias para
typename add_const<T>::type , e não const T .
Melhorias de conformidade no 16,1

char8_t
P0482r6. O C++20 adiciona um novo tipo de caractere usado para representar unidades de código UTF-8. Os
literais de cadeia de caracteres u8 no C++20 têm o tipo const char8_t[N] , em vez de const char[N] , que era o
caso anteriormente. Alterações semelhantes foram propostas para o padrão C no N2231. As sugestões para a
char8_t correção de compatibilidade com versões anteriores são fornecidas em P1423r3. o compilador do
Microsoft C++ adiciona suporte para char8_t o no Visual Studio 2019 versão 16,1 quando você especifica a
/Zc:char8_t opção do compilador. No futuro, ele terá suporte com /std:c++latest , que pode ser revertido
para o comportamento do c++ 17 por meio do /Zc:char8_t- . O compilador EDG que capacita o IntelliSense
ainda não oferece suporte a ele. Você poderá ver erros falsos somente do IntelliSense que não afetam a
compilação real.
Exemplo
const char* s = u8"Hello"; // C++17

const char8_t* s = u8"Hello"; // C++20
std::type_identity metafunção e std::identity objeto de função

Type_identity P0887R1. A extensão do modelo de classe std::identity preterido foi removida e substituída
pela metafunção std::type_identity do C++20 e pelo objeto de função std::identity . Ambos estão
disponíveis apenas em /std:c++latest .
o exemplo a seguir produz C4996 de aviso de reprovação para std::identity (definido em <type_traits> ) no
Visual Studio 2017:
#include <type_traits>
using T = std::identity<int>::type;
T x, y = std::identity<T>{}(x);
int i = 42;
long j = std::identity<long>{}(i);
O exemplo a seguir mostra como usar o novo std::identity (definido em <functional> ) junto com o novo
std::type_identity :
#include <functional>
using T = std::type_identity<int>::type;
T x, y = std::identity{}(x);
int i = 42;
long j = static_cast<long>(i);
Verificações de sintaxe para lambdas genéricos

O novo processador lambda permite algumas verificações sintáticas de modo de conformidade em lambdas
genéricos, em /std:c++latest ou sob qualquer outro modo de linguagem com
/experimental:newLambdaProcessor .
no Visual Studio 2017, esse código é compilado sem avisos, mas em Visual Studio 2019 ele produz o erro
C2760:
void f() {
auto a = [](auto arg) {
decltype(arg)::Type t; // C2760 syntax error: unexpected token 'identifier', expected ';'
};
}
O exemplo a seguir mostra a sintaxe correta, agora imposta pelo compilador:
void f() {
auto a = [](auto arg) {
typename decltype(arg)::Type t;
};
}
Pesquisa dependente de argumento para chamadas de função

P0846R0 (c++ 20) aumentou a capacidade de localizar modelos de função por meio de pesquisa dependente de
argumento para expressões de chamada de função com argumentos de modelo explícitos. Requer
/std:c++latest .
Inicialização designada
A inicialização designada do P0329R4 (c++ 20) permite que membros específicos sejam selecionados na
inicialização agregada usando a Type t { .member = expr } sintaxe. Requer /std:c++latest .
Funções da biblioteca padrão novas e atualizadas (C++20)
starts_with() e ends_with() para basic_string e basic_string_view .
contains() para contêineres associativos.
remove() , remove_if() , e unique() para list e forward_list agora retornam size_type .
shift_left() e shift_right() adicionados a <algorithm>.

noexcept``constexpr funções do
constexpr as funções não são mais consideradas noexcept por padrão quando usadas em uma expressão
constante. Essa alteração de comportamento vem da resolução do grupo de trabalho principal (CWG) 1351 e
está habilitada no /permissive- . o exemplo a seguir é compilado no Visual Studio 2019 versão 16,1 e anterior,
mas produz C2338 no Visual Studio 2019 versão 16,2:
constexpr int f() { return 0; }
int main() {
static_assert(noexcept(f()), "f should be noexcept"); // C2338 in 16.2
}
Para corrigir o erro, adicione a noexcept expressão à declaração da função:
constexpr int f() noexcept { return 0; }
int main() {
static_assert(noexcept(f()), "f should be noexcept");
}
Expressões binárias com diferentes tipos de enumeração

O c++ 20 preteriu as conversões aritméticas usuais em operandos, em que:
Um operando é do tipo de enumeração e
o outro é de um tipo de enumeração diferente ou de um tipo de ponto flutuante.
Para obter mais informações, consulte P1120R0.
no Visual Studio 2019 versão 16,2 e posteriores, o código a seguir produz um aviso de nível 4 quando a
/std:c++latest opção do compilador está habilitada:
enum E1 { a };
enum E2 { b };
int main() {
int i = a | b; // warning C5054: operator '|': deprecated between enumerations of different types
}
Para evitar o aviso, use static_cast para converter o segundo operando:
enum E1 { a };
enum E2 { b };
int main() {
int i = a | static_cast<int>(b);
}
Usar uma operação binária entre uma enumeração e um tipo de ponto flutuante agora é um aviso quando a
/std:c++latest opção do compilador está habilitada:
enum E1 { a };
int main() {
double i = a * 1.1;
}
Para evitar o aviso, use static_cast para converter o segundo operando:
enum E1 { a };
int main() {
double i = static_cast<int>(a) * 1.1;
}
Igualdade e comparações relacionais de matrizes

As comparações de igualdade e relacional entre dois operandos do tipo de matriz são preteridas em C++ 20
(P1120R0). Em outras palavras, uma operação de comparação entre duas matrizes (apesar das semelhanças de
classificação e extensão) é agora um aviso. a partir do Visual Studio 2019 versão 16,2, o código a seguir produz
C5056 quando a /std:c++latest opção do compilador está habilitada:
int main() {
int a[] = { 1, 2, 3 };
int b[] = { 1, 2, 3 };
if (a == b) { return 1; } // warning C5056: operator '==': deprecated for array types
}
Para evitar o aviso, você pode comparar os endereços dos primeiros elementos:
int main() {
int a[] = { 1, 2, 3 };
int b[] = { 1, 2, 3 };
if (&a[0] == &b[0]) { return 1; }
}
Para determinar se o conteúdo de duas matrizes é igual, use a std::equal função:
std::equal(std::begin(a), std::end(a), std::begin(b), std::end(b));
Efeito de definir o operador de espaçamento em == e !=
Uma definição do operador Spaceship ( <=> ) sozinha não irá mais reescrever expressões que envolvam == ou
a != menos que o operador de espaço esteja marcado como = default (P1185R2). o exemplo a seguir é
compilado no Visual Studio 2019 RTW e na versão 16,1, mas produz C2678 no Visual Studio 2019 versão 16,2:
#include <compare>
struct S {
int a;
auto operator<=>(const S& rhs) const {
return a <=> rhs.a;
}
};
bool eq(const S& lhs, const S& rhs) {
return lhs == rhs; // error C2676
}
bool neq(const S& lhs, const S& rhs) {
return lhs != rhs; // error C2676
}
Para evitar o erro, defina operator== ou declare como padrão:
#include <compare>
struct S {
int a;
auto operator<=>(const S& rhs) const {
return a <=> rhs.a;
}
bool operator==(const S&) const = default;
};
bool eq(const S& lhs, const S& rhs) {
return lhs == rhs;
}
return lhs != rhs;
}
Aprimoramentos da biblioteca padrão

<charconv> to_chars() com precisão fixa/científica. (A precisão geral está atualmente planejada para 16,4.)
P0020R6: atomic<float> , atomic<double> , atomic<long double>
P0463R1: endian
P0482R6: suporte de biblioteca para char8_t
P0600R1: [[nodiscard]] para a STL, parte 1
P0653R2: to_address()
P0754R2: <version>
P0771R1: noexcept para o std::function Construtor de movimentação
Comparadores const para contêineres associativos
O código para pesquisa e inserção no set , map , e foi multiset multimap mesclado para o tamanho de
código reduzido. As operações de inserção agora chamam a comparação de menor que em um const functor
de comparação, da mesma forma que as operações de pesquisa foram feitas anteriormente. o código a seguir é
compilado no Visual Studio 2019 versão 16,1 e anterior, mas gera C3848 no Visual Studio 2019 versão 16,2:
#include <iostream>
#include <map>
using namespace std;
struct K
{
int a;
string b = "label";
};
struct Comparer {
bool operator() (K a, K b) {
return a.a < b.a;
}
};
map<K, double, Comparer> m;
K const s1{1};
K const s2{2};
K const s3{3};
int main() {
m.emplace(s1, 1.08);
Para evitar o erro, torne o operador de comparação const :
struct Comparer {
bool operator() (K a, K b) const {
return a.a < b.a;
}
};
melhorias de conformidade no Visual Studio 2019 versão 16,3

Operadores de extração de fluxo para char* removidos
Os operadores de extração de fluxo para ponteiro para caracteres foram removidos e substituídos pelos
operadores de extração para a matriz de caracteres (por P0487R1). WG21 considera que as sobrecargas
removidas não são seguras. No /std:c++latest modo, o exemplo a seguir agora produz C2679:
// stream_extraction.cpp
// compile by using: cl /std:c++latest stream_extraction.cpp
#include <iostream>
#include <iomanip>
int main() {
char x[42];
char* p = x;
std::cin >> std::setw(42);
std::cin >> p; // C2679: binary '>>': no operator found which takes a right-hand operand of type 'char
*' (or there is no acceptable conversion)
}
Para evitar o erro, use o operador de extração com uma char[] variável:
#include <iostream>
#include <iomanip>
int main() {
char x[42];
std::cin >> std::setw(42);
std::cin >> x; // OK
}
Novas palavras-chave requires e concept
Novas palavras-chave requires e foram concept adicionadas ao compilador do Microsoft C++. Se você tentar
usar uma como um identificador no /std:c++latest modo, o compilador irá gerar C2059: "erro de sintaxe".
Construtores como nomes de tipo não permitidos
O compilador não considera mais os nomes de construtor como nomes de classe injetados nesse caso: quando
eles aparecem em um nome qualificado após um alias para uma especialização de modelo de classe.
Anteriormente, os construtores eram utilizáveis como um nome de tipo para declarar outras entidades. O
exemplo a seguir agora produz C3646:
#include <chrono>
class Foo {
std::chrono::milliseconds::duration TotalDuration{}; // C3646: 'TotalDuration': unknown override
specifier
};
Para evitar o erro, declare TotalDuration conforme mostrado aqui:
#include <chrono>
class Foo {
std::chrono::milliseconds TotalDuration {};
};
Verificação mais estrita de extern "C" funções

Se uma extern "C" função foi declarada em namespaces diferentes, as versões anteriores do compilador do
Microsoft C++ não verificaram se as declarações eram compatíveis. a partir do Visual Studio 2019 versão 16,3,
o compilador verifica a compatibilidade. No /permissive- modo, o código a seguir produz erros C2371 e
C2733:
using BOOL = int;
namespace N
{
extern "C" void f(int, int, int, bool);
}
void g()
{
N::f(0, 1, 2, false);
}
extern "C" void f(int, int, int, BOOL){}

// C2116: 'N::f': function parameter lists do not match between declarations
// C2733: 'f': you cannot overload a function with 'extern "C"' linkage
Para evitar os erros no exemplo anterior, use bool em vez de BOOL consistentemente em ambas as declarações
do f .
Aprimoramentos da biblioteca padrão
Os cabeçalhos não padrão <stdexcpt.h> e foram <typeinfo.h> removidos. O código que os inclui deve incluir os
cabeçalhos padrão <exception> e <typeinfo> , respectivamente.

Melhor imposição de pesquisa de nome de duas fases para as IDs qualificadas em /permissive-
A pesquisa de nome em duas fases requer que os nomes não dependentes usados nos corpos do modelo
fiquem visíveis para o modelo no tempo de definição. Anteriormente, esses nomes podem ter sido encontrados
quando o modelo é instanciado. essa alteração torna mais fácil escrever código portátil e de conformidade em
MSVC sob o /permissive- sinalizador.
no Visual Studio 2019 versão 16,4 com o /permissive- sinalizador definido, o exemplo a seguir produz um
erro, porque N::f não está visível quando o f<T> modelo é definido:
template <class T>

int f() {
return N::f() + T{}; // error C2039: 'f': is not a member of 'N'
}
namespace N {
int f() { return 42; }
}
Normalmente, esse erro pode ser corrigido incluindo cabeçalhos ausentes ou funções ou variáveis declaradoras
de encaminhamento, conforme mostrado no exemplo a seguir:
namespace N {
int f();
}
template <class T>

int f() {
return N::f() + T{};
}
namespace N {
}
Conversão implícita de expressões de constante integral para ponteiro nulo
o compilador de MSVC agora implementa o problema de CWG 903 no modo de conformidade ( /permissive-
). Essa regra não permite a conversão implícita de expressões de constante integral (exceto para o literal inteiro '
0 ') para constantes de ponteiro NULL. O exemplo a seguir produz C2440 no modo de conformidade:
int* f(bool* p) {
p = false; // error C2440: '=': cannot convert from 'bool' to 'bool *'
p = 0; // OK
return false; // error C2440: 'return': cannot convert from 'bool' to 'int *'
}
Para corrigir o erro, use nullptr em vez de false . Um literal 0 ainda é permitido:
int* f(bool* p) {
p = nullptr; // OK
p = 0; // OK
return nullptr; // OK
}
Regras padrão para tipos de literais inteiros

no modo de conformidade (habilitado por /permissive- ), MSVC usa as regras padrão para tipos de literais
inteiros. Literais decimais muito grandes para se ajustarem a um signed int tipo anteriormente determinado
unsigned int . Agora, esses literais recebem o próximo maior signed tipo de inteiro, long long . Além disso,
literais com o sufixo ' ' que são muito grandes para caber em um tipo recebem o signed tipo
unsigned long long .
Essa alteração pode levar a geração de diagnósticos de aviso diferentes e diferenças de comportamento para
operações aritméticas em literais.
o exemplo a seguir mostra o novo comportamento no Visual Studio 2019 versão 16,4. A i variável agora é do
tipo unsigned int . É por isso que o aviso é gerado. Os bits de ordem superior da variável j são definidos
como 0.
void f(int r) {
int i = 2964557531; // warning C4309: truncation of constant value
long long j = 0x8000000000000000ll >> r; // literal is now unsigned, shift will fill high-order bits
with 0
}
O exemplo a seguir demonstra como manter o comportamento antigo e evitar os avisos e a alteração de
comportamento de tempo de execução:
void f(int r) {
int i = 2964557531u; // OK
long long j = (long long)0x8000000000000000ll >> r; // shift will keep high-order bits
}
Parâmetros de função que os parâmetros de modelo de sombra

o compilador de MSVC agora gera um erro quando um parâmetro de função sombreia um parâmetro de
modelo:
template<typename T>
void f(T* buffer, int size, int& size_read);
template<typename T, int Size>

void f(T(&buffer)[Size], int& Size) // error C7576: declaration of 'Size' shadows a template parameter
{
return f(buffer, Size, Size);
}
Para corrigir o erro, altere o nome de um dos parâmetros:
void f(T* buffer, int size, int& size_read);
template<typename T, int Size>

void f(T (&buffer)[Size], int& size_read)
{
return f(buffer, Size, size_read);
}
Especializações fornecidas pelo usuário de características de tipo

em conformidade com a subcláusula meta. rqmts do padrão, o compilador MSVC agora gera um erro quando
encontra uma especialização definida pelo usuário de um dos type_traits modelos especificados no std
namespace. A menos que especificado de outra forma, essas especializações resultam em um comportamento
indefinido. O exemplo a seguir tem um comportamento indefinido porque ele viola a regra e a static_assert
falha com o erro C2338.
struct S;
template<>
struct std::is_fundamental<S> : std::true_type {};
static_assert(std::is_fundamental<S>::value, "fail");
Para evitar o erro, defina um struct que herde do preferencial type_trait e specialize que:
struct S;
struct my_is_fundamental : std::is_fundamental<T> {};
template<>
struct my_is_fundamental<S> : std::true_type { };
static_assert(my_is_fundamental<S>::value, "fail");
Alterações nos operadores de comparação fornecidos pelo compilador

o compilador de MSVC agora implementa as seguintes alterações para operadores de comparação por
P1630R1 quando a /std:c++latest opção está habilitada:
O compilador não reescreve as expressões usando operator== se envolve um tipo de retorno que não é um
bool . O código a seguir agora produz o erro C2088:
struct U {
operator bool() const;
};
struct S {
U operator==(const S&) const;
};

return lhs != rhs; // C2088: '!=': illegal for struct
}
Para evitar o erro, você deve definir explicitamente o operador necessário:
struct U {
};
struct S {
U operator==(const S&) const;
U operator!=(const S&) const;
};

return lhs != rhs;
}
O compilador não definirá mais um operador de comparação padrão se for membro de uma classe de união. O
exemplo a seguir agora produz o erro C2120:
#include <compare>
union S {
int a;
char b;
auto operator<=>(const S&) const = default;
};
bool lt(const S& lhs, const S& rhs) {

return lhs < rhs;
}
Para evitar o erro, defina um corpo para o operador :
#include <compare>
union S {
int a;
char b;
auto operator<=>(const S&) const { ... }
};
bool lt(const S& lhs, const S& rhs) {

return lhs < rhs;
}
O compilador não definirá mais um operador de comparação padrão se a classe contiver um membro de
referência. O código a seguir agora produz o erro C2120:
#include <compare>
struct U {
int& a;
auto operator<=>(const U&) const = default;
};
bool lt(const U& lhs, const U& rhs) {

return lhs < rhs;
}
Para evitar o erro, defina um corpo para o operador :
#include <compare>
struct U {
int& a;
auto operator<=>(const U&) const { ... };
};
bool lt(const U& lhs, const U& rhs) {

return lhs < rhs;
}
Melhorias de conformidade Visual Studio versão 16.5 de 2019

A declaração de especialização explícita sem um inicializador não é uma definição
Em , MSVC agora impõe uma regra padrão que declarações de especialização explícitas sem /permissive-
inicializadores não são definições. Anteriormente, a declaração seria considerada uma definição com um
inicializador padrão. O efeito é observável no momento do link, pois um programa dependendo desse
comportamento agora pode ter símbolos não resolvidos. Este exemplo agora resulta em um erro:
template <typename> struct S {

static int a;
};
// In permissive-, this declaration isn't a definition, and the program won't link.
template <> int S<char>::a;
int main() {
return S<char>::a;
}
error LNK2019: unresolved external symbol "public: static int S<char>::a" (?a@?$S@D@@2HA) referenced in
function _main at link time.
Para resolver o problema, adicione um inicializador:

template <typename> struct S {
static int a;
};
// Add an initializer for the declaration to be a definition.

template <> int S<char>::a{};
int main() {
return S<char>::a;
}
A saída do pré -processador preserva novas linhas

O pré-processador experimental agora preserva novas linhas e espaço em branco ao usar /P ou /E com
/experimental:preprocessor .
Dada esta origem de exemplo,
#define m()
line m(
) line
A saída anterior de /E era:
line line
#line 2
A nova saída de /E agora é:
line
line
import As module palavras-chave e são dependentes de contexto

Por P1857R1,e import module diretivas de pré-processador têm novas restrições em sua sintaxe. Este exemplo
não é mais compilado:
import // Invalid
m; // error C2146: syntax error: missing ';' before identifier 'm'
Para resolver o problema, mantenha a importação na mesma linha:
import m; // OK
Remoção de std::weak_equality e std::strong_equality
A mesclagem de P1959R0 requer que o compilador remova o comportamento e as referências aos tipos
std::weak_equality e std::strong_equality .
O código neste exemplo não é mais compilado:

#include <compare>
struct S {
std::strong_equality operator<=>(const S&) const = default;
};
void f() {
nullptr<=>nullptr;
&f <=> &f;
&S::operator<=> <=> &S::operator<=>;
}
O exemplo agora leva a esses erros:
error C2039: 'strong_equality': is not a member of 'std'

error C2143: syntax error: missing ';' before '<=>'
error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
error C7546: binary operator '<=>': unsupported operand types 'nullptr' and 'nullptr'
error C7546: binary operator '<=>': unsupported operand types 'void (__cdecl *)(void)' and 'void (__cdecl *)
(void)'
error C7546: binary operator '<=>': unsupported operand types 'int (__thiscall S::* )(const S &) const' and
'int (__thiscall S::* )(const S &) const'
Para resolver o problema, atualize para preferir os operadores relacionais integrados e substitua os tipos
removidos:
#include <compare>
struct S {
std::strong_ordering operator<=>(const S&) const = default; // prefer 'std::strong_ordering'
};
void f() {
nullptr != nullptr; // use pre-existing builtin operator != or ==.
&f != &f;
&S::operator<=> != &S::operator<=>;
}
Alterações do TLS Guard

Anteriormente, as variáveis locais de thread em DLLs não eram inicializadas corretamente. Além do thread que
carregou a DLL, eles não foram inicializados antes do primeiro uso em threads que existiam antes da DLL ser
carregada. Esse defeito agora foi corrigido. As variáveis locais de thread em uma DLL desse tipo são inicializadas
imediatamente antes de seu primeiro uso nesses threads.
Esse novo comportamento de teste para inicialização em usos de variáveis locais de thread pode ser
desabilitado usando a opção /Zc:tlsGuards- do compilador. Ou adicionando o atributo [[msvc:no_tls_guard]]
a variáveis locais de thread específicas.
Melhor diagnóstico de chamada para funções excluídas
Nosso compilador era mais permissivo sobre chamadas para funções excluídas anteriormente. Por exemplo, se
as chamadas ocorrem no contexto de um corpo de modelo, não diagnosticaremos a chamada. Além disso, se
houvesse várias instâncias de chamadas para funções excluídas, emitiríamos apenas um diagnóstico. Agora,
emitiremos um diagnóstico para cada um deles.
Uma consequência do novo comportamento pode produzir uma pequena alteração da quebra: o código que
chamou uma função excluída não seria diagnosticada se nunca fosse necessário para a geração de código.
Agora, podemos diagnosticá-lo com a frente.
Este exemplo mostra o código que agora produz um erro:
struct S {
S() = delete;
S(int) { }
};
struct U {
U() = delete;
U(int i): s{ i } { }
S s{};
};
U u{ 0 };
error C2280: 'S::S(void)': attempting to reference a deleted function

note: see declaration of 'S::S'
note: 'S::S(void)': function was explicitly deleted
Para resolver o problema, remova chamadas para funções excluídas:
struct S {
S() = delete;
S(int) { }
};
struct U {
U() = delete;
U(int i): s{ i } { }
S s; // Do not call the deleted ctor of 'S'.

};
U u{ 0 };

Os fluxos de biblioteca padrão rejeitam inserções de tipos de caracteres codificados indeteformados
inserções
Tradicionalmente, inserir um em um e inserir ou em um ou , saída wchar_t std::ostream de seu valor
char16_t char32_t std::ostream std::wostream integral. Inserir ponteiros para esses tipos de caracteres saída
o valor do ponteiro. Os programadores não acham nenhum dos dois casos intuitivos. Geralmente, eles esperam
que a biblioteca padrão transcodificar o caractere ou a cadeia de caracteres terminada em nulo em vez disso e
para a saída do resultado.
A proposta P1423R3 do C++20 adiciona sobrecargas de operador de inserção de fluxo excluídas para essas
combinações de tipos de fluxo e caractere ou ponteiro de caractere. Em , as sobrecargas fazem com que essas
inserções se formem mal, em vez de se comportarem de uma /std:c++latest maneira provavelmente não
intencional. O compilador gera o erro C2280 quando um é encontrado. Você pode definir a macro "escape
hatch" _HAS_STREAM_INSERTION_OPERATORS_DELETED_IN_CXX20 como para restaurar o comportamento 1 antigo. (A
proposta também exclui operadores de inserção de fluxo para char8_t . Nossa biblioteca padrão implementou
sobrecargas semelhantes quando adicionamos char8_t suporte, portanto, o comportamento "errado" nunca
esteve disponível para char8_t .)
Este exemplo mostra o comportamento com essa alteração:
#include <iostream>
int main() {
const wchar_t cw = L'x', *pw = L"meow";
const char16_t c16 = u'x', *p16 = u"meow";
const char32_t c32 = U'x', *p32 = U"meow";
std::cout << cw << ' ' << pw << '\n';
std::cout << c16 << ' ' << p16 << '\n';
std::cout << c32 << ' ' << p32 << '\n';
std::wcout << c16 << ' ' << p16 << '\n';
std::wcout << c32 << ' ' << p32 << '\n';
}
O código agora produz estas mensagens de diagnóstico:
error C2280: 'std::basic_ostream<char,std::char_traits<char>> &std::<<<std::char_traits<char>>

(std::basic_ostream<char,std::char_traits<char>> &,wchar_t)': attempting to reference a deleted function
(std::basic_ostream<char,std::char_traits<char>> &,char16_t)': attempting to reference a deleted function
(std::basic_ostream<char,std::char_traits<char>> &,char32_t)': attempting to reference a deleted function
error C2280: 'std::basic_ostream<wchar_t,std::char_traits<wchar_t>> &std::<<<std::char_traits<wchar_t>>
(std::basic_ostream<wchar_t,std::char_traits<wchar_t>> &,char16_t)': attempting to reference a deleted
function
error C2280: 'std::basic_ostream<wchar_t,std::char_traits<wchar_t>> &std::<<<std::char_traits<wchar_t>>
(std::basic_ostream<wchar_t,std::char_traits<wchar_t>> &,char32_t)': attempting to reference a deleted
function
Você pode obter o efeito do comportamento antigo em todos os modos de linguagem convertendo tipos de
caractere em ou tipos de ponteiro para unsigned int caractere para const void* :
#include <iostream>
int main() {
const wchar_t cw = L'x', *pw = L"meow";
const char16_t c16 = u'x', *p16 = u"meow";
const char32_t c32 = U'x', *p32 = U"meow";
std::cout << (unsigned)cw << ' ' << (const void*)pw << '\n'; // Outputs "120 0052B1C0"
std::cout << (unsigned)c16 << ' ' << (const void*)p16 << '\n'; // Outputs "120 0052B1CC"
std::cout << (unsigned)c32 << ' ' << (const void*)p32 << '\n'; // Outputs "120 0052B1D8"
std::wcout << (unsigned)c16 << ' ' << (const void*)p16 << '\n'; // Outputs "120 0052B1CC"
std::wcout << (unsigned)c32 << ' ' << (const void*)p32 << '\n'; // Outputs "120 0052B1D8"
}
Tipo de retorno alterado de std::pow() para std::complex
Anteriormente, MSVC implementação das regras de promoção para o tipo de retorno do modelo de função
std::pow() estava incorreta. Por exemplo, retornou pow(complex<float>, int) anteriormente complex<float> .
Agora, ele retorna corretamente complex<double> . A correção foi implementada incondicionalmente para todos
os modos de padrões no Visual Studio 2019 versão 16.6.
Essa alteração pode causar erros do compilador. Por exemplo, anteriormente, você podia multiplicar
pow(complex<float>, int) por um float . Como espera argumentos do mesmo tipo, o exemplo a seguir
complex<T> operator* agora emite o erro do compilador C2676:
// pow_error.cpp
// compile by using: cl /EHsc /nologo /W4 pow_error.cpp
#include <complex>
int main() {
std::complex<float> cf(2.0f, 0.0f);
(void) (std::pow(cf, -1) * 3.0f);
}
pow_error.cpp(7): error C2676: binary '*': 'std::complex<double>' does not define this operator or a
conversion to a type acceptable to the predefined operator
Há muitas correções possíveis:

Altere o tipo da float multiplicação para double . Esse argumento pode ser convertido diretamente em
um complex<double> para corresponder ao tipo retornado por pow .
Restrina o resultado de pow para complex<float> dizendo complex<float>{pow(ARG, ARG)} . Em seguida,
você pode continuar a multiplicar por um float valor.
Passe float em vez de para int pow . Essa operação pode ser mais lenta.
Em alguns casos, você pode evitar pow totalmente. Por exemplo, pow(cf, -1) pode ser substituído por
divisão.
switch avisos para C
A partir da Visual Studio 2019 versão 16.6, o compilador implementa alguns avisos C++ preexistência para o
código compilado como C. Os avisos a seguir agora estão habilitados em diferentes níveis: C4060, C4061,
C4062, C4063, C4064, C4065, C4808 e C4809. Avisos C4065 e C4060 são desabilitados por padrão em C.
Os avisos são disparados em instruções ausentes, indefinido e instruções switch ruins case enum (ou seja,
aquelas que bool contêm muitos casos). Por exemplo:
#include <stdbool.h>
int main() {
bool b = true;
switch (b) {
case true: break;
case false: break;
default: break; // C4809: switch statement has redundant 'default' label;
// all possible 'case' labels are given
}
}
Para corrigir esse código, remova o caso default redundante:
#include <stdbool.h>
int main() {
bool b = true;
switch (b) {
case true: break;
case false: break;
}
}
Classes sem nome em typedef declarações
A partir Visual Studio 2019 versão 16.6, o comportamento das declarações foi restrito para estar em
conformidade com typedef P1766R1. Com essa atualização, classes sem nome dentro typedef de uma
declaração não podem ter membros diferentes de:
membros de dados não estáticos sem inicializadores de membro padrão,
classes membro ou
enumerações de membro.
As mesmas restrições são aplicadas recursivamente a cada classe aninhada. A restrição serve para garantir a
simplicidade dos structs que têm typedef nomes para fins de vinculação. Eles devem ser simples o suficiente
para que nenhum cálculo de vinculação seja necessário antes que o compilador chegue typedef ao nome para
vinculação.
Essa alteração afeta todos os modos de padrões do compilador. Nos modos ( ) e padrão, o compilador emite o
aviso /std:c++14 /std:c++17 C5208 para código não compatível. Se for especificado, o compilador emitirá o
aviso C5208 como um erro em e emitirá o erro /permissive- /std:c++14 C7626 em /std:c++17 . O
compilador emite o erro C7626 para código não compatível quando /std:c++latest é especificado.
O exemplo a seguir mostra os constructos que não são mais permitidos em structs sem nome. Dependendo do
modo de padrões especificado, erros ou avisos C5208 ou C7626 são emitidos:
struct B { };
typedef struct : B { // inheriting from 'B'; ill-formed
void f(); // ill-formed
static int i; // ill-formed
struct U {
void f(); // nested class has non-data member; ill-formed
};
int j = 10; // default member initializer; ill-formed
} S;
O código acima pode ser corrigido dando um nome à classe sem nome:
struct B { };
typedef struct S_ : B {
void f();
static int i;
struct U {
void f();
};
int j = 10;
} S;
Importação de argumento padrão no C++/CLI

Um número crescente de APIs têm argumentos padrão no .NET Core. É por isso que agora damos suporte à
importação de argumento padrão no C++/CLI. Essa alteração pode quebrar o código existente em que várias
sobrecargas são declaradas, como neste exemplo:
public class R {
public void Func(string s) {} // overload 1
public void Func(string s, string s2 = "") {} // overload 2;
}
Quando essa classe é importada para C++/CLI, uma chamada para uma das sobrecargas causa um erro:
(gcnew R)->Func("abc"); // error C2668: 'R::Func' ambiguous call to overloaded function
O compilador emite o erro C2668 porque ambas as sobrecargas corresponderem a essa lista de argumentos.
Na segunda sobrecarga, o segundo argumento é preenchido pelo argumento padrão. Para resolver esse
problema, você pode excluir a sobrecarga redundante (1). Ou use a lista de argumentos completa e fornece
explicitamente os argumentos padrão.

é uma definição que pode ser copiada trivialmente
O C++20 alterou a definição de é trivialmente copiável. Quando uma classe tem um membro de dados não
estático com tipo qualificado, isso não implica mais que qualquer construtor de cópia ou movimentação gerado
pelo compilador, ou operador de atribuição de cópia ou movimentação, seja volatile não trivial. O comitê C++
Standard aplicou essa alteração retroativamente como um Relatório de Defeitos. No MSVC, o comportamento
do compilador não muda em diferentes modos de linguagem, como /std:c++14 ou /std:c++latest .
Veja um exemplo do novo comportamento:
struct S
{
volatile int m;
};
static_assert(std::is_trivially_copyable_v<S>, "Meow!");
Esse código não é compilado em versões do MSVC anteriores Visual Studio 2019 versão 16.7. Há um aviso do
compilador off-by-default que você pode usar para detectar essa alteração. Se você compilar o código acima
usando cl /W4 /w45220 , verá o seguinte aviso:
warning C5220: `'S::m': a non-static data member with a volatile qualified type no longer implies that
compiler generated copy/move constructors and copy/move assignment operators are non trivial`
Conversões literais de ponteiro para membro e cadeia de caracteres para bool estão restringindo
Recentemente, o comitê C++ Standard aprovou o Relatório de Defeito P1957R2,que considera como uma T*
bool conversão de restrição. MSVC correção de um bug em sua implementação, que diagnosticaria
anteriormente como T* estreitamento, mas não diagnosticou a conversão de um literal de cadeia de caracteres
em ou um ponteiro para membro bool bool para bool .
O programa a seguir está mal formado no Visual Studio 2019 versão 16.7:
struct X { bool b; };
void f(X);
int main() {
f(X { "whoops?" }); // error: conversion from 'const char [8]' to 'bool' requires a narrowing conversion
int (X::* p) = nullptr;

f(X { p }); // error: conversion from 'int X::*' to 'bool' requires a narrowing conversion
}
Para corrigir esse código, adicione comparações explícitas a ou evite contextos em que as conversões de
restrição nullptr estão mal formadas:
struct X { bool b; };
void f(X);
int main() {
f(X { "whoops?" != nullptr }); // Absurd, but OK
int (X::* p) = nullptr;

f(X { p != nullptr }); // OK
}
nullptr_t só é conversível para bool como uma inicialização direta

No C++11, só é conversível em como uma conversão direta; por exemplo, quando você inicializa um usando
uma lista de nullptr bool bool inicializadores entre chaves. Essa restrição nunca foi imposta por MSVC.
MSVC agora implementa a regra em /permissive- . Conversões implícitas agora são diagnosticadas como mal
formadas. Uma conversão contextual em ainda é permitida, porque a bool inicialização direta é
bool b(nullptr) válida.
Na maioria dos casos, o erro pode ser corrigido substituindo nullptr por , conforme mostrado neste false
exemplo:
struct S { bool b; };
void g(bool);
bool h() { return nullptr; } // error, should be 'return false;'
int main() {
bool b1 = nullptr; // error: cannot convert from 'nullptr' to 'bool'
S s { nullptr }; // error: cannot convert from 'nullptr' to 'bool'
g(nullptr); // error: cannot convert argument 1 from 'nullptr' to 'bool'
bool b2 { nullptr }; // OK: Direct-initialization

if (!nullptr) {} // OK: Contextual conversion to bool
}
Conformidade do comportamento de inicialização para inicializações de matriz com inicializadores ausentes

Anteriormente, MSVC tinha um comportamento não compatível para inicializações de matriz que tinham
inicializadores ausentes. MSVC sempre chamou o construtor padrão para cada elemento de matriz que não
tinha um inicializador. O comportamento padrão é inicializar cada elemento com uma chave vazia-initializer-list
( {} ). O contexto de inicialização para uma lista de inicializadores entre chaves vazia é a inicialização de cópia,
que não permite chamadas a construtores explícitos. Também pode haver diferenças de runtime, pois o uso de
para inicializar pode chamar um construtor que usa um , em vez {} std::initializer_list do construtor
padrão. O comportamento em conformidade está habilitado em /permissive- .
Veja um exemplo do comportamento alterado:
struct B {
explicit B() {}
};
void f() {
B b1[1]{}; // Error in /permissive-, because aggregate init calls explicit ctor
B b2[1]; // OK: calls default ctor for each array element
}
A inicialização de membros de classe com nomes sobrecarregados é sequenciada corretamente

Identificamos um bug na representação interna dos membros de dados da classe quando um nome de tipo
também é sobrecarregado como o nome de um membro de dados. Esse bug causou inconsistências na
inicialização agregada e na ordem de inicialização de membro. O código de inicialização gerado agora está
correto. No entanto, essa alteração pode levar a erros ou avisos na origem que dependia inadvertidamente dos
membros ordenados incorretamente, como neste exemplo:
// Compiling with /w15038 now gives:

// warning C5038: data member 'Outer::Inner' will be initialized after data member 'Outer::v'
struct Outer {
Outer(int i, int j) : Inner{ i }, v{ j } {}
struct Inner { int x; };

int v;
Inner Inner; // 'Inner' is both a type name and data member name in the same scope
};
Nas versões anteriores, o construtor inicializaria incorretamente o membro de dados Inner antes do membro
de dados v . (O padrão C++ requer uma ordem de inicialização igual à ordem de declaração dos membros).
Agora que o código gerado segue o padrão, a member-init-list está fora de ordem. O compilador gera um aviso
para este exemplo. Para corrigi-lo, reordene a member-initializer-list para refletir a ordem da declaração.
Resolução de sobrecarga envolvendo sobrecargas e long argumentos integrais
O padrão C++ requer a classificação de um long para int conversão como uma conversão padrão. Os MSVC
compiladores anteriores o classificam incorretamente como uma promoção integral, que classifica mais alto
para resolução de sobrecarga. Essa classificação pode fazer com que a resolução de sobrecarga seja resolvida
com êxito quando ela deve ser considerada ambígua.
O compilador agora considera a classificação corretamente no /permissive- modo . O código inválido é
diagnosticada corretamente, como neste exemplo:
void f(long long);

void f(int);
int main() {
long x {};
f(x); // error: 'f': ambiguous call to overloaded function
f(static_cast<int>(x)); // OK
}
Você pode corrigir esse problema de várias maneiras:

No site de chamada, altere o tipo do argumento passado para int . Você pode alterar o tipo de variável
ou castiá-lo.
Se houver muitos sites de chamada, você poderá adicionar outra sobrecarga que aceita um long
argumento . Nessa função, castre e encaminhe o argumento para a int sobrecarga.
Uso de variável indefinida com vinculação interna
Versões do MSVC anteriores Visual Studio 2019 versão 16.7 aceitaram o uso de uma variável declarada que
tinha vinculação interna e não extern foi definida. Essas variáveis não podem ser definidas em nenhuma outra
unidade de tradução e não podem formar um programa válido. O compilador agora diagnostica esse caso em
tempo de compilação. O erro é semelhante ao erro para funções estáticas indefinidas.
namespace {
extern int x; // Not a definition, but has internal linkage because of the anonymous namespace
}
int main()
{
return x; // Use of 'x' that no other translation unit can possibly define.
}
Esse programa anteriormente compilado e vinculado incorretamente, mas agora emitirá o erro C7631.
error C7631: 'anonymous-namespace::x': variable with internal linkage declared but not defined
Essas variáveis devem ser definidas na mesma unidade de tradução em que são usadas. Por exemplo, você pode
fornecer um inicializador explícito ou uma definição separada.
Conclusão do tipo e conversões de ponteiro derivadas para base
Em padrões C++ antes do C++20, uma conversão de uma classe derivada para uma classe base não exigia que
a classe derivada fosse um tipo de classe completo. O comitê padrão do C++ aprovou uma alteração retroativa
do Relatório de Defeitos que se aplica a todas as versões da linguagem C++. Essa alteração alinha o processo de
conversão com características de tipo, como , que exigem que a classe derivada std::is_base_of seja um tipo
de classe completo.
Veja um exemplo:
template<typename A, typename B>

struct check_derived_from
{
static A a;
static constexpr B* p = &a;
};
struct W { };
struct X { };
struct Y { };
// With this change this code will fail as Z1 is not a complete class type
struct Z1 : X, check_derived_from<Z1, X>
{
};
// This code failed before and it will still fail after this change
struct Z2 : check_derived_from<Z2, Y>, Y
{
};
// With this change this code will fail as Z3 is not a complete class type
struct Z3 : W
{
check_derived_from<Z3, W> cdf;
};
Essa alteração de comportamento se aplica a todos os modos de linguagem C++ MSVC, não apenas
/std:c++latest .
Conversões de restrição são diagnosticadas de forma mais consistente

MSVC emite um aviso para restringir conversões em um inicializador de lista de chaves. Anteriormente, o
compilador não diagnosticaria conversões de restrição de tipos subjacentes enum maiores para tipos integrais
mais restritos. (O compilador os considerou incorretamente uma promoção integral em vez de uma conversão).
Se a conversão de restrição for intencional, você poderá evitar o aviso usando um static_cast no argumento
do inicializador. Ou escolha um tipo integral de destino maior.
Aqui está um exemplo de como usar um explícito static_cast para resolver o aviso:
enum E : long long { e1 };

struct S { int i; };
void f(E e) {
S s = { e }; // warning: conversion from 'E' to 'int' requires a narrowing conversion
S s1 = { static_cast<int>(e) }; // Suppress warning with explicit conversion
}

Extensão 'Class rvalue used as lvalue'
MSVC tem uma extensão que permite usar uma classe rvalue como um lvalue. A extensão não estende o tempo
de vida da classe rvalue e pode levar a um comportamento indefinido em runtime. Agora, impõemos a regra
padrão e não permitemos essa extensão em /permissive- . Se você ainda não puder /permissive- usar, poderá
usar /we4238 para não permitir explicitamente a extensão. Veja um exemplo:
// Compiling with /permissive- now gives:

// error C2102: '&' requires l-value
struct S {};
S f();
void g()
{
auto p1 = &(f()); // The temporary returned by 'f' is destructed after this statement. So 'p1' points to
an invalid object.
const auto &r = f(); // This extends the lifetime of the temporary returned by 'f'
auto p2 = &r; // 'p2' points to a valid object
}
Extensão 'Especialização explícita em escopo não namespace'

MSVC tinha uma extensão que permitia especialização explícita no escopo de não namespace. Agora faz parte
do padrão, após a resolução do CWG 727. No entanto, há diferenças de comportamento. Ajustamos o
comportamento do compilador para alinhar com o padrão.
// Compiling with 'cl a.cpp b.cpp /permissive-' now gives:
// error LNK2005: "public: void __thiscall S::f<int>(int)" (??$f@H@S@@QAEXH@Z) already defined in a.obj
// To fix the linker error,
// 1. Mark the explicit specialization with 'inline' explicitly. Or,
// 2. Move its definition to a source file.
// common.h
struct S {
template<typename T> void f(T);
template<> void f(int);
};
// This explicit specialization is implicitly inline in the default mode.

template<> void S::f(int) {}
// a.cpp
#include "common.h"
int main() {}
// b.cpp
#include "common.h"
Verificando tipos de classe abstratas

O padrão C++20 alterou o uso dos compiladores de processo para detectar o uso de um tipo de classe abstrata
como um parâmetro de função. Especificamente, não é mais um erro SFINAE. Anteriormente, se o compilador
detectasse que uma especialização de um modelo de função teria uma instância de tipo de classe abstrata como
um parâmetro de função, essa especialização seria considerada mal formada. Ele não seria adicionado ao
conjunto de funções candidatas viáveis. No C++20, a verificação de um parâmetro de tipo de classe abstrata
não acontece até que a função seja chamada. O efeito é que o código usado para compilar não causará um erro.
Veja um exemplo:
class Node {
public:
int index() const;
};
class String : public Node {

public:
virtual int size() const = 0;
};
class Identifier : public Node {

public:
const String& string() const;
};
int compare(T x, T y)
{
return x < y ? -1 : (x > y ? 1 : 0);
}
int compare(const Node& x, const Node& y)

{
return compare(x.index(), y.index());
}
int f(const Identifier& x, const String& y)

{
return compare(x.string(), y);
}
Anteriormente, a chamada para compare teria tentado especializar o modelo de função compare usando um
String argumento de modelo para T . Falha ao gerar uma especialização válida, porque String é uma classe
abstrata. O único candidato viável teria sido compare(const Node&, const Node&) . No entanto, em C++ 20, a
verificação para o tipo de classe abstrata não acontece até que a função seja chamada. Portanto, a especialização
compare(String, String) é adicionada ao conjunto de candidatos viáveis e é escolhida como a melhor candidata
porque a conversão de const String& para String é uma sequência de conversão melhor do que a conversão
de const String& para const Node& .
Em C++ 20, uma correção possível para este exemplo é usar conceitos; ou seja, altere a definição de compare
para:
int compare(T x, T y) requires !std::is_abstract_v<T>
{
return x < y ? -1 : (x > y ? 1 : 0);
}
Ou, se os conceitos do C++ não estiverem disponíveis, você poderá fazer fallback para SFINAE:
template<typename T, std::enable_if_t<!std::is_abstract_v<T>, int> = 0>

int compare(T x, T y)
{
return x < y ? -1 : (x > y ? 1 : 0);
}
Suporte para P0960R3-permitir a inicialização de agregações de uma lista de valores entre parênteses
O c++ 20 P0960R3 adiciona suporte para inicializar uma agregação usando uma lista de inicializadores entre
parênteses. Por exemplo, o código a seguir é válido em C++ 20:
struct S {
int i;
int j;
};
S s(1, 2);
A maior parte desse recurso é aditiva, ou seja, o código agora compila que não foi compilado antes. No entanto,
ele altera o comportamento de std::is_constructible . No modo C++ 17 static_assert , isso falha, mas no
modo c++ 20 tem êxito:
static_assert(std::is_constructible_v<S, int, int>, "Assertion failed!");
Se você usar esse tipo de característica para controlar a resolução de sobrecarga, isso poderá levar a uma
alteração no comportamento entre C++ 17 e C++ 20.
Resolução de sobrecarga envolvendo modelos de função
Anteriormente, o compilador permitia a compilação de algum código /permissive- que não deveria ser
compilado. O efeito foi, o compilador chamou a função incorreta que leva a uma alteração no comportamento
do tempo de execução:
int f(int);
namespace N
{
using ::f;
T f(T);
}
void g(T&& t)
{
}
void h()
{
using namespace N;
g(f);
}
A chamada para g usa um conjunto de sobrecarga que contém duas funções, ::f e N::f . Como N::f é um
modelo de função, o compilador deve tratar o argumento da função como um contexto não deduzido. Isso
significa que, nesse caso, a chamada para g deve falhar, pois o compilador não pode deduzir um tipo para o
parâmetro de modelo T . Infelizmente, o compilador não descartava o fato de que ele já tinha decidido que
::f era uma boa correspondência para a chamada de função. Em vez de emitir um erro, o compilador geraria
código para chamar g usando ::f como argumento.
Considerando que, em muitos casos ::f , usar como o argumento da função é o que o usuário espera, só
emitiremos um erro se o código for compilado com /permissive- .
Migrando do /await para c++ 20 corrotinas
As corotinas padrão do C++ 20 estão agora ativadas por padrão em /std:c++latest . Eles diferem do TS de
corrotinas e do suporte sob a /await opção. A migração do /await para as corotinas padrão pode exigir
algumas alterações de origem.
Palavras-chave não padrão
await yieldNão há suporte para as palavras-chave e antigas no modo c++ 20. O código deve usar co_await
e co_yield , em vez disso. O modo padrão também não permite o uso de return em uma corrotina. Cada
return um em uma corrotina deve usar co_return .
// /await
task f_legacy() {
...
await g();
return n;
}
// /std:c++latest
task f() {
...
co_await g();
co_return n;
}
Tipos de initial_suspend/final_suspend
Em /await , as funções Promise inicial e suspender podem ser declaradas como retornando bool . Esse
comportamento não é padrão. No C++ 20, essas funções devem retornar um tipo de classe awaitable,
geralmente um dos tipos comuns de espera: std::suspend_always se a função foi retornada anteriormente
true ou std::suspend_never se ela foi retornada false .
// /await
struct promise_type_legacy {
bool initial_suspend() noexcept { return false; }
bool final_suspend() noexcept { return true; }
...
};
// /std:c++latest
struct promise_type {
auto initial_suspend() noexcept { return std::suspend_never{}; }
auto final_suspend() noexcept { return std::suspend_always{}; }
...
};
Tipo de yield_value
No C++ 20, a yield_value função Promise deve retornar um awaitable. No /await modo, a yield_value
função foi permitida para retornar void e sempre suspenderia. Essas funções podem ser substituídas por uma
função que retorna std::suspend_always .
// /await
...
void yield_value(int x) { next = x; };
};
// /std:c++latest
...
auto yield_value(int x) { next = x; return std::suspend_always{}; }
};
Função de tratamento de exceção

/await o oferece suporte a um tipo de promessa com nenhuma função de tratamento de exceção ou uma
função de tratamento de exceção chamada set_exception que usa um std::exception_ptr . No C++ 20, o tipo
Promise deve ter uma função chamada unhandled_exception que não usa nenhum argumento. O objeto de
exceção pode ser obtido de std::current_exception se necessário.
// /await
void set_exception(std::exception_ptr e) { saved_exception = e; }
...
};
// /std:c++latest
void unhandled_exception() { saved_exception = std::current_exception(); }
...
};
Não há suporte para tipos de retorno deduzidos de corrotinas

O c++ 20 não dá suporte a corrotinas com um tipo de retorno que inclui um tipo de espaço reservado como
auto . Tipos de retorno de corrotinas devem ser declarados explicitamente. Em /await , esses tipos deduzidos
sempre envolvem um tipo experimental e exigem a inclusão de um cabeçalho que define o tipo necessário: um
de std::experimental::task<T> , std::experimental::generator<T> ou std::experimental::async_stream<T> .
// /await
auto my_generator() {
...
co_yield next;
};
// /std:c++latest
#include <experimental/generator>
std::experimental::generator<int> my_generator() {
...
co_yield next;
};
Tipo de retorno de return_value
O tipo de retorno da return_value função Promise deve ser void . No /await modo, o tipo de retorno pode
ser qualquer coisa e é ignorado. Esse diagnóstico pode ajudar a detectar erros sutis, como quando o autor
assume incorretamente que o valor de retorno de return_value é retornado para um chamador.
// /await
...
int return_value(int x) { return x; } // incorrect, the return value of this function is unused and the
value is lost.
};
// /std:c++latest
...
void return_value(int x) { value = x; }; // save return value
};
Retornar comportamento de conversão de objeto

Se o tipo de retorno declarado de uma corrotina não corresponder ao tipo de retorno da get_return_object
função Promise, o objeto retornado de get_return_object será convertido no tipo de retorno da corrotina. Em
/await , essa conversão é feita antecipadamente, antes que o corpo da corrotina tenha a chance de ser
executado. No /std:c++latest , essa conversão é feita quando o valor é retornado para o chamador. Ele permite
que as corotinas que não suspendem no ponto de suspensão inicial façam uso do objeto retornado por
get_return_object dentro do corpo da corotina.
Parâmetros de promessa de interrotina

No C++ 20, o compilador tenta passar os parâmetros de corrotina (se houver) para um construtor do tipo
Promise. Se falhar, ele tentará novamente com um construtor padrão. No /await modo, apenas o construtor
padrão foi usado. Essa alteração pode levar a uma diferença no comportamento se a promessa tiver vários
construtores. Ou, se houver uma conversão de um parâmetro de corrotina para o tipo Promise.
struct coro {
promise_type() { ... }
promise_type(int x) { ... }
...
};
};
coro f1(int x);
// Under /await the promise gets constructed using the default constructor.
// Under /std:c++latest the promise gets constructed using the 1-argument constructor.
f1(0);
struct Object {
template <typename T> operator T() { ... } // Converts to anything!
};
coro f2(Object o);
// Under /await the promise gets constructed using the default constructor
// Under /std:c++latest the promise gets copy- or move-constructed from the result of
// Object::operator coro::promise_type().
f2(Object{});
/permissive- e os módulos do C++ 20 estão ativados por padrão em /std:c++latest
O suporte a módulos do c++ 20 está ativado por padrão em /std:c++latest . para obter mais informações
sobre essa alteração e os cenários em que module e import são tratados condicionalmente como palavras-
chave, consulte suporte a módulos padrão do c++ 20 com MSVC no Visual Studio 2019 versão 16,8.
Como um pré-requisito para suporte a módulos, permissive- agora é habilitado quando /std:c++latest é
especificado. Para obter mais informações, confira /permissive- .
Para o código que foi compilado anteriormente no /std:c++latest e requer comportamentos de compilador
não conformes, /permissive pode ser especificado para desativar o modo de conformidade estrito no
compilador. A opção do compilador deve aparecer depois /std:c++latest na lista de argumentos da linha de
comando. No entanto, /permissive o resultará em um erro se o uso de módulos for detectado:
erro C1214: os módulos estão em conflito com o comportamento não padrão solicitado via 'Option'
Os valores mais comuns para a opção são:
OPÇ ÃO DESC RIÇ Ã O
/Zc:twoPhase- A pesquisa de nome de duas fases é necessária para os

módulos do C++ 20 e implícita por /permissive- .
/Zc:hiddenFriend- Regras de pesquisa de nome de amigo oculto padrão são

necessárias para módulos do C++ 20 e implícitas pelo
/permissive- .
/Zc:preprocessor- O pré-processador de conformidade é necessário apenas

para o uso e a criação da unidade de cabeçalho do C++ 20.
Os módulos nomeados não exigem essa opção.
a /experimental:module opção ainda é necessária para usar os std.* módulos fornecidos com o Visual Studio,
porque eles ainda não foram padronizados.
A /experimental:module opção também implica /Zc:twoPhase e /Zc:hiddenFriend . Anteriormente, o código
compilado com módulos às vezes poderia ser compilado com /Zc:twoPhase- se o módulo fosse consumido
apenas. Não há mais suporte para esse comportamento.

Cópia-inicialização de temporária na inicialização direta de referência
O problema do grupo de trabalho principal CWG 2267 foi resolvido com uma inconsistência entre uma lista de
inicializadores entre parênteses e uma lista de inicializadores de chaves. A resolução harmoniza as duas formas.
Visual Studio 2019 versão 16,9 implementa o comportamento alterado em todos os /std modos de
compilador. No entanto, como é potencialmente uma alteração significativa de origem, só haverá suporte se o
código for compilado usando /permissive- .
Este exemplo demonstra a alteração no comportamento:
struct A { };
struct B {
explicit B(const A&);
};
void f()
{
A a;
const B& b1(a); // Always an error
const B& b2{ a }; // Allowed before resolution to CWG 2267 was adopted: now an error
}
Características do destruidor e subobjetos possivelmente construídos

O problema do grupo de trabalho principal CWG 2336 aborda uma omissão sobre as especificações de exceção
implícitas de destruidores em classes que têm classes base virtuais. A omissão significava que um destruidor
em uma classe derivada poderia ter uma especificação de exceção mais fraca do que uma classe base, se essa
base fosse abstrata e tivesse uma virtual base.
Visual Studio 2019 versão 16,9 implementa o comportamento alterado em todos os /std modos de
compilador.
Este exemplo mostra como a interpretação mudou:
class V {
public:
virtual ~V() noexcept(false);
};
class B : virtual V {
virtual void foo () = 0;
// BEFORE: implicitly defined virtual ~B() noexcept(true);
// AFTER: implicitly defined virtual ~B() noexcept(false);
};
class D : B {
virtual void foo ();
// implicitly defined virtual ~D () noexcept(false);
};
Antes dessa alteração, o destruidor implicitamente definido para B was noexcept , porque apenas subobjetos
possivelmente construídos são considerados. E, a classe base V não é um subobjeto potencialmente
construído, porque é uma virtual base e B é abstrata. No entanto, a classe base V é um subobjeto
potencialmente construído da classe D e, portanto D::~D , é determinada como sendo noexcept(false) ,
levando a uma classe derivada com uma especificação de exceção mais fraca do que sua base. Essa
interpretação não é segura. Pode levar a um comportamento de tempo de execução incorreto se uma exceção
for gerada de um destruidor de uma classe derivada de B.
Com essa alteração, um destruidor também será potencialmente a lançar se tiver um destruidor virtual e
qualquer classe base virtual tiver um destruidor potencialmente em lançamento.
Tipos semelhantes e associação de referência
O problema CWG 2352 do Grupo de Trabalho Principal lida com uma inconsistência entre as regras de
associação de referência e as alterações na similaridade de tipo. A inconsistência foi introduzida em relatórios de
defeito anteriores (como CWG 330). Com essa alteração, o código que anteriormente vinculava uma referência
a um temporário agora pode ser vinculado diretamente quando os tipos envolvidos diferem apenas por
qualificadores cv.
Visual Studio 2019 versão 16.9 implementa o comportamento alterado em todos os /std modos do
compilador. É potencialmente uma alteração da origem.
Este exemplo mostra o comportamento alterado:
int *ptr;
const int *const &f() {
return ptr; // Now returns a reference to 'ptr' directly.
// Previously returned a reference to a temporary and emitted C4172
}
A atualização pode alterar o comportamento do programa que dependia de um temporário introduzido:
int func() {
int i1 = 13;
int i2 = 23;
int* iptr = &i1;

int const * const& iptrcref = iptr;
// iptrcref is a reference to a pointer to i1 with value 13.

if (*iptrcref != 13)
{
return 1;
}
// Now change what iptr points to.
// Prior to CWG 2352 iptrcref should be bound to a temporary and still points to the value 13.
// After CWG 2352 it is bound directly to iptr and now points to the value 23.
iptr = &i2;
if (*iptrcref != 23)
{
return 1;
}
return 0;
}
/Zc:twoPhase e /Zc:twoPhase- alteração de comportamento da opção

Normalmente, as MSVC do compilador funcionam com base no princípio de que o último visto vence.
Infelizmente, não era o caso com as opções /Zc:twoPhase /Zc:twoPhase- e . Essas opções eram "sticky",
portanto, as opções posteriores não podiam substituí-las. Por exemplo:
cl /Zc:twoPhase /permissive a.cpp
Nesse caso, a primeira opção /Zc:twoPhase habilita a pesquisa estrita de nome de duas fases. A segunda opção
é destinada a desabilitar o modo de conformidade estrito (é o oposto de ), mas /permissive- não desabilitou
/Zc:twoPhase .
Visual Studio 2019 versão 16.9 altera esse comportamento em todos os /std modos do compilador.
/Zc:twoPhase e /Zc:twoPhase- não são mais "sticky", e as opções posteriores podem substituí-las.
Especificadores noexcept explícitos em modelos de destruidor

O compilador aceitava anteriormente um modelo de destruidor declarado com uma especificação de exceção
sem lançamento, mas definido sem um especificador noexcept explícito. A especificação de exceção implícita de
um destruidor depende das propriedades da classe – propriedades que podem não ser conhecidas no ponto de
definição de um modelo. O padrão C++ também requer esse comportamento: se um destruidor for declarado
sem um especificador noexcept, ele terá uma especificação de exceção implícita e nenhuma outra declaração da
função poderá ter um especificador noexcept.
Visual Studio 2019 versão 16.9 muda para o comportamento em conformidade em todos os /std modos do
compilador.
Este exemplo mostra a alteração no comportamento do compilador:

class B {
virtual ~B() noexcept; // or throw()
};

B<T>::~B() { /* ... */ } // Before: no diagnostic.
// Now diagnoses a definition mismatch. To fix, define the implementation by
// using the same noexcept-specifier. For example,
// B<T>::~B() noexcept { /* ... */ }
Expressões reescritas em C++20

Desde Visual Studio 2019 versão 16.2, em , o compilador aceitou /std:c++latest um código como este
exemplo:
#include <compare>
struct S {
auto operator<=>(const S&) const = default;
};
bool f(S a, S b) {
return a < b;
}
No entanto, o compilador não invocaria a função de comparação que o autor poderia esperar. O código acima
deve ter reescrito a < b como (a <=> b) < 0 . Em vez disso, o compilador usou a operator bool() função de
conversão definida pelo usuário e comparou bool(a) < bool(b) . A partir Visual Studio versão 16.9 de 2019, o
compilador reescreve a expressão usando a expressão de operador de nave espacial esperada.
Alteração da falha de origem
A aplicação correta de conversões a expressões reescritas tem outro efeito: o compilador também diagnostica
corretamente ambiguidades de tentativas de reescrever a expressão. Considere este exemplo:
struct Base {
bool operator==(const Base&) const;
};
struct Derived : Base {

Derived();
Derived(const Base&);
bool operator==(const Derived& rhs) const;
};
bool b = Base{} == Derived{};
No C++17, esse código seria aceito devido à conversão derivada para base de no lado direito Derived da
expressão. No C++20, o candidato à expressão sintetizada também é adicionado: Derived{} == Base{} . Devido
às regras no padrão sobre qual função vence com base em conversões, acontece que a escolha entre e
Base::operator== Derived::operator== é indecidável. Isso porque as sequências de conversão nas duas
expressões não são melhores ou piores do que as outras, portanto, o código de exemplo resulta em uma
ambiguidade.
Para resolver a ambiguidade, adicione um novo candidato que não estará sujeito às duas sequências de
conversão:
bool operator==(const Derived&, const Base&);
Alteração da quebra de runtime

Devido às regras de regravação do operador no C++20, é possível que a resolução de sobrecarga encontre um
novo candidato que, de outra forma, não seria possível encontrar em um modo de linguagem inferior. E o novo
candidato pode ser uma melhor combinação do que o candidato mais antigo. Considere este exemplo:
struct iterator;
struct const_iterator {
const_iterator(const iterator&);
bool operator==(const const_iterator &ci) const;
};
struct iterator {
bool operator==(const const_iterator &ci) const { return ci == *this; }
};
No C++17, o único candidato para ci == *this é const_iterator::operator== . É uma combinação porque

*this passa por uma conversão derivada para base em const_iterator . No C++20, outro candidato reescrito
é adicionado: *this == ci , que invoca iterator::operator== . Esse candidato não requer conversões, portanto,
é uma melhor combinação do que const_iterator::operator== . O problema com o novo candidato é que ela é
a função que está sendo definida no momento, portanto, a nova semântica da função causa uma definição
infinitamente recursiva de iterator::operator== .
Para ajudar no código como o exemplo, o compilador implementa um novo aviso:
$ cl /std:c++latest /c t.cpp
t.cpp
t.cpp(8): warning C5232: in C++20 this comparison calls 'bool iterator::operator ==(const const_iterator &)
const' recursively
Para corrigir o código, seja explícito sobre qual conversão usar:

struct iterator {
bool operator==(const const_iterator &ci) const { return ci == static_cast<const const_iterator&>(*this);
}
};
Melhorias de conformidade Visual Studio versão 16.10 da versão 2019

Sobrecarga errada escolhida para inicialização de cópia da classe
Dado este código de exemplo:
struct A { template <typename T> A(T&&); };

struct B { operator A(); };
struct C : public B{};
void f(A);
f(C{});
Versões anteriores do compilador converteriam incorretamente o argumento de do tipo em um usando o

construtor de conversão f C de modelo de A A . Em vez disso, o C++ padrão requer o uso do operador de
B::operator A conversão. A partir Visual Studio 2019 versão 16.10, o comportamento de resolução de
sobrecarga é alterado para usar a sobrecarga correta.
Essa alteração também pode corrigir a sobrecarga escolhida em algumas outras situações:
struct Base
{
operator char *();
};
struct Derived : public Base

{
};
void f(Derived &d)

{
// Implicit conversion to bool previously used Derived::operator bool(), now uses Base::operator char*.
// The Base function is preferred because operator bool() is declared 'const' and requires a
qualification
// adjustment for the implicit object parameter, while the Base function does not.
if (d)
{
// ...
}
}
Análise incorreta de literais de ponto flutuante

A partir Visual Studio 2019 versão 16.10, os literais de ponto flutuante são analisados com base em seu tipo
real. As versões anteriores do compilador sempre analisaram um literal de ponto flutuante como se tivesse tipo
e, em seguida, converteram o resultado double no tipo real. Esse comportamento pode levar a
arredondamento incorreto e rejeição de valores válidos:
// The binary representation is '0x15AE43FE' in VS2019 16.9

// The binary representation is '0x15AE43FD' in VS2019 16.10
// You can use 'static_cast<float>(7.038531E-26)' if you want the old behavior.
float f = 7.038531E-26f;
Ponto incorreto de declaração
As versões anteriores do compilador não podiam compilar código autorreferencial como este exemplo:
struct S {
S(int, const S*);
int value() const;

};
S s(4, &s);
O compilador não declararia a variável até analisar a s declaração inteira, incluindo os argumentos do
construtor. A lookup do s na lista de argumentos do construtor falharia. A partir Visual Studio 2019 versão
16.10, este exemplo agora é compilado corretamente.
Infelizmente, essa alteração pode quebrar o código existente, como neste exemplo:
S s(1, nullptr); // outer s

// ...
{
S s(s.value(), nullptr); // inner s
}
Em versões anteriores do compilador, quando ele pesquisa nos argumentos do construtor para a declaração
"interna" de , ele localiza a declaração anterior ("externa" ) e o código s s é s compilado. A partir da versão
16.10, o compilador emite o aviso C4700. Isso porque o compilador agora declara o "interno" antes s de
analisar os argumentos do construtor. Portanto, s a procura localiza o "interno", s que ainda não foi
inicializado.
Membro explicitamente especializado de um modelo de classe
Versões anteriores do compilador marcaram incorretamente uma especialização explícita de um membro de
modelo de classe como se ele também tivesse sido inline definido no modelo primário. Esse comportamento
significa que o compilador às vezes rejeitaria o código em conformidade. A partir Visual Studio 2019 versão
16.10, uma especialização explícita não é mais marcada implicitamente como inline no /permissive- modo .
Considere este exemplo:
// s.h
struct S {
};
template<> int S<int>::f() { return 2; }
// s.cpp
#include "s.h"
// main.cpp
#include "s.h"
int main()
{
}
Para resolver o erro do linker no exemplo acima, inline adicione explicitamente a S<int>::f :
template<> inline int S<int>::f() { return 2; }
Mangling de nome de tipo de retorno deduzido

A partir da Visual Studio 2019 versão 16.10, o compilador alterou a maneira como ele gera nomes
emaranhados para funções que deduziram tipos de retorno. Por exemplo, considere estas funções:
auto f() { return 0; }

auto g() { []{}; return 0; }
Versões anteriores do compilador gerariam esses nomes para o linker:
f: ?f@@YAHXZ -> int __cdecl f(void)

g: ?g@@YA@XZ -> __cdecl g(void)
Surpreendentemente, o tipo de retorno seria omitido de devido a outro comportamento semântico causado
pelo g lambda local no corpo da função. Essa inconsistência dificultava a implementação de funções
exportadas que têm um tipo de retorno deduzido: a interface do módulo requer informações sobre como o
corpo de uma função foi compilado. Ele precisa das informações para produzir uma função no lado de
importação que possa vincular corretamente à definição.
O compilador agora omite o tipo de retorno de uma função de tipo de retorno deduzida. Esse comportamento é
consistente com outras implementações principais. Há uma exceção para modelos de função: esta versão do
compilador apresenta um novo comportamento de nome emaranhado para modelos de função que têm um
tipo de retorno deduzido:

auto f(T) { return 1; }

decltype(auto) g(T) { return 1.; }
int (*fp1)(int) = &f;

double (*fp2)(int) = &g;
Os nomes emaranhados auto para e agora aparecem no decltype(auto) binário, não no tipo de retorno
deduzido:
f: ??$f@H@@YA?A_PH@Z -> auto __cdecl f<int>(int)

g: ??$g@H@@YA?A_TH@Z -> decltype(auto) __cdecl g<int>(int)
As versões anteriores do compilador incluiriam o tipo de retorno deduzido como parte da assinatura. Quando o
compilador incluiu o tipo de retorno no nome emaranhado, ele pode causar problemas do vinculador. Alguns
cenários bem formados se tornariam ambíguos para o vinculador.
O novo comportamento do compilador pode produzir uma alteração de quebra binária. Considere este
exemplo:
// a.cpp
auto f() { return 1; }
// main.cpp
int f();
int main() { f(); }
Em versões anteriores à versão 16.10, o compilador produzia um nome para que se parecesse com , mesmo
que elas sejam auto f() int f() funções semanticamente distintas. Isso significa que o exemplo seria
compilado. Para corrigir o problema, não confie na auto definição original de f . Em vez disso, escreva-o
como int f() . Como as funções que deduziram tipos de retorno são sempre compiladas, as implicações da
ABI são minimizadas.
Aviso para atributo nodiscard ignorado
As versões anteriores do compilador ignoram silenciosamente determinados usos de um nodiscard atributo.
Eles ignoraram o atributo se ele estava em uma posição sintática que não se aplicava à função ou classe que
está sendo declarada. Por exemplo:
static [[nodiscard]] int f() { return 1; }
a partir do Visual Studio 2019 versão 16,10, o compilador emite o aviso de nível 4 C5240 em vez disso:
a.cpp(1): warning C5240: 'nodiscard': attribute is ignored in this syntactic position
Para corrigir esse problema, mova o atributo para a posição sintática correta:
[[nodiscard]] static int f() { return 1; }
Aviso para include diretivas com nomes de cabeçalho do sistema no módulo alcance
a partir do Visual Studio 2019 versão 16,10, o compilador emite um aviso para evitar um erro de criação de
interface de módulo comum. Se você incluir um cabeçalho de biblioteca padrão após uma export module
instrução, o compilador emitirá o aviso C5244. Veja um exemplo:
export module m;
#include <vector>
export
void f(std::vector<int>);
O desenvolvedor provavelmente não pretendia m que o módulo tenha o conteúdo <vector> . O compilador
agora emite um aviso para ajudar a localizar e corrigir o problema:
m.ixx(2): warning C5244: '#include <vector>' in the purview of module 'm' appears erroneous. Consider moving
that directive before the module declaration, or replace the textual inclusion with an "import <vector>;".
m.ixx(1): note: see module 'm' declaration
Para corrigir esse problema, mova #include <vector> antes de export module m; :
#include <vector>
export module m;
export
void f(std::vector<int>);
Aviso para funções de vinculação internas não usadas
a partir do Visual Studio 2019 versão 16,10, o compilador avisa em mais situações em que uma função não
referenciada com vínculo interno foi removida. As versões anteriores do compilador emitirão o aviso C4505
para o seguinte código:
static void f() // warning C4505: 'f': unreferenced function with internal linkage has been removed
{
}
O compilador agora também avisa sobre funções não referenciadas auto e funções não referenciadas em
namespaces anônimos. Ele emite um aviso C5245 por padrão para as duas funções a seguir:
namespace
{
void f1() // warning C5245: '`anonymous-namespace'::f1': unreferenced function with internal linkage has
been removed
{
}
}
auto f2() // warning C5245: 'f2': unreferenced function with internal linkage has been removed
{
return []{ return 13; };
}
Aviso na chave corrotina

a partir do Visual Studio 2019 versão 16,10, o compilador avisa sobre as listas de inicialização que não usam
chaves para subobjetos. O compilador emite C5246 de aviso por padrão .
Veja um exemplo:
struct S1 {
int i, j;
};
struct S2 {
S1 s1;
int k;
};
S2 s2{ 1, 2, 3 }; // warning C5246: 'S2::s1': the initialization of a subobject should be wrapped in braces
Para corrigir esse problema, empacote a inicialização do subobjeto entre chaves:
S2 s2{ { 1, 2 }, 3 };
Detectar corretamente se um const objeto não foi inicializado

a partir do Visual Studio 2019 versão 16,10, o compilador agora emite o erro C2737 quando você tenta definir
um const objeto que não está totalmente inicializado:
struct S {
int i;
int j = 2;
};
const S s; // error C2737: 's': const object must be initialized
As versões anteriores do compilador permitiam que esse código fosse compilado, embora S::i não tenha sido
inicializado.
Para corrigir esse problema, inicialize todos os membros antes de criar uma const instância de um objeto:
struct S {
int i = 1;
int j = 2;
};
Confira também
melhorias de conformidade do C++, alterações de
comportamento e correções de bugs no Visual
Studio 2017
o Microsoft C/C++ no Visual Studio (MSVC) faz melhorias de conformidade e correções de bugs em todas as
versões. Este artigo lista as melhorias por versão principal e depois pela versão. Para saltar diretamente para as
alterações de uma versão específica, use a lista abaixo neste ar tigo .
este documento lista as alterações no Visual Studio 2017. para obter um guia sobre as alterações no Visual
Studio 2019, consulte melhorias de conformidade do C++ no Visual Studio 2019. Para obter uma lista completa
de melhorias de conformidade anteriores, consulte Visual C++ novidades de 2003 a 2015.
melhorias de conformidade no Visual Studio 2017 RTW (versão 15,0)

com suporte para constexpr NSDMI (inicialização de membro de dados) generalizada e não estática para
agregações, o compilador de MSVC no Visual Studio 2017 agora está concluído para os recursos adicionados
no padrão c++ 14. No entanto, o compilador ainda não tem alguns recursos dos padrões C++11 e C++98.
Consulte conformidade da linguagem C/C++ da Microsoft para o estado atual do compilador.
C++ 11: suporte ao Expression SFINAE em mais bibliotecas
O compilador continua a melhorar seu suporte para o Expression SFINAE. Ele é necessário para dedução de
argumento de modelo e substituição onde decltype e constexpr as expressões podem aparecer como
parâmetros de modelo. Para obter mais informações, consulte Expression SFINAE improvements in Visual
Studio 2017 RC (Melhorias da expressão SFINAE no Visual Studio 2017 RC).
C++ 14: NSDMI para agregações
Uma agregação é uma matriz ou uma classe que tem: nenhum construtor fornecido pelo usuário, nenhum
membro de dados não estático privado ou protegido, nenhuma classe base e nenhuma função virtual. A partir
do C++ 14, as agregações podem conter inicializadores de membro. Para obter mais informações, consulte
Member initializers and aggregates (Inicializadores de membro e agregações).
C++ 14: estendido constexpr
As expressões declaradas como constexpr agora podem conter determinados tipos de declarações, instruções
IF e switch, instruções de loop e mutação de objetos cujo tempo de vida começou dentro da constexpr
avaliação da expressão. Não há mais um requisito de que uma constexpr função de membro não estática deva
ser implicitamente const . Para obter mais informações, consulte relaxando restrições em constexpr funções.
C++ 17: conciso static_assert
o parâmetro de mensagem para static_assert é opcional. Para obter mais informações, consulte N3928:
Estendendo static_assert, v2.
C++17: atributo [[fallthrough]]
No /std:c++17 modo, o [[fallthrough]] atributo pode ser usado no contexto de instruções switch como uma
dica para o compilador que o comportamento de passagem é pretendido. Esse atributo impede o compilador de
emitir avisos em tais casos. Para obter mais informações, consulte P0188R0 para o [[fallthrough]] atributo.
Loops baseados em intervalo generalizados for
for Os loops baseados em intervalo não exigem mais que begin() e end() retornem objetos do mesmo tipo.
Essa alteração permite que o end() retorne um sentinela como usado por intervalos no range-v3 e a
especificação técnica de intervalos concluídos, mas não, bem publicados. Para obter mais informações, consulte
P0184R0-generalizando o for Loop de Range-Based.
Inicialização de lista de cópia
Visual Studio 2017 gera corretamente erros de compilador relacionados à criação de objetos usando listas de
inicializadores. esses erros não foram capturados no Visual Studio 2015 e podem levar a falhas ou
comportamento indefinido do tempo de execução. De acordo com o N4594 13.3.1.7 P1, no
copy-list-initialization , o compilador é necessário para considerar um construtor explícito para resolução de
sobrecarga. No entanto, ele deve gerar um erro se essa sobrecarga específica for escolhida.
Os dois exemplos a seguir são compilados no Visual Studio 2015, mas não no Visual Studio 2017.
struct A
{
explicit A(int) {}
A(double) {}
};
int main()
{
A a1 = { 1 }; // error C3445: copy-list-initialization of 'A' cannot use an explicit constructor
const A& a2 = { 1 }; // error C2440: 'initializing': cannot convert from 'int' to 'const A &'
Para corrigir o erro, use a inicialização direta:
A a1{ 1 };
const A& a2{ 1 };
no Visual Studio 2015, o compilador incorretamente tratava a inicialização da lista de cópia da mesma maneira
que a inicialização de cópia regular: ela considerou apenas converter construtores para resolução de
sobrecarga. no exemplo a seguir, Visual Studio o 2015 escolhe MyInt(23) . Visual Studio 2017 gera o erro
corretamente.
// From http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#1228
struct MyStore {
explicit MyStore(int initialCapacity);
};
struct MyInt {
MyInt(int i);
};
struct Printer {
void operator()(MyStore const& s);
void operator()(MyInt const& i);
};
void f() {
Printer p;
p({ 23 }); // C3066: there are multiple ways that an object
// of this type can be called with these arguments
}
Esse exemplo é semelhante ao anterior, mas gera um erro diferente. ele tem êxito no Visual Studio 2015 e falha
em Visual Studio 2017 com C2668.
struct A {
explicit A(int) {}
};
struct B {
B(int) {}
};
void f(const A&) {}

void f(const B&) {}
int main()
{
f({ 1 }); // error C2668: 'f': ambiguous call to overloaded function
}
Typedefs preteridos
Visual Studio 2017 agora emite o aviso correto para typedefs preteridos declarados em uma classe ou estrutura.
o exemplo a seguir compila sem avisos no Visual Studio 2015. ele produz C4996 no Visual Studio 2017.
struct A
{
// also for __declspec(deprecated)
[[deprecated]] typedef int inttype;
};
int main()
{
A::inttype a = 0; // C4996 'A::inttype': was declared deprecated
}
constexpr
Visual Studio 2017 gera um erro corretamente quando o operando à esquerda de uma operação de avaliação
condicional não é válido em um constexpr contexto. o código a seguir é compilado no Visual Studio 2015, mas
não em Visual Studio 2017, onde ele gera C3615:
template<int N>
struct array
{
int size() const { return N; }
};
constexpr bool f(const array<1> &arr)

{
return arr.size() == 10 || arr.size() == 11; // C3615 constexpr function 'f' cannot result in a constant
expression
}
Para corrigir o erro, declare a array::size() função como constexpr ou remova o constexpr qualificador de
f .
Tipos de classe passados para funções variadic

no Visual Studio 2017, as classes ou structs que são passadas para uma função variadic como printf devem
ser trivialmente copiáveis. Ao passar esses objetos, o compilador simplesmente faz uma cópia bit a bit e não
chama o construtor nem o destruidor.
#include <atomic>
#include <memory>
#include <stdio.h>
int main()
{
std::atomic<int> i(0);
printf("%i\n", i); // error C4839: non-standard use of class 'std::atomic<int>'
// as an argument to a variadic function.
// note: the constructor and destructor will not be called;
// a bitwise copy of the class will be passed as the argument
// error C2280: 'std::atomic<int>::atomic(const std::atomic<int> &)':
// attempting to reference a deleted function
struct S {
S(int i) : i(i) {}
S(const S& other) : i(other.i) {}
operator int() { return i; }
private:
int i;
} s(0);
printf("%i\n", s); // warning C4840 : non-portable use of class 'main::S'
// as an argument to a variadic function
}
Para corrigir o erro, é possível chamar uma função membro que retorna um tipo facilmente copiado,
std::atomic<int> i(0);
printf("%i\n", i.load());
ou usa uma conversão estática para converter o objeto antes de passá-lo:
struct S {/* as before */} s(0);

printf("%i\n", static_cast<int>(s))
Para cadeias de caracteres criadas e gerenciadas usando CString , o fornecido operator LPCTSTR() deve ser
usado para converter um CString objeto para o ponteiro C esperado pela cadeia de caracteres de formato.
CString str1;
CString str2 = _T("hello!");
str1.Format(_T("%s"), static_cast<LPCTSTR>(str2));
Qualificadores CV na construção de classe

No Visual Studio 2015, às vezes, o compilador ignora incorretamente o qualificador CV ao gerar um objeto de
classe por meio de uma chamada do construtor. Eventualmente, esse problema pode gerar uma falha ou
comportamento inesperado do runtime. O exemplo a seguir é compilado no Visual Studio 2015, mas gera um
erro de compilador no Visual Studio 2017:
struct S
{
S(int);
operator int();
};
int i = (const S)0; // error C2440
Para corrigir o erro, declare operator int() como const .

Verificação de acesso em nomes qualificados em modelos
As versões anteriores do compilador não verificaram o acesso a nomes qualificados em alguns contextos de
modelo. Esse problema pode interferir no comportamento esperado do SFINAE, em que a substituição deve
falhar devido à inacessibilidade de um nome. Ele poderia ter causado potencialmente uma falha ou um
comportamento inesperado no tempo de execução, pois o compilador incorretamente chamou a sobrecarga
incorreta do operador. No Visual Studio 2017, é gerado um erro do compilador. O erro específico pode variar,
mas um erro típico é C2672, "não há correspondência de função sobrecarregada encontrada". O código a seguir
é compilado no Visual Studio 2015, mas gera um erro no Visual Studio 2017:
template <class T> class S {

typedef typename T type;
};
template <class T, std::enable_if<std::is_integral<typename S<T>::type>::value, T> * = 0>

bool f(T x);
int main()
{
f(10); // C2672: No matching overloaded function found.
}
Listas de argumentos de modelo ausentes

no Visual Studio 2015 e anteriores, o compilador não diagnósticou todas as listas de argumentos de modelo
ausentes. Não notaria quando o modelo ausente apareceu em uma lista de parâmetros de modelo: por exemplo,
quando parte de um argumento de modelo padrão ou um parâmetro de modelo sem tipo estava ausente. Esse
problema pode resultar em comportamento imprevisível, incluindo falhas do compilador ou comportamento
inesperado do runtime. O código a seguir é compilado no Visual Studio 2015, mas produz um erro no Visual
Studio 2017.
template <class T> class ListNode;

template <class T> using ListNodeMember = ListNode<T> T::*;
template <class T, ListNodeMember M> class ListHead; // C2955: 'ListNodeMember': use of alias
// template requires template argument list
// correct: template <class T, ListNodeMember<T> M> class ListHead;
Expressão SFINAE
Para dar suporte ao Expression-SFINAE, o compilador agora analisa decltype argumentos quando os modelos
são declarados em vez de instanciados. Portanto, se uma especialização não dependente for encontrada no
argumento decltype, ela não será adiada para o tempo de instanciação. Ela será processada imediatamente, e
qualquer erro resultante será diagnosticado nesse momento.
O exemplo a seguir mostra esse erro do compilador gerado no momento da declaração:
#include <utility>
template <class T, class ReturnT, class... ArgsT>
class IsCallable
{
public:
struct BadType {};
template <class U>

static decltype(std::declval<T>()(std::declval<ArgsT>()...)) Test(int); //C2064. Should be declval<U>
template <class U>

static BadType Test(...);
static constexpr bool value = std::is_convertible<decltype(Test<T>(0)), ReturnT>::value;

};
constexpr bool test1 = IsCallable<int(), int>::value;

static_assert(test1, "PASS1");
constexpr bool test2 = !IsCallable<int*, int>::value;
static_assert(test2, "PASS2");
Classes declaradas em namespaces anônimos

De acordo com o padrão C++, uma classe declarada dentro de um namespace anônimo tem vinculação interna,
e isso significa que ela não pode ser exportada. No Visual Studio 2015 e anteriores, essa regra não era aplicada.
No Visual Studio 2017, a regra é parcialmente aplicada. no Visual Studio 2017, o exemplo a seguir gera o erro
C2201:
struct __declspec(dllexport) S1 { virtual void f() {} };

// C2201 const anonymous namespace::S1::vftable: must have external linkage
// in order to be exported/imported.
Inicializadores padrão para membros de classe de valor (C++/CLI )

No Visual Studio 2015 e nas versões anteriores, o compilador permitia (mas ignorava) um inicializador de
membro padrão para um membro de uma classe de valor. A inicialização padrão de uma classe de valor sempre
inicializa os membros em zero. Não é permitido um construtor padrão. No Visual Studio 2017, os inicializadores
de membro padrão geram um erro de compilador, conforme mostrado neste exemplo:
value struct V
{
int i = 0; // error C3446: 'V::i': a default member initializer
// isn't allowed for a member of a value class
};
Indexadores padrão (C++/CLI )

No Visual Studio 2015 e em versões anteriores, o compilador, em alguns casos, identificava incorretamente uma
propriedade padrão como um indexador padrão. Era possível contornar o problema usando o identificador
default para acessar a propriedade. A solução alternativa se tornou problemática após ter default sido
introduzida como uma palavra-chave em c++ 11. no Visual Studio 2017, os bugs que exigiam a solução
alternativa foram corrigidos. O compilador agora gera um erro quando default é usado para acessar a
propriedade padrão para uma classe.
//class1.cs
using System.Reflection;
using System.Runtime.InteropServices;
namespace ClassLibrary1
{
[DefaultMember("Value")]
public class Class1
{
public int Value
{
// using attribute on the return type triggers the compiler bug
[return: MarshalAs(UnmanagedType.I4)]
get;
}
}
[DefaultMember("Value")]
public class Class2
{
public int Value
{
get;
}
}
}
// code.cpp
#using "class1.dll"
void f(ClassLibrary1::Class1 ^r1, ClassLibrary1::Class2 ^r2)

{
r1->Value; // error
r1->default;
r2->Value;
r2->default; // error
}
No Visual Studio de 2017, é possível acessar ambas as propriedades Value pelo nome:
#using "class1.dll"
void f(ClassLibrary1::Class1 ^r1, ClassLibrary1::Class2 ^r2)

{
r1->Value;
r2->Value;
}

constexpr Lambdas
Expressões Lambda agora podem ser usadas em expressões de constante. Para obter mais informações,
consulte constexpr expressões lambda em C++.
if constexpr em modelos de função
Um modelo de função pode conter if constexpr instruções para habilitar a ramificação em tempo de
compilação. Para obter mais informações, consulte if constexpr instruções.
Instruções de seleção com inicializadores
Uma if instrução pode incluir um inicializador que apresenta uma variável no escopo do bloco dentro da
própria instrução. Para obter mais informações, consulte if instruções com inicializador.
Atributos [[maybe_unused]] e [[nodiscard]]
O novo atributo [[maybe_unused]] silencia avisos quando uma entidade não é usada. O atributo [[nodiscard]]
criará um aviso se o valor retornado de uma chamada de função for descartado. Para saber mais, veja Atributos
em C++.
Uso de namespaces de atributo sem repetição
Nova sintaxe para permitir apenas um único identificador de namespace em uma lista de atributos. Para saber
mais, veja Atributos em C++.
Associações estruturadas
Agora é possível, em uma única declaração, armazenar um valor com nomes individuais de seus componentes,
quando o valor é uma matriz, um std::tuple ou std::pair , ou tem todos os membros de dados não estáticos
públicos. Para obter mais informações, consulte associações estruturadas P0144R0 e retornando vários valores
de uma função.
Regras de construção para valores enum class
Agora há uma conversão implícita para enumerações com escopo que não são restritas. Ele converte de um tipo
subjacente de enumeração com escopo para a própria enumeração. A conversão está disponível quando sua
definição não introduz um enumerador e quando a origem usa uma sintaxe de inicialização de lista. Para obter
mais informações, consulte regras de construção de P0138R2 para enum class valores e enumerações.
Capturar *this por valor
O *this objeto em uma expressão lambda agora pode ser capturado por valor. Essa mudança permite cenários
nos quais o lambda é invocado em operações paralelas e assíncronas, especialmente em arquiteturas de
computadores mais recentes. Para obter mais informações, consulte P0018R3-lambda capturada * por valor
como [ =, * isto ] .
Remover operator++ para bool
operator++ Não é mais suportado em bool tipos. Para obter mais informações, consulte P0002R1-remove
Preterited Operator + + (bool).
Remover a palavra-chave register preterida
A register palavra-chave, anteriormente preterida (e ignorada pelo compilador), agora é removida da
linguagem. Para obter mais informações, consulte P0001R1-remove preterido uso da register palavra-chave.
Chamadas para modelos de membros excluídos
nas versões anteriores do Visual Studio, o compilador em alguns casos não emitiria um erro para chamadas
malformadas para um modelo de membro excluído. Essas chamadas poderiam causar falhas em tempo de
execução. O código a seguir agora produz C2280:
struct S {
template<typename U> static int f() = delete;
};
void g()
{
decltype(S<int>::f<int>()) i; // this should fail with
// C2280: 'int S<int>::f<int>(void)': attempting to reference a deleted function
}
Para corrigir o erro, declare i como int .

Verificações de pré -condição para características de tipo
O Visual Studio 2017 versão 15.3 melhora as verificações de pré-condição para características de tipo para
seguir o padrão mais estritamente. Uma verificação assim destina-se aos atribuíveis. o código a seguir produz
C2139 no Visual Studio 2017 versão 15,3:
struct S;
enum E;
static_assert(!__is_assignable(S, S), "fail"); // C2139 in 15.3

static_assert(__is_convertible_to(E, E), "fail"); // C2139 in 15.3
Novas verificações de runtime e o aviso do compilador em marshaling nativo para gerenciado

Chamar desde funções gerenciadas a funções nativas requer o marshaling. O CLR faz marshaling, mas não
entende a semântica do C++. Se você passar um objeto nativo por valor, o CLR chamará o construtor de cópia
do objeto ou usará BitBlt , o que poderá causar um comportamento indefinido em runtime.
Agora, o compilador emite um aviso se encontrar esse erro no momento da compilação: um objeto nativo com
o construtor de cópia excluído é passado entre um limite nativo e o gerenciado por valor. Nos casos em que o
compilador não souber no tempo de compilação, ele injetará uma verificação de runtime para que o programa
chame std::terminate imediatamente quando um marshaling malformado ocorrer. no Visual Studio 2017
versão 15,3, o código a seguir produz o aviso C4606:
class A
{
public:
A() : p_(new int) {}
~A() { delete p_; }
A(A const &) = delete;

A(A &&rhs) {
p_ = rhs.p_;
}
private:
int *p_;
};
#pragma unmanaged
void f(A a)
{
}
#pragma managed
int main()
{
// This call from managed to native requires marshaling. The CLR doesn't
// understand C++ and uses BitBlt, which results in a double-free later.
f(A()); // C4606 'A': passing argument by value across native and managed
// boundary requires valid copy constructor. Otherwise, the runtime
// behavior is undefined.`
}
Para corrigir o erro, remova a diretiva #pragma managed para marcar o chamador como nativo e evitar
marshaling.
Aviso de API experimental para WinRT
As APIs do WinRT lançadas para experimentação e comentários são decoradas com
Windows.Foundation.Metadata.ExperimentalAttribute . no Visual Studio 2017 versão 15,3, o compilador produz o
aviso C4698 para este atributo. Algumas APIs em versões anteriores do SDK do Windows já tinham sido
decoradas com o atributo, e chamadas para essas APIs agora começam a disparar esse aviso do compilador.
SDKs de Windows mais recentes têm o atributo removido de todos os tipos enviados. Se estiver usando um
SDK mais antigo, você precisará suprimir esses avisos para todas as chamadas para os tipos enviados.
O código a seguir produz o aviso C4698:
Windows::Storage::IApplicationDataStatics2::GetForUserAsync(); // C4698
// 'Windows::Storage::IApplicationDataStatics2::GetForUserAsync' is for
// evaluation purposes only and is subject to change or removal in future updates
Para desabilitar o aviso, adicione um #pragma:
#pragma warning(push)
#pragma warning(disable:4698)
Windows::Storage::IApplicationDataStatics2::GetForUserAsync();
#pragma warning(pop)
Definição fora da linha de uma função de membro de modelo

Visual Studio 2017 versão 15,3 produz um erro para uma definição fora de linha de uma função de membro de
modelo que não foi declarada na classe. O código a seguir agora produz o erro C2039:
struct S {};

void S::f(T t) {} // C2039: 'f': is not a member of 'S'
Para corrigir o erro, adicione uma declaração à classe:
struct S {
void f(T t);
};
void S::f(T t) {}
Tentar obter o endereço do ponteiro this
Em C++, this é um não prvalue do tipo ponteiro para X. Você não pode pegar o endereço this ou associá-lo
a uma referência lvalue. Nas versões anteriores do Visual Studio, o compilador permitia contornar essa restrição
com o uso de uma conversão. no Visual Studio 2017 versão 15,3, o compilador produz o erro C2664.
Conversão em uma classe base inacessível
O Visual Studio 2017 versão 15.3 gera um erro quando você tenta converter um tipo em uma classe base que
está inacessível. O código a seguir está malformado e poderá causar uma falha em runtime. O compilador agora
produz C2243 quando vê um código como este:
#include <memory>
class B { };
class D : B { }; // C2243: 'type cast': conversion from 'D *' to 'B *' exists, but is inaccessible
void f()
{
std::unique_ptr<B>(new D());
}
Os argumentos padrão não são permitidos em definições fora de linha de funções de membro
Os argumentos padrão não são permitidos em definições fora da linha de funções de membro em classes de
modelo. O compilador emitirá um aviso em /permissive e um erro de hardware em /permissive- .
Nas versões anteriores do Visual Studio, o código malformado a seguir pode causar uma falha de runtime.
Visual Studio 2017 versão 15,3 produz o aviso C5037:

struct A {
T f(T t, bool b = false);
};

T A<T>::f(T t, bool b = false) // C5037: 'A<T>::f': an out-of-line definition of a member of a class
template cannot have default arguments
{
// ...
}
Para corrigir o erro, remova o argumento padrão = false .

Uso de offsetof com o designador de membro composto
no Visual Studio 2017 versão 15,3, o uso de offsetof(T, m) onde m é um "designador de membro composto"
resulta em um aviso quando você compila com a /Wall opção. O código a seguir está malformado e pode
causar falhas em runtime. Visual Studio 2017 versão 15,3 produz o aviso C4841:
struct A {
int arr[10];
};
// warning C4841: non-standard extension used: compound member designator used in offsetof
constexpr auto off = offsetof(A, arr[2]);
Para corrigir o código, desabilite o aviso com um pragma ou altere o código para não usar offsetof :
#pragma warning(push)
#pragma warning(disable: 4841)
constexpr auto off = offsetof(A, arr[2]);
#pragma warning(pop)
Uso de offsetof com o membro de dados estáticos ou função de membro

No Visual Studio 2017 versão 15.3, usar offsetof(T, m) , em que m se refere a um membro de dados estático
ou uma função de membro, resultará em um erro. O código a seguir produz o erro C4597:
#include <cstddef>
struct A {
int ten() { return 10; }
static constexpr int two = 2;
};
constexpr auto off = offsetof(A, ten); // C4597: undefined behavior: offsetof applied to member function
'A::ten'
constexpr auto off2 = offsetof(A, two); // C4597: undefined behavior: offsetof applied to static data member
'A::two'
Esse código está malformado e pode causar falhas em runtime. Para corrigir o erro, altere o código para não
invocar mais um comportamento indefinido. Esse é o código não portátil que não é permitido pelo padrão C++.
Novo aviso em atributos __declspec
No Visual Studio 2017 versão 15.3, o compilador não ignora os atributos se __declspec(...) é aplicado antes
da especificação de vinculação extern "C" . Anteriormente, o compilador ignorava o atributo, o que podia ter
implicações de runtime. Quando as /Wall /WX Opções e são definidas, o código a seguir produz o aviso
C4768:
__declspec(noinline) extern "C" HRESULT __stdcall // C4768: __declspec attributes before linkage
specification are ignored
Para corrigir o aviso, coloque extern "C" primeiro:
extern "C" __declspec(noinline) HRESULT __stdcall
esse aviso está desativado por padrão na versão 15,3 do Visual Studio 2017 e só afeta o código compilado com
/Wall /WX . a partir do Visual Studio 2017 versão 15,5, ele é habilitado por padrão como um aviso de nível 3.
decltype e chamadas para destruidores excluídos

nas versões anteriores do Visual Studio, o compilador não detectou quando uma chamada para um destruidor
excluído ocorreu no contexto da expressão associada a decltype . no Visual Studio 2017 versão 15,3, o código a
seguir produz o erro C2280:
struct A
{
~A() = delete;
};
auto f() -> A<T>;
auto g(T) -> decltype((f<T>()));
void h()
{
g(42); // C2280: 'A<T>::~A(void)': attempting to reference a deleted function
}
Variáveis constantes não inicializadas

Visual Studio versão 2017 RTW teve uma regressão: o compilador C++ não emitiria um diagnóstico para uma
variável não const reinicializada. Essa regressão foi corrigida no Visual Studio 2017 versão 15.3. O código a
seguir agora produz o aviso C4132:
const int Value; // C4132: 'Value': const object should be initialized
Para corrigir o erro, atribua um valor a Value .

Declarações vazias
O Visual Studio 2017 versão 15.3 agora avisa sobre declarações vazias para todos os tipos, não apenas tipos
internos. O código a seguir agora produz um aviso C4091 de nível 2 para todas as quatro declarações:
struct A {};
template <typename> struct B {};
enum C { c1, c2, c3 };
int; // warning C4091 : '' : ignored on left of 'int' when no variable is declared
A; // warning C4091 : '' : ignored on left of 'main::A' when no variable is declared
B<int>; // warning C4091 : '' : ignored on left of 'B<int>' when no variable is declared
C; // warning C4091 : '' : ignored on left of 'C' when no variable is declared
Para remover os avisos, comente ou remova as declarações vazias. Em casos em que o objeto não nomeado se
destinar a ter um efeito colateral (como RAII), ele deverá receber um nome.
O aviso é excluído em /Wv:18 e está em por padrão no nível de aviso W2.
std::is_convertible para tipos de matriz
As versões anteriores do compilador davam resultados incorretos para std::is_convertible tipos de matriz.
Isso exigia que gravadores de biblioteca tratassem o compilador do Microsoft C++ de forma especial ao usar a
característica de tipo std::is_convertible<...> . No exemplo a seguir, as declarações de estática passam em
versões anteriores do Visual Studio, mas falham no Visual Studio 2017 versão 15.3:
using Array = char[1];
static_assert(std::is_convertible<Array, Array>::value);
static_assert(std::is_convertible<const Array, const Array>::value, "");
static_assert(std::is_convertible<Array&, Array>::value, "");
static_assert(std::is_convertible<Array, Array&>::value, "");
std::is_convertible<From, To> é calculada para verificar se uma definição de função imaginária está bem
formada:
To test() { return std::declval<From>(); }
Destruidores privados e std::is_constructible
As versões anteriores do compilador ignoram se um destruidor era privado ao decidir o resultado de

std::is_constructible . Agora ele os considera. No exemplo a seguir, as declarações de estática passam em
versões anteriores do Visual Studio, mas falham no Visual Studio 2017 versão 15.3:
class PrivateDtor {
PrivateDtor(int) { }
private:
~PrivateDtor() { }
};
// This assertion used to succeed. It now correctly fails.

static_assert(std::is_constructible<PrivateDtor, int>::value);
Os destruidores particulares fazem com que um tipo não seja construível. std::is_constructible<T, Args...> é
calculada como se a declaração a seguir estivesse escrita:
T obj(std::declval<Args>()...)
Essa chamada implica em uma chamada de destruidor.

C2668: resolução de sobrecarga ambígua
As versões anteriores do compilador falhavam algumas vezes ao detectar ambiguidade quando encontravam
vários candidatos, tanto por meio de declarações using quanto de pesquisas dependentes de argumento. Essa
falha pode levar à escolha errada de sobrecarga e ao comportamento inesperado de runtime. No exemplo a
seguir, Visual Studio versão 2017 15.3 gera corretamente o C2668:
namespace N {
template<class T>
void f(T&, T&);
template<class T>
void f();
}
template<class T>
void f(T&, T&);
struct S {};
void f()
{
using N::f;
S s1, s2;
f(s1, s2); // C2668: 'f': ambiguous call to overloaded function
}
Para corrigir o código, remova o uso da instrução N::f se você pretende chamar ::f() .
C2660: declarações de função locais e pesquisa dependente de argumento
As declarações de função local ocultam a declaração de função no escopo delimitador e desabilitam a pesquisa
dependente de argumento. As versões anteriores do compilador sempre fizeram uma pesquisa dependente de
argumento nesse caso. Isso poderia levar a um comportamento de runtime inesperado, se o compilador
escolhesse a sobrecarga errada. Normalmente, o erro é devido a uma assinatura incorreta da declaração da
função local. No exemplo a seguir, Visual Studio versão 2017 15.3 gera corretamente o C2660:
struct S {};
void f(S, int);
void g()
{
void f(S); // C2660 'f': function does not take 2 arguments:
// or void f(S, int);
S s;
f(s, 0);
}
Para corrigir o problema, altere a assinatura f(S) ou remova-a.

C5038: ordem de inicialização em listas de inicializador
Os membros de classe são inicializados na ordem em que são declarados, não na ordem em que aparecem nas
listas do inicializador. As versões anteriores do compilador não avisavam quando a ordem da lista de
inicializadores era diferente da ordem da declaração. Esse problema poderá levar a um comportamento de
runtime indefinido se a inicialização de um membro depender de outro membro na lista que já está sendo
inicializada. No exemplo a seguir, Visual Studio versão 2017 15.3 (com ) gera o aviso /Wall C5038:
struct A
{ // Initialized in reverse, y reused
A(int a) : y(a), x(y) {} // C5038: data member 'A::y' will be initialized after data member 'A::x'
int x;
int y;
};
Para corrigir o problema, organize a lista do inicializador para que tenha a mesma ordem que as declarações.
Um aviso semelhante é gerado quando um ou ambos os inicializadores fazem referência a membros de classe
base.
Esse aviso está off-by-default e afeta apenas o código compilado com /Wall .
Melhorias de conformidade na 15.5

Recursos marcados [ com 14] estão disponíveis incondicionalmente, mesmo no /std:c++14 modo .
Nova opção de compilador para extern constexpr
Em versões anteriores do Visual Studio, o compilador sempre dava uma vinculação interna variável, mesmo
quando a constexpr variável era marcada extern como . No Visual Studio 2017 versão 15.5, uma nova opção
do compilador, , habilita o comportamento correto e em conformidade /Zc:externConstexpr com os padrões.
Para obter mais informações, consulte extern constexpr vinculação.
Remover especificações de exceção dinâmica
P0003R5 As especificações de exceções dinâmicas foram preteridas no C++11. O recurso foi removido do
C++17, mas a especificação throw() (ainda) preterida é mantida estritamente como um alias para
noexcept(true) . Para obter mais informações, consulte Remoção de noexcept especificação de exceção
dinâmica e .
not_fn()
P0005R4 not_fn é uma substituição de not1 e not2 .

Reescrever enable_shared_from_this
P0033R1 enable_shared_from_this foi adicionada no C++ 11. O padrão C++17 atualiza a especificação para
lidar melhor com certos casos de canto. [14]
Unir mapas e conjuntos
P0083R3 Esse recurso permite a extração de nós de contêineres associativos (ou seja, , , , ) que podem ser
modificados e inseridos de volta no mesmo contêiner ou em um contêiner diferente que usa o mesmo tipo de
map set unordered_map unordered_set nó. (É um caso de uso comum extrair um nó de um std::map , alterar
a chave e inseri-lo novamente.)
Preterir partes residuais da biblioteca
P0174R2 Vários recursos da biblioteca padrão do C++ foram substituídos por novos recursos ao longo dos
anos, ou porque não se mostraram úteis, ou porque apresentaram problemas. Esses recursos foram
oficialmente preteridos no C++17.
Remover o suporte ao alocador em std::function
P0302R1 Antes do C++17, o modelo de classe tinha std::function vários construtores que levaram um
argumento de alocador. No entanto, o uso de alocadores neste contexto era problemático e a semântica era
confusa. Os construtores de problema foram removidos.
Correções para not_fn()
P0358R1 A nova expressão para std::not_fn dão suporte à propagação de categoria de valor quando usada na
invocação do wrapper.
shared_ptr<T[]> , shared_ptr<T[N]>
P0414R2 Mesclando alterações do shared_ptr dos Princípios básicos de biblioteca para o C++17. [14]
Corrigir shared_ptr para matrizes
P0497R0 Correções para o suporte de shared_ptr para matrizes. [14]
Esclarecer insert_return_type
P0508R0 Os contêineres associativos e não ordenados, ambos com chaves exclusivas, têm uma função de
membro insert que retorna um tipo aninhado insert_return_type . O tipo de retorno agora é definido como
uma especialização de um tipo com parâmetros no iterador e NodeType do contêiner.
Variáveis embutidas para a biblioteca padrão
Para P0607R0, várias variáveis comuns declaradas na biblioteca padrão agora são declaradas em linha.
Recursos preteridos do anexo D
O anexo D do C++ padrão contém todos os recursos que foram preteridos, incluindo shared_ptr::unique() ,
<codecvt> e namespace std::tr1 . Quando a opção do compilador é definida, quase todos os recursos de
biblioteca padrão no Anexo D são marcados /std:c++17 como preterido. Para obter mais informações, consulte
Recursos de biblioteca padrão no Anexo D são marcados como preterido.
O namespace no agora emite um aviso de preterição em por padrão e agora é std::tr2::sys
<experimental/filesystem> removido em por /std:c++14 /std:c++17 padrão.
Melhoria na conformidade em <iostream> , evitando uma extensão não padrão (especializações explícitas na
classe).
A biblioteca padrão agora usa modelos de variável internamente.
A biblioteca padrão foi atualizada em resposta às alterações do compilador C++17. As atualizações incluem a
noexcept adição de no sistema de tipos e a remoção de especificações de exceção dinâmica.
Alteração de ordenação parcial

O compilador agora rejeita corretamente o código a seguir e oferece a mensagem de erro correta:
template<typename... T>
int f(T* ...)
{
return 1;
}
int f(const T&)
{
return 2;
}
int main()
{
int i = 0;
f(&i); // C2668
}
t161.cpp
t161.cpp(16): error C2668: 'f': ambiguous call to overloaded function
t161.cpp(8): note: could be 'int f<int*>(const T &)'
with
[
T=int*
]
t161.cpp(2): note: or 'int f<int>(int*)'
t161.cpp(16): note: while trying to match the argument list '(int*)'
O problema no exemplo acima é que há duas diferenças nos tipos (const versus não const e pacote versus não
pack). Para eliminar o erro do compilador, remova uma das diferenças. Em seguida, o compilador pode ordenar
sem ambígua as funções.
int f(T* ...)
{
return 1;
}
int f(T&)
{
return 2;
}
int main()
{
int i = 0;
f(&i);
}
Manipuladores de exceção
Manipuladores de referência para o tipo de matriz ou função nunca são uma correspondência para qualquer
objeto de exceção. O compilador agora faz a adoção correta dessa regra e gera um aviso de nível 4, C4843. Ele
também não corresponde mais a um manipulador de ou a um literal de cadeia char* wchar_t* de caracteres
quando é /Zc:strictStrings usado.
int main()
{
try {
throw "";
}
catch (int (&)[1]) {} // C4843 (This should always be dead code.)
catch (void (&)()) {} // C4843 (This should always be dead code.)
catch (char*) {} // This should not be a match under /Zc:strictStrings
}
warning C4843: 'int (&)[1]': An exception handler of reference to array or function type is unreachable, use
'int*' instead
warning C4843: 'void (__cdecl &)(void)': An exception handler of reference to array or function type is
unreachable, use 'void (__cdecl*)(void)' instead
O código a seguir evita o erro:
catch (int (*)[1]) {}
O namespace
std::tr1 é preterido
O namespace não padrão std::tr1 está marcado como preterido nos modos C++14 e C++17. No Visual
Studio 2017 versão 15.5, o código a seguir aciona C4996:
#include <iostream>
int main() {
std::tr1::function<int (int, int)> f = std::plus<int>(); //C4996
cout << f(3, 5) << std::endl;
f = std::multiplies<int>();
}
warning C4996: 'std::tr1': warning STL4002: The non-standard std::tr1 namespace and TR1-only machinery are
deprecated and will be REMOVED. You can define _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING to acknowledge
that you have received this warning.
Para corrigir o erro, remova a referência ao namespace tr1 :
#include <iostream>
int main() {
std::function<int (int, int)> f = std::plus<int>();
f = std::multiplies<int>();
}
Os recursos de biblioteca padrão no anexo D são marcados como preteridos

Quando a /std:c++17 opção de compilador de modo é definida, quase todos os recursos de biblioteca padrão
no anexo D são marcados como preteridos.
No Visual Studio 2017 versão 15.5, o código a seguir aciona C4996:
#include <iterator>
class MyIter : public std::iterator<std::random_access_iterator_tag, int> {

public:
// ... other members ...
};
static_assert(std::is_same<MyIter::pointer, int*>::value, "BOOM");
warning C4996: 'std::iterator<std::random_access_iterator_tag,int,ptrdiff_t,_Ty*,_Ty &>::pointer': warning

STL4015: The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
(The <iterator> header is NOT deprecated.) The C++ standard has never required user-defined iterators to
derive from std::iterator. To fix this warning, stop deriving from std::iterator and start providing
publicly accessible typedefs named iterator_category, value_type, difference_type, pointer, and reference.
Note that value_type is required to be non-const, even for constant iterators. You can define
_SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to
acknowledge that you have received this warning.
Para corrigir o erro, siga as instruções no texto de aviso, conforme demonstrado no código a seguir:
#include <iterator>
class MyIter {
public:
typedef std::random_access_iterator_tag iterator_category;
typedef int value_type;
typedef ptrdiff_t difference_type;
typedef int* pointer;
typedef int& reference;
// ... other members ...

};
static_assert(std::is_same<MyIter::pointer, int*>::value, "BOOM");
Variáveis locais não referenciadas

no Visual Studio 15,5, o aviso C4189 é emitido em mais casos, conforme mostrado no código a seguir:
void f() {
char s[2] = {0}; // C4189. Either use the variable or remove it.
}
warning C4189: 's': local variable is initialized but not referenced
Para corrigir o erro, remova a variável não usada.

Comentários de única linha
No Visual Studio 2017 versão 15.5, os avisos C4001 e C4179 não são emitidos pelo compilador C.
Anteriormente, eles eram emitidos apenas sob a /Za opção do compilador. Os avisos não são mais necessários
porque comentários de linha única fazem parte do padrão C desde C99.
/* C only */
#pragma warning(disable:4001) // C4619
// single line comment
//* single line comment */
warning C4619: #pragma warning: there is no warning number '4001'
Quando o código não precisar ser compatível com versões anteriores, evite o aviso removendo a supressão
C4001 e C4179. Se o código precisar ser compatível com versões anteriores, suprima somente C4619.
/* C only */
// single line comment

/* single line comment */
Atributos __declspec com vinculação extern "C"
Em versões anteriores do Visual Studio, o compilador ignorou atributos __declspec(...) quando

__declspec(...) foi aplicado antes da especificação de vinculação extern "C" . Esse comportamento faz com
que seja gerado código não pretendido pelo usuário, com possíveis consequências no runtime. o aviso C4768
foi adicionado no Visual Studio versão 15,3, mas estava desativado por padrão. No Visual Studio 2017 versão
15.5, o aviso está habilitado por padrão.
__declspec(noinline) extern "C" HRESULT __stdcall // C4768
warning C4768: __declspec attributes before linkage specification are ignored
Para corrigir o erro, coloque a especificação de vinculação antes do atributo __declspec:
extern "C" __declspec(noinline) HRESULT __stdcall
Esse novo aviso C4768 é determinado em alguns cabeçalhos do SDK do Windows que foram fornecidos com o
Visual Studio 2017 15.3 ou anterior (por exemplo: versão 10.0.15063.0, também conhecido como SDK do RS2).
No entanto, as versões posteriores dos cabeçalhos do SDK do Windows (especificamente, ShlObj.h e
ShlObj_core.h) foram corrigidas para que não produzam o aviso. Quando você vir esse aviso proveniente de
cabeçalhos do SDK do Windows, poderá executar estas ações:
1. Mude para o SDK do Windows mais recente que acompanha o Visual Studio 2017 versão 15.5.
2. Desligue o aviso ao redor de #include da instrução de cabeçalho do SDK do Windows:
#pragma warning (push)

#include <shlobj.h>
#pragma warning (pop)
extern constexpr vinculação

em versões anteriores do Visual Studio, o compilador sempre deu uma constexpr variável de vinculação
interna mesmo quando a variável foi marcada extern . no Visual Studio 2017 versão 15,5, uma nova opção de
compilador ( /Zc:externConstexpr ) habilita o comportamento correto de conformidade com padrões. No fim
das contas, esse comportamento se tornará o padrão.
extern constexpr int x = 10;
error LNK2005: "int const x" already defined
Se um arquivo de cabeçalho contiver uma variável declarada extern constexpr , ele precisará ser marcado
__declspec(selectany) para ter suas declarações duplicadas combinadas corretamente:
extern constexpr __declspec(selectany) int x = 10;
typeid não pode ser usado em tipo de classe incompleto

Em versões anteriores do Visual Studio, o compilador permitia incorretamente o código a seguir, resultando em
informações de tipo potencialmente incorretas. No Visual Studio 2017 versão 15.5, o compilador produz
corretamente um erro:
#include <typeinfo>
struct S;
void f() { typeid(S); } //C2027 in 15.5
error C2027: use of undefined type 'S'
Tipo de destino de std::is_convertible
std::is_convertible requer que o tipo de destino seja um tipo de retorno válido. Em versões anteriores do
Visual Studio, o compilador permitia incorretamente tipos abstratos, que podem levar à resolução de
sobrecarga incorreta e ao comportamento de runtime imprevisto. O código a seguir agora aciona C2338
corretamente:
struct B { virtual ~B() = 0; };

struct D : public B { virtual ~D(); };
static_assert(std::is_convertible<D, B>::value, "fail"); // C2338 in 15.5
Para evitar o erro, você deve comparar tipos de ponteiro ao usar is_convertible , pois uma comparação de tipo
que não é de ponteiro poderá falhar se um tipo for abstrato:
struct B { virtual ~B() = 0; };

struct D : public B { virtual ~D(); };
static_assert(std::is_convertible<D *, B *>::value, "fail");

Remoção de especificação de exceção dinâmica e noexcept
No C++ 17, throw() é um alias para noexcept , throw(<type list>) e throw(...) é removido, e determinados
tipos podem incluir noexcept . Essa mudança pode causar problemas de compatibilidade de origem com o
código que está em conformidade com a C++14 ou anterior. A /Zc:noexceptTypes- opção pode ser usada para
reverter para a versão c++ 14 do noexcept ao usar o modo c++ 17 em geral. Ela permite atualizar seu código-
fonte para estar em conformidade com a C++17 sem precisar reescrever todo o código throw() ao mesmo
tempo.
O compilador agora também diagnostica mais especificações de exceção incompatíveis em declarações no
modo C++ 17 ou com /permissive- o novo aviso C5043.
o código a seguir gera C5043 e C5040 no Visual Studio 2017 versão 15,5 quando a /std:c++17 opção é
aplicada:
void f() throw(); // equivalent to void f() noexcept;

void f() {} // warning C5043
void g() throw(); // warning C5040
struct A {
virtual void f() throw();
};
struct B : A {
virtual void f() { } // error C2694
};
Para remover os erros enquanto estiver usando o /std:c++17 , adicione a /Zc:noexceptTypes- opção à linha de
comando ou atualize seu código para usar noexcept , conforme mostrado no exemplo a seguir:
void f() noexcept;

void f() noexcept { }
void g() noexcept(false);
struct A {
virtual void f() noexcept;
};
struct B : A {
virtual void f() noexcept { }
};
Variáveis embutidas
constexpr Os membros de dados estáticos agora são implicitamente inline , o que significa que sua
declaração dentro de uma classe agora é sua definição. O uso de uma definição fora de linha para um
static constexpr membro de dados é redundante e agora é preterido. no Visual Studio 2017 versão 15,5,
quando a /std:c++17 opção é aplicada, o seguinte código agora produz o aviso C5041:
struct X {
static constexpr int size = 3;
};
const int X::size; // C5041: 'size': out-of-line definition for constexpr static data member is not needed
and is deprecated in C++17
O aviso C4768 de extern "C" __declspec(...) agora está ativado por padrão
O aviso foi adicionado no Visual Studio versão 2017 versão 15.3, mas estava desativado por padrão. No Visual
Studio 2017 versão 15.5, o aviso está ativo por padrão. Para obter mais informações, consulte novo aviso sobre
__declspec atributos.
Funções usadas como padrão e __declspec(nothrow)
O compilador permitia anteriormente que funções padronizadas fossem declaradas com __declspec(nothrow)
quando as funções de base/membro correspondente permitiam exceções. Esse comportamento é contrário ao
padrão C++ e pode causar um comportamento indefinido no runtime. O padrão exige que tais funções sejam
definidas como excluídas se houver uma incompatibilidade de especificação de exceção. Em /std:c++17 , o
código a seguir gera C2280:
struct A {
A& operator=(const A& other) { // No exception specification; this function may throw.
...
}
};
struct B : public A {
__declspec(nothrow) B& operator=(const B& other) = default;
};
int main()
{
B b1, b2;
b2 = b1; // error C2280: attempting to reference a deleted function.
// Function was implicitly deleted because the explicit exception
// specification is incompatible with that of the implicit declaration.
}
Para corrigir esse código, remova o __declspec(nothrow) da função padronizada ou o = default e forneça uma
definição para a função juntamente com qualquer manipulação de exceção necessária:
struct A {
A& operator=(const A& other) {
// ...
}
};
struct B : public A {
B& operator=(const B& other) = default;
};
int main()
{
B b1, b2;
b2 = b1;
}
Especializações parciais e noexcept
Com noexcept no sistema de tipos, as especializações parciais para correspondência de tipos "chamáveis"
específicos podem não compilar ou não escolher o modelo primário, devido à ausência de uma especialização
parcial para ponteiros para as funções Except.
Nesses casos, talvez seja necessário adicionar mais especializações parciais para lidar com noexcept ponteiros
de função e noexcept ponteiros para funções de membro. Essas sobrecargas são apenas no /std:c++17 modo
legal. Se for necessário manter a compatibilidade com versões anteriores de C++14 e você estiver escrevendo
código que outras pessoas consumirão, será necessário proteger essas novas sobrecargas dentro de diretivas
#ifdef . Se você estiver trabalhando em um módulo independente, em vez de usar #ifdef as proteções, basta
compilar com a /Zc:noexceptTypes- opção.
O código a seguir é compilado em /std:c++14 , mas falha em /std:c++17 com o erro C2027:
template <typename T> struct A;
template <>
struct A<void(*)()>
{
static const bool value = true;
};

bool g(T t)
{
return A<T>::value;
}
void f() noexcept {}
int main()
{
return g(&f) ? 0 : 1; // C2027: use of undefined type 'A<T>'
}
O código a seguir é executado com sucesso /std:c++17 porque o compilador escolhe a nova especialização
parcial A<void (*)() noexcept> :
template <typename T> struct A;
template <>
struct A<void(*)()>
{
};
template <>
struct A<void(*)() noexcept>
{
};

bool g(T t)
{
return A<T>::value;
}
void f() noexcept {}
int main()
{
return g(&f) ? 0 : 1; // OK
}

Princípios básicos da biblioteca C++17 V1
O P0220R1 incorpora a especificação técnica dos princípios básicos da biblioteca para o C++17 no padrão.
Aborda atualizações para,,,,,, <experimental/tuple> <experimental/optional> <experimental/functional>
<experimental/any> <experimental/string_view> <experimental/memory> <experimental/memory_resource>
e <experimental/algorithm> .
C++ 17: melhorando a dedução de argumento de modelo de classe para a biblioteca padrão
O P0739R0 move o adopt_lock_t para a frente da lista de parâmetros para scoped_lock a fim de habilitar o
uso consistente de scoped_lock . Permite que o construtor std::variant participe na resolução de sobrecarga
em mais casos para habilitar a atribuição de cópia.

C++ 17: repalavras que herdam construtores
P0136R1 especifica que uma using declaração que nomeia um Construtor agora faz com que os construtores
de classe base correspondentes fiquem visíveis para inicializações da classe derivada, em vez de declarar
construtores de classe mais derivados. Essa reformulação é uma mudança a partir do C++14. no Visual Studio
2017 versão 15,7 e posterior, no /std:c++17 modo, o código que é válido no c++ 14 e usa construtores de
herança pode não ser válido ou ter semânticas diferentes.
O exemplo a seguir mostra o comportamento do C++14:
struct A {
A(T, typename T::type = 0);
A(int);
};
struct B : A {
using A::A;
B(int n) = delete; // Error C2280
};
B b(42L); // Calls B<long>(long), which calls A(int)

// due to substitution failure in A<long>(long).
o exemplo a seguir mostra o /std:c++17 comportamento no Visual Studio 15,7:
struct A {
A(T, typename T::type = 0);
A(int);
};
struct B : A {
using A::A;
B(int n)
{
//do something
}
};
B b(42L); // now calls B(int)
Para saber mais, veja Construtores.

C++ 17: inicialização de agregação estendida
P0017R1
se o construtor de uma classe base for não público, mas acessível a uma classe derivada, em /std:c++17 modo
no Visual Studio 2017 versão 15,7, você não poderá mais usar chaves vazias para inicializar um objeto do tipo
derivado. O exemplo a seguir mostra o comportamento de conformidade do C++ 14:
struct Derived;
struct Base {
friend struct Derived;
private:
Base() {}
};
struct Derived : Base {};

Derived d1; // OK. No aggregate init involved.
Derived d2 {}; // OK in C++14: Calls Derived::Derived()
// which can call Base ctor.
No C++ 17, Derived agora é considerado um tipo de agregação. Isso significa que a inicialização de Base por
meio do construtor padrão privado acontece diretamente como parte da regra de inicialização de agregação
estendida. Anteriormente, o construtor privado Base era chamado por meio do construtor Derived , e isso era
bem-sucedido devido à declaração friend. o exemplo a seguir mostra o comportamento do c++ 17 no Visual
Studio versão 15,7 no /std:c++17 modo:
struct Derived;
struct Base {
friend struct Derived;
private:
Base() {}
};
struct Derived : Base {
Derived() {} // add user-defined constructor
// to call with {} initialization
};
Derived d1; // OK. No aggregate init involved.
Derived d2 {}; // error C2248: 'Base::Base': cannot access
// private member declared in class 'Base'
C++ 17: declarando parâmetros de modelo sem tipo com auto

P0127R2
No /std:c++17 modo, o compilador agora pode deduzir o tipo de um argumento de modelo não tipo que é
declarado com auto :
template <auto x> constexpr auto constant = x;
auto v1 = constant<5>; // v1 == 5, decltype(v1) is int

auto v2 = constant<true>; // v2 == true, decltype(v2) is bool
auto v3 = constant<'a'>; // v3 == 'a', decltype(v3) is char
Um dos efeitos desse novo recurso é que o código válido do C++ 14 pode não ser válido ou ter semânticas
diferentes. Por exemplo, algumas sobrecargas que anteriormente eram inválidas, agora são válidas. O exemplo a
seguir mostra um código do C++14 que é compilado porque a chamada a example(p) está associada a
example(void*); . no Visual Studio 2017 versão 15,7, no /std:c++17 modo, o example modelo de função é a
melhor correspondência.
template <int N> struct A;
template <typename T, T N> int example(A<N>*) = delete;
void example(void *);
void sample(A<0> *p)

{
example(p); // OK in C++14
}
o exemplo a seguir mostra o código c++ 17 no Visual Studio 15,7 no /std:c++17 modo:
template <int N> struct A;

template <typename T, T N> int example(A<N>*);
void example(void *);
void sample(A<0> *p)

{
example(p); // C2280: 'int example<int,0>(A<0>*)': attempting to reference a deleted function
}
C++ 17: conversões elementares de cadeia de caracteres (parcial)

P0067R5 funções de nível baixo, independentes de localidade para conversões entre cadeias de caracteres e
inteiros e entre cadeias de caracteres e números de ponto flutuante.
C++ 20: evitando decaimento desnecessárias (parcial)
P0777R1 Adiciona diferenciação entre o conceito de "decaimento" e o da simples remoção de const ou de
qualificadores de referência. A característica de novo tipo de remove_reference_t substitui decay_t em alguns
contextos. O suporte a remove_cvref_t é implementado no Visual Studio 2019.
C++ 17: algoritmos paralelos
P0024R2 A TS de paralelismo será incorporada no padrão, com pequenas modificações.
C++17: hypot(x, y, z)
P0030R1 Adiciona três novas sobrecargas para std::hypot , para tipos float , double e long double , cada
uma delas tem três parâmetros de entrada.
C++17: <filesystem>
P0218R1 Adota a TS do sistema de arquivos no padrão, com algumas modificações de frase.
C++ 17: funções especiais matemáticas
P0226R1 Adota especificações técnicas anteriores para funções especiais matemáticas no cabeçalho padrão
<cmath> .
C++ 17: guias de dedução para a biblioteca padrão
P0433R2 Atualizações ao STL para aproveitar a adoção do P0091R3 pelo C++17, que adiciona suporte à
dedução de argumento de modelo de classe.
C++ 17: reparar conversões de cadeia de caracteres elementares
P0682R1 Mova as novas funções de conversão de cadeia de caracteres elementares do P0067R5 para um novo
cabeçalho <charconv> e faça outras melhorias, incluindo a alteração do tratamento de erro a ser usado
std::errc em vez de std::error_code .
C++17: constexpr para char_traits (parcial)

P0426R1 Alterações em std::traits_type funções de membro length , compare e find para tornar
std::string_viewutilizáveis em expressões constantes. (No Visual Studio 2017 versão 15.6, compatível
somente com Clang/LLVM. Na versão 15.7 Preview 2, há compatibilidade quase concluída com ClXX também).
C++ 17: argumento padrão no modelo de classe primária
Essa alteração de comportamento é uma pré-condição para dedução de argumento P0091R3-template para
modelos de classe.
Anteriormente, o compilador ignorava o argumento padrão no modelo de classe primária:
struct S {
void f(int = 0);
};
void S<T>::f(int = 0) {} // Re-definition necessary
no /std:c++17 modo no Visual Studio 2017 versão 15,7, o argumento padrão não é ignorado:
struct S {
void f(int = 0);
};
void S<T>::f(int) {} // Default argument is used
Resolução de nome dependente

Essa alteração de comportamento é uma pré-condição para dedução de argumento P0091R3-template para
modelos de classe.
No exemplo a seguir, o compilador do Visual Studio 15.6 e anterior resolve D::type como B<T>::type no
modelo de classe primária.
struct B {
using type = T;
};
struct D : B<T*> {
using type = B<T*>::type;
};
Visual Studio 2017 versão 15,7, no /std:c++17 modo, requer a typename palavra-chave na using instrução em
D. Sem typename , o compilador gera o aviso C4346: 'B<T*>::type': dependent name is not a type e o erro
C2061: syntax error: identifier 'type' :
struct B {
using type = T;
};
struct D : B<T*> {
using type = typename B<T*>::type;
};
C++17: Atributo [[nodiscard]] – aumento do nível de aviso
no Visual Studio 2017 versão 15,7 no /std:c++17 modo, o nível de aviso de C4834 é aumentado de W3 para
W1. Você pode desabilitar o aviso com uma conversão para void ou passando /wd:4834 para o compilador.
[[nodiscard]] int f() { return 0; }
int main() {
f(); // warning C4834: discarding return value
// of function with 'nodiscard'
}
Lista de inicialização de classe base do construtor de modelo Variadic

Em edições anteriores do Visual Studio, uma lista de inicialização de classe base do construtor de modelo
variadic que não continha argumentos de modelos foi erroneamente permitida sem erro. No Visual Studio 2017
versão 15.7 é gerado um erro do compilador.
O exemplo de código a seguir no Visual Studio 2017 versão 15.7 gera erro C2614:
struct B {};
struct D : B<T>
{
template<typename ...C>
D() : B() {} // C2614: D<int>: illegal member initialization: 'B' is not a base or member
};
D<int> d;
Para corrigir o erro, altere a expressão B () para B <T> ().

Inicialização de agregação de constexpr
As versões anteriores do compilador C++ manipulavam incorretamente a constexpr inicialização de

agregação. O compilador aceitou o código inválido no qual o Aggregate-init-List tinha muitos elementos e
produziu código de objeto inválido para ele. O código a seguir é um exemplo desse código:
#include <array>
struct X {
unsigned short a;
unsigned char b;
};
int main() {
constexpr std::array<X, 2> xs = { // C2078: too many initializers
{ 1, 2 },
{ 3, 4 }
};
return 0;
}
no Visual Studio 2017 versão 15,7 atualização 3 e posterior, o exemplo anterior agora gera C2078. O exemplo a
seguir mostra como corrigir o código. Ao inicializar um std::array com chaves init-lists aninhadas, forneça
para matriz interna uma lista entre chaves própria:
#include <array>
struct X {
unsigned short a;
unsigned char b;
};
int main() {
constexpr std::array<X, 2> xs = {{ // note double braces
{ 1, 2 },
{ 3, 4 }
}}; // note double braces
return 0;
}

typename em identificadores não qualificados
No /permissive- modo, typename palavras-chave falsas em identificadores não qualificados em definições de
modelo de alias não são mais aceitas pelo compilador. O código a seguir agora produz C7511:

using X = typename T; // C7511: 'T': 'typename' keyword must be
// followed by a qualified name
Para corrigir o erro, altere a segunda linha para using X = T; .

__declspec() no lado direito das definições de modelo de alias
__declspec Não é mais permitido no lado direito de uma definição de modelo de alias. Anteriormente, o
compilador aceitou, mas ignorei esse código. Ele nunca resultaria em um aviso de reprovação quando o alias foi
usado.
o atributo C++ padrão [[deprecated]] pode ser usado em vez disso e é respeitado no Visual Studio 2017
versão 15,6. O código a seguir agora produz C2760:

using X = __declspec(deprecated("msg")) T; // C2760: syntax error:
// unexpected token '__declspec',
// expected 'type specifier'`
Para corrigir o erro, altere o código da seguinte forma (com o atributo colocado antes de '=' da definição do
alias):

using X [[deprecated("msg")]] = T;
Diagnóstico de pesquisa de nome em duas fases

A pesquisa de nome em duas fases requer que os nomes não dependentes usados nos corpos do modelo
fiquem visíveis para o modelo no tempo de definição. Anteriormente, o compilador C++ da Microsoft deixaria
um nome não encontrado como não pesquisado até o momento da instanciação. Agora, ele exige que os nomes
não dependentes estejam vinculados no corpo do modelo.
Uma forma em que isso se manifesta é com a pesquisa em classes base dependentes. Anteriormente, o
compilador permitia o uso de nomes que são definidos em classes base dependentes. Isso ocorre porque eles
seriam pesquisados durante o tempo de instanciação quando todos os tipos são resolvidos. Agora, esse código
é tratado como um erro. Nesses casos, você pode forçar a pesquisa da variável no tempo de instanciação
qualificando-a com o tipo de classe base ou, de outro modo, tornando-a dependente, por exemplo, adicionando
um ponteiro this-> .
No /permissive- modo, o código a seguir agora gera C3861:
template <class T>

struct Base {
int base_value = 42;
};
template <class T>

struct S : Base<T> {
int f() {
return base_value; // C3861: 'base_value': identifier not found
}
};
Para corrigir o erro, altere a return instrução para return this->base_value; .
NOTE
nas versões do Boost. Python library anteriores a 1,70, há uma solução alternativa específica MSVC para uma declaração
de encaminhamento de modelo no unwind_type.hpp . em /permissive- modo começando no Visual Studio 2017
versão 15,8 ( _MSC_VER==1915 ), o compilador MSVC faz a pesquisa de nome dependente de argumento (ADL)
corretamente. Agora é consistente com outros compiladores, tornando essa proteção alternativa desnecessária. Para
evitar o erro C3861: 'unwind_type': identifier not found , atualize sua biblioteca Boost. Python.
Declarações e definições de encaminhamento no namespace std
O padrão C++ não permite que um usuário adicione declarações ou definições de encaminhamento no
namespace std . A adição de declarações ou de definições ao namespace std ou a um namespace no
namespace std agora resulta em um comportamento indefinido.
Em algum momento no futuro, a Microsoft mudará o local em que alguns tipos padrão são definidos. Essa
mudança interromperá o código existente que adiciona as declarações de encaminhamento ao namespace std .
Um novo aviso, o C4643, ajuda a identificar esses problemas de origem. O aviso é habilitado no /default
modo e é desativado por padrão. Ele afetará os programas que são compilados com o /Wall ou o /WX .
O código a seguir agora gera C4643:
namespace std {
template<typename T> class vector; // C4643: Forward declaring 'vector'
// in namespace std is not permitted
// by the C++ Standard`
}
Para corrigir o erro, use uma #include diretiva em vez de uma declaração de encaminhamento:
#include <vector>
Construtores que delegam a si mesmos

O padrão C++ sugere que um compilador deve emitir um diagnóstico quando um construtor de delegação
delega a si mesmo. O compilador do Microsoft C++ no /std:c++17 e os /std:c++latest modos agora geram
C7535.
Sem esse erro, o programa a seguir será compilado, mas gerará um loop infinito:
class X {
public:
X(int, int);
X(int v) : X(v){} // C7535: 'X::X': delegating constructor calls itself
};
Para evitar o loop infinito, delegue para um construtor diferente:
class X {
public:
X(int, int);
X(int v) : X(v, 0) {}
};
offsetof com expressões de constante

offsetof Tradicionalmente, foi implementado usando uma macro que requer um reinterpret_cast . Esse uso
não é válido em contextos que requerem uma expressão de constante, mas usualmente o compilador C++ da
Microsoft tem permitido isso. A offsetof macro que é enviada como parte da biblioteca padrão usa
corretamente um compilador intrínseco ( __builtin_offsetof ), mas muitas pessoas usaram o truque da macro
para definir suas próprias offsetof .
no Visual Studio 2017 versão 15,8, o compilador restringe as áreas que esses reinterpret_cast operadores
podem aparecer no modo padrão, para ajudar o código a estar em conformidade com o comportamento
padrão do C++. Em /permissive- , as restrições são ainda mais estritas. O uso do resultado de um offsetof
em locais que exigem expressões constantes pode resultar em código que emite aviso C4644 ou C2975.
O código a seguir gera C4644 /default e /std:c++17 modos, e C2975 no /permissive- modo:
struct Data {
int x;
};
// Common pattern of user-defined offsetof

#define MY_OFFSET(T, m) (unsigned long long)(&(((T*)nullptr)->m))
int main()
{
switch (0) {
case MY_OFFSET(Data, x): return 0; // C4644: usage of the
// macro-based offsetof pattern in constant expressions
// is non-standard; use offsetof defined in the C++
// standard library instead
// OR
// C2975: invalid template argument, expected
// compile-time constant expression
default: return 1;
}
}
Para corrigir o erro, use offsetof conforme definido por meio de <cstddef> :
#include <cstddef>
struct Data {
int x;
};
int main()
{
switch (0) {
case offsetof(Data, x): return 0;
default: return 1;
}
}
qualificadores de cv em classes base sujeitos a expansão de pacote

As versões anteriores do compilador C++ da Microsoft não detectavam que uma classe base tinha
qualificadores de cv se ele também estivesse sujeito à expansão do pacote.
no Visual Studio 2017 versão 15,8, no /permissive- modo, o código a seguir gera C3770:
class X : public T... { };
class S { };
int main()
{
X<const S> x; // C3770: 'const S': is not a valid base class
}
Palavra-chave template e especificadores de nome aninhados

No /permissive- modo, o compilador agora requer que a template palavra-chave preceda um nome de
modelo quando ele vier após um especificador de nome aninhado dependente.
O código a seguir no /permissive- modo agora gera C7510:
template<typename T> struct Base

{
template<class U> void example() {}
};
struct X : Base<T>
{
void example()
{
Base<T>::example<int>(); // C7510: 'example': use of dependent
// template name must be prefixed with 'template'
// note: see reference to class template instantiation
// 'X<T>' being compiled
}
};
Para corrigir o erro, adicione a template palavra-chave à Base<T>::example<int>(); instrução, conforme

mostrado no exemplo a seguir:
template<typename T> struct Base
{
template<class U> void example() {}
};
struct X : Base<T>
{
void example()
{
// Add template keyword here:
Base<T>::template example<int>();
}
};

Ordem de avaliação da esquerda para a direita para os operadores ->* , [] , >> e <<
A partir do C++17, os operandos dos operadores ->* , [] , >> e << devem ser avaliados na ordem da
esquerda para a direita. Há dois casos em que o compilador não conseguirá garantir esta ordem:
quando uma das expressões do operando é um objeto passado por valor ou que contém um objeto
passado por valor ou
Quando compilado usando /clr , e um dos operandos é um campo de um objeto ou um elemento de
matriz.
O compilador emite um aviso C4866 quando não é capaz de garantir a avaliação da esquerda para a direita. O
compilador gera esse aviso somente se /std:c++17 ou mais tarde for especificado, pois o requisito de ordem da
esquerda para a direita desses operadores foi introduzido em c++ 17.
Para resolver esse aviso, primeiro considere se a avaliação da esquerda para a direita dos operandos é
necessária. Por exemplo, pode ser necessário quando a avaliação dos operandos puder produzir efeitos
colaterais dependentes de ordem. A ordem na qual os operandos são avaliados não tem nenhum efeito
observável em muitos casos. Se a ordem da avaliação precisar ser da esquerda para a direita, considere se não é
possível passar os operandos por referência const. Essa alteração elimina o aviso no seguinte exemplo de
código:
// C4866.cpp
// compile with: /w14866 /std:c++17
class HasCopyConstructor
{
public:
int x;
HasCopyConstructor(int x) : x(x) {}
HasCopyConstructor(const HasCopyConstructor& h) : x(h.x) { }
};
int operator>>(HasCopyConstructor a, HasCopyConstructor b) { return a.x >> b.x; }
// This version of operator>> does not trigger the warning:

// int operator>>(const HasCopyConstructor& a, const HasCopyConstructor& b) { return a.x >> b.x; }
int main()
{
HasCopyConstructor a{ 1 };
HasCopyConstructor b{ 2 };
a>>b; // C4866 for call to operator>>

};
Identificadores em modelos de alias de membro

Um identificador usado em uma definição de modelo de alias de membro precisa ser declarado antes de ser
usado.
Em versões anteriores do compilador, o código a seguir era permitido. no Visual Studio 2017 versão 15,9, no
/permissive- modo, o compilador gera C3861:
template <typename... Ts>

struct A
{
public:
template <typename U>
using from_template_t = decltype(from_template(A<U>{})); // C3861:
// 'from_template': identifier not found
private:
template <template <typename...> typename Type, typename... Args>
static constexpr A<Args...> from_template(A<Type<Args...>>);
};
A<>::from_template_t<A<int>> a;
Para corrigir o erro, declare from_template antes de from_template_t .

Alterações nos módulos
no Visual Studio 2017, versão 15,9, o compilador gera C5050 sempre que as opções de linha de comando para
módulos não são consistentes entre os lados de criação de módulo e de consumo de módulo. No exemplo a
seguir, há dois problemas:
No lado de consumo (Main. cpp), a opção /EHsc não é especificada.
A versão C++ está /std:c++17 no lado da criação e /std:c++14 no lado do consumo.
cl /EHsc /std:c++17 m.ixx /experimental:module

cl /experimental:module /module:reference m.ifc main.cpp /std:c++14
O compilador gera C5050 para ambos os casos:
warning C5050: Possible incompatible environment while

importing module 'm': mismatched C++ versions.
Current "201402" module version "201703".
O compilador também gera C7536 sempre que o .ifc arquivo tiver sido adulterado. O cabeçalho da interface
do módulo contém um hash SHA2 do conteúdo abaixo dele. Na importação, o .ifc arquivo é submetido a
hash e, em seguida, verificado em relação ao hash fornecido no cabeçalho. Se eles não corresponderem, o erro
C7536 será gerado:
error C7536: ifc failed integrity checks.

Expected SHA2: '66d5c8154df0c71d4cab7665bab4a125c7ce5cb9a401a4d8b461b706ddd771c6'
Ordenação parcial envolvendo aliases e contextos não deduzidos

As implementações divergem nas regras de ordenação parciais que envolvem aliases em contextos não
deduzidos. no exemplo a seguir, GCC e o compilador do Microsoft C++ (no /permissive- modo) geram um
erro, enquanto Clang aceita o código.
#include <utility>
using size_t = std::size_t;

struct A {};
template <size_t, size_t>
struct AlignedBuffer {};
template <size_t len>
using AlignedStorage = AlignedBuffer<len, 4>;
template <class T, class Alloc>

int f(Alloc &alloc, const AlignedStorage<T::size> &buffer)
{
return 1;
}

int f(A<Alloc> &alloc, const AlignedStorage<T::size> &buffer)
{
return 2;
}
struct Alloc
{
static constexpr size_t size = 10;
};
int main()
{
A<void> a;
AlignedStorage<Alloc::size> buf;
if (f<Alloc>(a, buf) != 2)
{
return 1;
}
return 0;
}
O exemplo anterior gera C2668:

partial_alias.cpp(32): error C2668: 'f': ambiguous call to overloaded function
partial_alias.cpp(18): note: could be 'int f<Alloc,void>(A<void> &,const AlignedBuffer<10,4> &)'
partial_alias.cpp(12): note: or 'int f<Alloc,A<void>>(Alloc &,const AlignedBuffer<10,4> &)'
with
[
Alloc=A<void>
]
partial_alias.cpp(32): note: while trying to match the argument list '(A<void>, AlignedBuffer<10,4>)'
A divergência de implementação se deve a uma regressão na expressão do padrão C++. A resolução para
edição de núcleo de 2235 removeu algum texto que permitiria que essas sobrecargas fossem ordenadas. O
padrão C++ atual não fornece um mecanismo para ordenar parcialmente essas funções, portanto, elas são
consideradas ambíguas.
Como solução alternativa, é recomendável não depender de ordenação parcial para resolver esse problema. Em
vez disso, use SFINAE para remover sobrecargas específicas. No exemplo a seguir, usamos uma classe auxiliar
IsA para remover a primeira sobrecarga quando Alloc é uma especialização de A :
#include <utility>
using size_t = std::size_t;

struct A {};
template <size_t, size_t>
struct AlignedBuffer {};
template <size_t len>
using AlignedStorage = AlignedBuffer<len, 4>;
template <typename T> struct IsA : std::false_type {};

template <typename T> struct IsA<A<T>> : std::true_type {};
template <class T, class Alloc, typename = std::enable_if_t<!IsA<Alloc>::value>>

int f(Alloc &alloc, const AlignedStorage<T::size> &buffer)
{
return 1;
}

int f(A<Alloc> &alloc, const AlignedStorage<T::size> &buffer)
{
return 2;
}
struct Alloc
{
static constexpr size_t size = 10;
};
int main()
{
A<void> a;
AlignedStorage<Alloc::size> buf;
if (f<Alloc>(a, buf) != 2)
{
return 1;
}
return 0;
}
Expressões ilegais e tipos não literais em definições de função com modelo

Expressões ilegais e tipos não literais agora são diagnosticados corretamente nas definições de funções com
modelo especializadas explicitamente. Anteriormente, esses erros não eram emitidos para a definição da função.
No entanto, o tipo não literal ou a expressão ilegal ainda teria sido diagnosticado se avaliado como parte de
uma expressão de constante.
Em versões anteriores do Visual Studio, o seguinte código é compilado sem aviso:
void g();
struct S
{
constexpr void f();
};
template<>
constexpr void S<int>::f()
{
g(); // C3615 in 15.9
}
no Visual Studio 2017 versão 15,9, o código gera o erro C3615:
error C3615: constexpr function 'S<int>::f' cannot result in a constant expression.

note: failure was caused by call of undefined function or one not declared 'constexpr'
note: see usage of 'g'.
Para evitar o erro, remova o constexpr qualificador da instanciação explícita da função f() .
Confira também
Visual Studio versão
A conformidade com padrões para o compilador C/C++ da Microsoft Visual Studio (MSVC) é um trabalho em
andamento. Aqui está um resumo de nossa linguagem C e C++ Padrão ISO e conformidade com a biblioteca
por Visual Studio versão. Cada compilador C++ e o nome do recurso de biblioteca padrão são links para o
documento de proposta do ISO Standard C++ que descreve o recurso, se um estiver disponível no momento da
publicação. A coluna Com suporte lista a Visual Studio na qual o suporte para o recurso apareceu pela
primeira vez.
Para obter detalhes sobre melhorias de conformidade, consulte Melhorias de conformidade do C++ no Visual
Studio. Para ver uma lista de outras alterações, confira Novidades do Visual C++ no Visual Studio. Para
alterações de compatibilidade em versões anteriores, consulte Histórico de alterações do Visual C++ e
Novidades do Visual C++ de 2003 a 2015. Para saber mais sobre as últimas notícias da equipe do C++, visite o
blog da equipe do C++.
NOTE
Não há alterações da falha do binário entre o Visual Studio 2015, Visual Studio 2017 e Visual Studio 2019. Para obter mais
informações, consulte Compatibilidade binária do C++ entre Visual Studio 2015, 2017 e 2019
Recursos do compilador C++

REC URSO C O M SUP O RT E
Recursos de linguagem principal do C++03/11 Com supor te
Todo o resto VS 2015 A
Pesquisa de nome de duas fases VS 2017 15.7 B
N2634 Expression SFINAE VS 2017 15.7
N1653 C99 preprocessor VS 2019 16.6 C
Recursos da linguagem C++14 Core Com supor te
N3323 Tweaked wording for contextual conversions VS 2013
N3472 Binary literals VS 2015
N3638 auto and decltype(auto) return types VS 2015
N3648 init-captures VS 2015
N3649 Generic lambdas VS 2015

N3760 [[deprecated]] attribute VS 2015
N3778 Sized deallocation VS 2015
N3781 Digit separators VS 2015
N3651 Variable templates VS 2015.2
N3652 Extended constexpr VS 2017 15.0
N3653 Default member initializers for aggregates VS 2017 15.0
N4086 Removing trigraphs VS 2010 14
N3922 New rules for auto with braced-init-lists VS 2015 14
N4051 typename in template template-parameters VS 2015 14
N4266 Attributes for namespaces and enumerators VS 2015 14
N4267 u8 character literals VS 2015 14
N4230 Nested namespace definitions VS 2015.3 17
N3928 Terse static_assert VS 2017 15.0 17
P0184R0 Generalized range-based for-loops VS 2017 15.0 14
P0188R1 [[fallthrough]] attribute VS 2017 15.0 17
P0001R1 Removing the register keyword VS 2017 15.3 17
P0002R1 Removing operator++ for bool VS 2017 15.3 17
P0018R3 Capturing *this by value VS 2017 15.3 17
VS 2017 15.3 17
P0028R4 Using attribute namespaces without
repetition
P0061R1 __has_include VS 2017 15.3 14
VS 2017 15.3 17
P0138R2 Direct-list-init of fixed enums from
integers
P0170R1 constexpr lambdas VS 2017 15.3 17

P0189R1 [[nodiscard]] attribute VS 2017 15.3 17
P0212R1 [[maybe_unused]] attribute VS 2017 15.3 17
P0217R3 Structured bindings VS 2017 15.3 17
P0292R2 constexpr if-statements VS 2017 15.3 D
P0305R1 Selection statements with initializers VS 2017 15.3 17
P1381R1 Reference capture of structured bindings VS 2017 15.3 17
P0245R1 Hexfloat literals VS 2017 15.5 17
N4268 Allowing more non-type template args VS 2017 15.5 17
N4295 Fold expressions VS 2017 15.5 17
P0003R5 Removing dynamic-exception-specifications VS 2017 15.5 17
P0012R1 Adding noexcept to the type system VS 2017 15.5 17
P0035R4 Over-aligned dynamic memory allocation VS 2017 15.5 17
P0386R2 Inline variables VS 2017 15.5 17
VS 2017 15.5 17
P0522R0 Matching template template-parameters to
compatible arguments
P0036R0 Removing some empty unary folds VS 2017 15.5 17
N4261 Fixing qualification conversions VS 2017 15.7 17
P0017R1 Extended aggregate initialization VS 2017 15.7 17
VS 2017 15.7 17
P0091R3 Template argument deduction for class
templates
P0512R0 Class template argument deduction issues
VS 2017 15.7 17
P0127R2 Declaring non-type template parameters with
auto
P0135R1 Guaranteed copy elision VS 2017 15.6
P0136R1 Rewording inheriting constructors VS 2017 15.7 17
P0137R1 std::launder VS 2017 15.7 17

P0145R3 Refining expression evaluation order VS 2017 15.7 17

P0400R0 Order of evaluation of function arguments
P0195R2 Pack expansions in using-declarations VS 2017 15.7 17
P0283R2 Ignoring unrecognized attributes VS 2015 14
Recursos da linguagem C++17 Core (relatórios de Com supor te

defeito)
VS 2017 15.7 17
P0702R1 Fixing class template argument deduction
for initializer-list ctors
VS 2019 16.0 17
P0961R1 Relaxing the structured bindings
customization point finding rules
VS 2019 16.0 17
P0969R0 Allowing structured bindings to accessible
members
P0588R1 Simplifying implicit lambda capture VS 2019 16.4 17
P1771R1 [[nodiscard]] for constructors VS 2019 16.4 17
VS 2019 16.4 17
P1825R0 Merged wording for P0527R1 and P1155R3,
more implicit moves
P0929R2 Checking for abstract class types VS 2019 16.5 17
VS 2019 16.5 17
P0962R1 Relaxing the range-for loop customization
point finding rules
Parcial no VS 2019 16.7 E

P0859R0 CWG 1581: When are constexpr member
functions defined
P1009R2 Array size deduction in new-expressions VS 2019 16.7 17
P1286R2 Contra CWG DR1778 VS 2019 16.8 17
VS 2015 14
P0641R2 const mismatch with defaulted copy
constructor
VS 2015 14
P0704R1 Fixing const lvalue ref-qualified pointers
to members
VS 2015 14
P1041R4 Make char16_t/char32_t string literals be
UTF-16/32
VS 2017 15.0 14
P1330R0 Changing the active member of a union
inside constexpr
VS 2017 15.7 14
P0972R0 noexcept For <chrono> zero(), min(), max()
VS 2019 16.0 20
P0515R3 Three-way (spaceship) comparison operator
<=>
P0941R2 Feature-test macros VS 2019 16.0 14
VS 2019 16.0 20
P1008R1 Prohibiting aggregates with user-declared
constructors
P0329R4 Designated initialization VS 2019 16.1 20
VS 2019 16.1 20
P0846R0 ADL and function templates that are not
visible
P0409R2 Allowing lambda-capture [=, this] VS 2019 16,2 20
VS 2019 16,2 20
P0428R2 Familiar template syntax for generic
lambdas
VS 2019 16,2 20
P0624R2 Default constructible and assignable
stateless lambdas
VS 2019 16,2 20
P0780R2 Allowing pack expansion in lambda init-
capture
VS 2019 16,2 20
P0806R2 Deprecate implicit capture of this via [=]
VS 2019 16,2 20
P1120R0 Consistency improvements for <=> and other
comparison operators
P1185R2 <=> != == VS 2019 16,2 20
P0734R0 Concepts VS 2019 16,3 20
P0857R0 Fixing functionality gaps in constraints VS 2019 16,3 20

VS 2019 16,3 20
P1084R2 Today's return-type-requirements are
insufficient
P0892R2 Conditional explicit VS 2019 16,4 20
VS 2019 16,4 20
P1091R3 Extending structured bindings to be more
like variable declarations
P1099R5 Using enum VS 2019 16,4 20
P1186R3 When do you actually use <=> VS 2019 16,4 20
P1630R1 Spaceship needs a tune-up VS 2019 16,4 20
VS 2019 16,5 20
P0306R4 Adding __VA_OPT__ for comma omission and
comma deletion
P0614R1 Range-based for-loops with initializers VS 2019 16,5 20
VS 2019 16,5 20
P0683R1 Default member initializers for bit-fields
P1002R1 try-catch blocks in constexpr functions VS 2019 16,5 20
VS 2019 16,5 20
P1161R3 Deprecate uses of the comma operator in
subscripting expressions
P1301R4 [[nodiscard("message")]] VS 2019 16,5 20
VS 2019 16,5 20
P1703R1 Recognizing header unit imports requires
full preprocessing
P1946R0 Allow defaulting comparisons by value VS 2019 16,5 20
P0479R5 [[likely]] and [[unlikely]] attributes VS 2019 16,6 20
VS 2019 16,6 14
P0692R1 Relaxing access checking on specializations
VS 2019 16,6 20
P0732R2 Class types in non-type template parameters
VS 2019 16,6 14
P1139R2 Address wording issues related to ISO 10646
VS 2019 16,6 20
P1907R1 Inconsistencies with non-type template
parameters
VS 2019 16,6 20
P1971R0 US053: Mandate the return type for
return_void and return_value to be void
VS 2019 16,6 20
P1971R0 US065: Apply Coroutines issue 24 from
P0664R8
P1979R0 Resolution to US086 VS 2019 16,6 20
VS 2019 16,7 20
P0388R4 Permit conversions to arrays of unknown
bound
VS 2019 16,7 20
P0466R5 Layout-compatibility and Pointer-
interconvertibility Traits
VS 2019 16,7 20
P0722R3 Efficient sized delete for variable sized
classes
P1094R2 Nested inline namespaces VS 2019 16,7 20
P1152R4 Deprecating volatile VS 2019 16,7 20
VS 2019 16,7 20
P1331R2 Permitting trivial default initialization
in constexpr contexts
VS 2019 16,7 20
P1358R0 2310: Type completeness and derived-to-base
pointer conversions
VS 2019 16,7 20
P1452R2 On the non-uniform semantics of return-
type-requirements
VS 2019 16,7 20
P1616R1 Using unconstrained TTPs with constrained
templates
P1814R0 CTAD for alias templates VS 2019 16,7 20
P1816R0 CTAD for aggregates VS 2019 16,7 20
VS 2019 16,7 Dr
P1957R1 Converting from T* to bool should be
considered narrowing (re: US 212)
VS 2019 16,7 20
P1968R0 CWG 2282: Consistency with mismatched
aligned/non-over-aligned allocation/deallocation
functions
VS 2019 16,7 20
P1969R0 CWG 2280: Matching a usual deallocation
function with placement new
VS 2019 16,7 20
P1969R0 CWG 2382: Array allocation overhead for
non-allocating placement new
P1969R0 CWG 2441: Inline function parameters VS 2019 16,7 20
VS 2019 16,7 20
P1971R0 US052: Non-executed return statements in
coroutines
VS 2019 16,7 20
P1972R0 US105: Check satisfaction of constraints
for non-templates when forming pointer to function
VS 2019 16,7 20
P1980R0 CA096: Declaration matching for non-
dependent requires-clauses
P2082R1 Fixing CTAD for aggregates VS 2019 16,7 20
P2085R0 Consistent defaulted comparisons VS 2019 16,7 20
VS 2019 16,7 20
P2103R0 US033: Allow "import" inside linkage-
specifications
VS 2019 16,7 20
P2107R0 US064: Copy semantics of coroutine
parameters
P0912R5 Coroutines VS 2019 16,8 20
P1103R3 Modules VS 2019 16,8 20
P0315R4 Allowing lambdas in unevaluated contexts VS 2019 16,8 20
VS 2019 16,8 20
P0848R3 Conditionally trivial special member
functions
VS 2019 16,8 20
P0960R3 Allow initializing aggregates from a
parenthesized list of values
P1766R1 Mitigating minor modules maladies VS 2019 16,8 20
VS 2019 16,8 20
P1811R0 Relaxing redefinition restrictions for re-
exportation robustness
VS 2019 16,8 20
P1874R1 Dynamic Initialization Order of Non-Local
Variables in Modules
VS 2019 16,8 20
P1975R0 Fixing the wording of parenthesized
aggregate-initialization
P0634R3 Down with typename! VS 2019 16,9 20
P0784R7 More constexpr containers VS 2019 16,9 20
P0840R2 [[no_unique_address]] attribute VS 2019 16,9 20
VS 2019 16,9 20
P1064R0 Allowing virtual function calls in constant
expressions
VS 2019 16,9 20
P1141R2 Yet another approach for constrained
declarations
VS 2019 16,9 20
P1327R1 Allowing dynamic_cast, polymorphic typeid
in constant expressions
VS 2019 16,9 20
P1668R1 Permitting unevaluated inline assembly in
constexpr functions
P1073R3 Immediate functions VS 2019 16,10 20
P1143R2 constinit VS 2019 16,10 20
P1353R0 Missing feature-test macros VS 2019 16,10 20
N/D
P0735R1 Interaction of memory_order_consume with
release sequences
P1236R1 Signed integers are two's complement N/D
Recursos de biblioteca padrão do C++

uma lista mais detalhada de recursos de biblioteca padrão e correções de bugs por versão do produto está
disponível na página de Changelog do GitHub Microsoft STL wiki .
Recursos de biblioteca padrão do c++ 14 Com supor te
N3462 SFINAE-Friendly result_of VS 2015.2

N3302 constexpr For <complex> VS 2015
N3469 constexpr For <chrono> VS 2015
N3470 constexpr For <array> VS 2015
VS 2015
N3471 constexpr For <initializer_list>, <tuple>,
<utility>
N3545 integral_constant::operator()() VS 2015
VS 2015
N3642 UDLs For <chrono>, <string> (1729ms, "meow"s,
etc.)
N3644 Null Forward Iterators VS 2015
N3654 quoted() VS 2015
N3657 Heterogeneous Associative Lookup VS 2015
N3658 integer_sequence VS 2015
N3659 shared_mutex (Timed) VS 2015
N3668 exchange() VS 2015
VS 2015
N3669 Fixing constexpr Member Functions Without
const
N3670 get<T>() VS 2015
VS 2015
N3671 Dual-Range equal(), is_permutation(),
mismatch()
N3778 Sized Deallocation VS 2015
N3779 UDLs For <complex> (3.14i, etc.) VS 2015
N3789 constexpr For <functional> VS 2015
N3887 tuple_element_t VS 2015
VS 2015
N3891 Renaming shared_mutex (Timed) To
shared_timed_mutex
N3346 Minimal Container Element Requirements VS 2013

VS 2013
N3421 Transparent Operator Functors (less<>, etc.)
VS 2013
N3655 Alias Templates For <type_traits> (decay_t,
etc.)
N3656 make_unique() VS 2013
Recursos da biblioteca padrão do C++17 Com supor te
LWG 2221 Formatted output operator for nullptr VS 2019 16.1
N3911 void_t VS 2015 14
N4089 Safe Conversions In unique_ptr<T[]> VS 2015 14
N4169 invoke() VS 2015 14
VS 2015 F
N4190 Removing auto_ptr, random_shuffle(), And Old
<functional> Stuff
N4258 noexcept Cleanups VS 2015 14
N4259 uncaught_exceptions() VS 2015 14
N4277 Trivially Copyable reference_wrapper VS 2015 14
VS 2015 14
N4279 insert_or_assign()/try_emplace() For
map/unordered_map
N4280 size(), empty(), data() VS 2015 14
VS 2015 14
N4366 Precisely Constraining unique_ptr Assignment
N4387 Improving pair And tuple VS 2015.2 14
N4389 bool_constant VS 2015 14
N4508 shared_mutex (Untimed) VS 2015.2 14
VS 2013 14
N4510 Supporting Incomplete Types In
vector/list/forward_list
N4562 Library Fundamentals: <algorithm> sample() VS 2017 15.0
N4562 Library Fundamentals: <any> VS 2017 15.0

N4562 Library Fundamentals: <memory_resource> VS 2017 15.6

P0337R0 Deleting polymorphic_allocator Assignment
N4562 Library Fundamentals: <optional> VS 2017 15.0
N4562 Library Fundamentals: <string_view> VS 2017 15.0
N4562 Library Fundamentals: <tuple> apply() VS 2017 15.0
N4562 Library Fundamentals: Boyer-Moore search() VS 2017 15.3 17

P0253R1 Fixing Searcher Return Types
P0003R5 Removing Dynamic Exception Specifications VS 2017 15.5 17
P0004R1 Removing Deprecated Iostreams Aliases VS 2015.2 F
P0005R4 not_fn() VS 2017 15.5 17

P0358R1 Fixes For not_fn()
VS 2015.2 14
P0006R0 Variable Templates For Type Traits
(is_same_v, etc.)
P0007R1 as_const() VS 2015.2 14
VS 2015.2 14
P0013R1 Logical Operator Type Traits (conjunction,
etc.)
P0024R2 Parallel Algorithms VS 2017 15.7 G

P0336R1 Renaming Parallel Execution Policies
P0394R4 Parallel Algorithms Should terminate() For

Exceptions
P0452R1 Unifying <numeric> Parallel Algorithms
P0025R1 clamp() VS 2015.3
P0030R1 hypot(x, y, z) VS 2017 15.7
VS 2017 15.3 17
P0031R0 constexpr For <array> (Again) And
<iterator>
VS 2017 15.0
P0032R3 Homogeneous Interface For
variant/any/optional
P0033R1 Rewording enable_shared_from_this VS 2017 15.5 14
P0040R3 Extending Memory Management Tools VS 2017 15.3 17

P0063R3 C11 Standard Library VS 2015 C11, 14
P0067R5 Elementary String Conversions VS 2019 16.4
P0074R0 owner_less<> VS 2015.2 14
P0077R2 is_callable, is_nothrow_callable VS 2017 15.0
P0083R3 Splicing Maps And Sets VS 2017 15.5 17

P0508R0 Clarifying insert_return_type
P0084R2 Emplace Return Type VS 2017 15.3 17
P0088R3 <variant> VS 2017 15.0
P0092R1 <chrono> floor(), ceil(), round(), abs() VS 2015.2 14
P0152R1 atomic::is_always_lock_free VS 2017 15.3 17
VS 2017 15.3 17
P0154R1 hardware_destructive_interference_size,
etc.
P0156R0 Variadic lock_guard VS 2015.2 14
VS 2017 15.3 17
P0156R2 Renaming Variadic lock_guard to scoped_lock
P0163R0 shared_ptr::weak_type VS 2017 15.0
P0174R2 Deprecating Vestigial Library Parts VS 2017 15.5 17
P0185R1 is_swappable, is_nothrow_swappable VS 2015.3
P0209R2 make_from_tuple() VS 2017 15.0
P0218R1 <filesystem> VS 2017 15.7 H

P0219R1 Relative Paths For Filesystem
P0317R1 Directory Entry Caching For Filesystem
P0392R0 Supporting string_view In Filesystem Paths

P0430R2 Supporting Non-POSIX Filesystems
P0492R2 Resolving NB Comments for Filesystem
P0220R1 Library Fundamentals V1 VS 2017 15.6
P0226R1 Mathematical Special Functions VS 2017 15.7
P0254R2 Integrating string_view And std::string VS 2017 15.0

P0258R2 has_unique_object_representations VS 2017 15.3 I
P0272R1 Non-const basic_string::data() VS 2015.3
P0295R0 gcd(), lcm() VS 2017 15.3 17
P0298R3 std::byte VS 2017 15.3 17, J
VS 2017 15.5 17
P0302R1 Removing Allocator Support In std::function
P0307R2 Making Optional Greater Equal Again VS 2017 15.0
P0393R3 Making Variant Greater Equal VS 2017 15.0
P0403R1 UDLs For <string_view> ("meow"sv, etc.) VS 2017 15.3 17
P0414R2 shared_ptr<T[]>, shared_ptr<T[N]> VS 2017 15.5 14

P0497R0 Fixing shared_ptr For Arrays
VS 2017 15.3 14
P0418R2 atomic compare_exchange memory_order
Requirements
P0426R1 constexpr For char_traits VS 2017 15.7
VS 2017 15.7
P0433R2 Integrating template deduction for class
templates into the standard library
P0739R0 Improving class template argument deduction

integration into the standard library
P0435R1 Overhauling common_type VS 2017 15.3 14

P0548R1 Tweaking common_type and duration
VS 2017 15.0
P0504R0 Revisiting
in_place_t/in_place_type_t<T>/in_place_index_t<I>
P0505R0 constexpr For <chrono> (Again) VS 2017 15.3 17
VS 2017 15.0
P0510R0 Rejecting variants Of Nothing, Arrays,
References, And Incomplete Types
P0513R0 Poisoning hash VS 2017 15.3 14

P0599R1 noexcept hash
P0516R0 Marking shared_future Copying As noexcept VS 2017 15.3 14

VS 2017 15.3 14
P0517R0 Constructing future_error From future_errc
P0521R0 Deprecating shared_ptr::unique() VS 2017 15.5 17
VS 2017 15.3 14
P0558R1 Resolving atomic<T> Named Base Class
Inconsistencies
P0595R2 std::is_constant_evaluated() VS 2019 16.5 20
VS 2017 15.317
P0602R4 Propagating Copy/Move Triviality In
variant/optional
VS 2017 15.3 17
P0604R0 Changing is_callable/result_of To
invoke_result, is_invocable, is_nothrow_invocable
P0607R0 Inline Variables for the Standard Library VS 2017 15.5 17
P0618R0 Deprecating <codecvt> VS 2017 15.5 17
P0682R1 Repairing Elementary String Conversions VS 2015 15.7 17
Recursos da biblioteca padrão do C++20 Com supor te
P0809R0 Comparing Unordered Containers VS 2010 14
P0858R0 Constexpr Iterator Requirements VS 2017 15.3 17
P0777R1 Avoiding Unnecessary Decay VS 2017 15.7 14
P1164R1 Making create_directory() Intuitive VS 2019 16.0 20
P0550R2 remove_cvref VS 2019 16.0 20
P0318R1 unwrap_reference, unwrap_ref_decay VS 2019 16.1 20
VS 2019 16.1 20
P0457R2 starts_with()/ends_with() For
basic_string/basic_string_view
VS 2019 16.1 20
P0458R2 contains() For Ordered And Unordered
Associative Containers
VS 2019 16.1 20
P0646R1 list/forward_list
remove()/remove_if()/unique() Return size_type
P0769R2 shift_left(), shift_right() VS 2019 16.1 20

P0887R1 type_identity VS 2019 16.1 20
VS 2019 16.2 20
P0020R6 atomic<float>, atomic<double>, atomic<long
double>
P0463R1 endian VS 2019 16.2 20
VS 2019 16.2 20
P0482R6 char8_t: A type for UTF-8 characters and
strings
P0600R1 [[nodiscard]] For The STL, Part 1 VS 2019 16.2 20
P0653R2 to_address() VS 2019 16.2 20
P0754R2 <version> VS 2019 16.2 20
VS 2019 16.2 20
P0771R1 noexcept For std::function's Move
Constructor
P0487R1 Fixing operator>>(basic_istream&, CharT*) VS 2019 16.3 20
P0616R0 Using move() In <numeric> VS 2019 16.3 20
P0758R1 is_nothrow_convertible VS 2019 16.3 20
P0898R3 Standard Library Concepts VS 2019 16.3 20
VS 2019 16.3 20
P0919R3 Heterogeneous Lookup For Unordered
Containers
P1754R1 Rename Concepts to standard_case VS 2019 16.4 20
P0325R4 to_array from LFTS with updates VS 2019 16.5 20
P0340R3 SFINAE-Friendly underlying_type VS 2019 16.5 14
P0356R5 bind_front() VS 2019 16.5 20
P0439R0 enum class memory_order VS 2019 16.5 20
P0553R4 <bit> Rotating And Counting Functions VS 2019 16.5 20
VS 2019 16.5 20
P0556R3 <bit> ispow2(), ceil2(), floor2(), log2p1()
P0595R2 is_constant_evaluated() VS 2019 16.5 20

P0631R8 <numbers> Math Constants VS 2019 16.5 20
P0655R1 visit<R>() VS 2019 16.5 20
P0738R2 istream_iterator Cleanup VS 2019 16.5 14
P0767R1 Deprecating is_pod VS 2019 16.5 20
P0966R1 string::reserve() Should Not Shrink VS 2019 16.5 20
P1209R0 erase_if(), erase() VS 2019 16.5 20
VS 2019 16.5 20
P1227R2 Signed std::ssize(), Unsigned span::size()
P1355R2 Narrow Contract For ceil2() VS 2019 16.5 20
P1357R1 is_bounded_array, is_unbounded_array VS 2019 16.5 20
P1612R1 Relocating endian To <bit> VS 2019 16.5 20
VS 2019 16.5 20
P1651R0 bind_front() Should Not Unwrap
reference_wrapper
VS 2019 16.5 20
P1690R1 Refining Heterogeneous Lookup For Unordered
Containers
P1902R1 Missing Feature-Test Macros 2017-2019 VS 2019 16.5 14
P0122R7 <span> VS 2019 16.6 20

P1024R3 Enhancing span usability
P1085R2 Removing span comparisons
P1394R4 Range constructor for span
P1872R0 span should have size_type, not index_type
P0202R3 constexpr for <algorithm> and exchange() VS 2019 16.6 20
VS 2019 16.6 20
P0357R3 Supporting Incomplete Types In
reference_wrapper
VS 2019 16.6 20
P0619R4 Removing C++17-Deprecated Features In C++20
P0879R0 constexpr for swapping functions VS 2019 16.6 20
P0883R2 Fixing atomic initialization VS 2019 16.6 14

VS 2019 16.6 14
P0935R0 Eradicating Unnecessarily Explicit Default
Constructors
VS 2019 16.6 20
P1006R1 constexpr For
pointer_traits<T*>::pointer_to()
VS 2019 16.6 14
P1165R1 Consistently Propagating Stateful
Allocators In basic_string's operator+()
VS 2019 16.6 20
P1423R3 char8_t backward compatibility remediation
P1645R1 constexpr for <numeric> algorithms VS 2019 16.6 20
P0415R1 constexpr For <complex> (Again) VS 2019 16.7 20
P0476R2 <bit> bit_cast VS 2019 16.7 20
VS 2019 16.7 20
P0528R3 Atomic Compare-And-Exchange With Padding
Bits
P0586R2 Integer comparison functions VS 2019 16.7 20
P0674R1 make_shared() For Arrays VS 2019 16.7 20
VS 2019 16.7 20
P0718R2 atomic<shared_ptr<T>>, atomic<weak_ptr<T>>
P1023R0 constexpr For std::array Comparisons VS 2019 16.7 20
P1115R3 erase()/erase_if() Return size_type VS 2019 16.7 20
VS 2019 16.7 20
P1831R1 Deprecating volatile in the standard
library
VS 2019 16.7 20
P1871R1 Concept traits should be named after
concepts
VS 2019 16.7 20
P1956R1 <bit> has_single_bit(), bit_ceil(),
bit_floor(), bit_width()
P1964R2 Replacing boolean With boolean-testable VS 2019 16.7 20
VS 2019 16.7 20
P1976R2 Fixed-size span construction from dynamic
range
P2091R0 Issues with range access CPOs VS 2019 16.7 20
VS 2019 16.7 20
P2102R0 Make "implicit expression variations" more
explicit
VS 2019 16.7 20
P2116R0 Remove tuple-like protocol support from
fixed-extent span
P0019R8 atomic_ref VS 2019 16.8 20
VS 2019 16.8 20
P0528R3 Library support for atomic compare-and-
exchange with padding bits
P0811R3 midpoint(), lerp() VS 2019 16.8 20
P0912R5 Library Support For Coroutines VS 2019 16.8 20
P1001R2 execution::unseq VS 2019 16.8 20
P1032R1 Miscellaneous constexpr VS 2019 16.8 20
P1065R2 constexpr INVOKE VS 2019 16.8 20
VS 2019 16.8 20
P1123R0 Editorial Guidance for merging P0019r8 and
P0528r3
P1960R0 NB Comment Changes Reviewed by SG1 VS 2019 16.8 20
P0339R6 polymorphic_allocator<> VS 2019 16.9 20
P0660R10 <stop_token> and jthread VS 2019 16.9 20
VS 2019 16.9 20
P0768R1 Library Support For The Spaceship
Comparison Operator <=>
P1007R3 assume_aligned() VS 2019 16.9 20
VS 2019 16.9 20
P1020R1 Smart Pointer Creation With Default
Initialization
P1135R6 The C++20 Synchronization Library VS 2019 16.9 20
VS 2019 16.9 20
P1771R1 Library support for [[nodiscard]] for
constructors
P0053R7 <syncstream> VS 2019 16.10 20

P0753R2 osyncstream Manipulators
P0355R7 <chrono> Calendars And Time Zones VS 2019 16.10 20
VS 2019 16.10 20
P0408R7 Efficient access To basic_stringbuf's
buffer
VS 2019 16.10 20
P0466R5 Library support for layout-compatibility
and pointer-interconvertibility traits
VS 2019 16.10 20
P0475R1 Guaranteed Copy Elision For Piecewise
Construction
VS 2019 16.10 20
P0591R4 Utility Functions For Uses-Allocator
Construction
VS 2019 16.10 20
P0608R3 Improving variant's Converting
Constructor/Assignment
P0645R10 <format> Text Formatting VS 2019 16.10 20
VS 2019 16.10 20
P0784R7 Library support for more constexpr
containers
P0896R4 <ranges> VS 2019 16.10 20
P0980R1 constexpr std::string VS 2019 16.10 20
P1004R2 constexpr std::vector VS 2019 16.10 20
P1208R6 <source_location> VS 2019 16.10 20
P1502R1 Standard Library Header Units VS 2019 16.10 20
P1614R2 Adding Spaceship <=> To The Library VS 2019 16.10 20
N/D
P1285R0 Improving Completeness Requirements For
Type Traits
Recursos da biblioteca standard do c++ 23 Com supor te
P0881R7 <stacktrace> Não
P0943R6 Supporting C Atomics In C++ Não

P1048R1 is_scoped_enum Não
Não
P1679R3 contains() For
basic_string/basic_string_view
P1682R3 to_underlying() For Enumerations Não
P2162R2 Inheriting From variant Não
Um grupo de documentos listados em conjunto indica um recurso padrão junto com uma ou mais melhorias ou
expansões aprovadas. Esses recursos são implementados juntos.
Recursos da biblioteca padrão C

Recursos de biblioteca padrão do C99 Com supor te
Macros de ortografia alternativas <iso646.h> VS 2015
Suporte a caracteres largos <wchar.h> e <wctype.h> VS 2015
Suporte complexo no <complex.h> Parcial em VS 2015 K
Digite funções matemáticas genéricas <tgmath.h> VS 2019 16,8 2104
Características de ponto flutuante adicionais <float.h> VS 2015
Especificadores de flutuante de float hexadecimal %A , VS 2015

%a
Tipos de inteiros estendidos <inttypes.h> , VS 2015

<stdint.h>
vscanf família <stdio.h> e <wchar.h> VS 2015
Novas funções matemáticas no <math.h> VS 2015
Tratamento de condições de erro da biblioteca matemática VS 2015

( math_errhandling )
Acesso ao ambiente de ponto flutuante <fenv.h> VS 2015
%lf especificador de conversão para printf VS 2015
snprintf família de funções no <stdio.h> VS 2015
boolean Digite <stdbool.h> VS 2015

va_copy Ela VS 2015
strftime Especificadores de conversão adicionais Parcial em VS 2015 L
Recursos de biblioteca padrão do C11 Com supor te
Especificadores de alinhamento <stdalign.h> VS 2019 16,8 C11, 2104
aligned_alloc Sem M
Nenhum especificador de retorno <stdnoreturn.h> VS 2019 16,8 C11, 2104
Suporte a Threading <threads.h> Não
Suporte Atomic <stdatomic.h> Não
char16_t , char32_t <uchar.h> VS 2019 16,8 C11
gets() removido VS 2019 16,8 C11, N
gets_s() VS 2019 16,8 C11
Limites-verificando interfaces ( *_s APIs) Parcial em VS 2015 C11, O
fopen``"x" opção VS 2019 16,8 C11
Asserções estáticas VS 2019 16,8 C11, 2104
quick_exit VS 2019 16,8 C11
<complex.h> macros VS 2019 16,8 C11
características de ponto flutuante <float.h> VS 2019 16,8 C11
Valores com suporte

Não Ainda não implementado.
Parcial A implementação está incompleta. Para obter mais informações, consulte a seção observações .
VS 2010 com suporte no Visual Studio 2010.
VS 2013 Com suporte no Visual Studio 2013.
VS 2015 com suporte no Visual Studio 2015 (RTW).
vs 2015,2 e vs 2015,3 indicam recursos com suporte no Visual Studio 2015 atualização 2 e Visual Studio
2015 atualização 3, respectivamente.
VS 2017 15,0 com suporte no Visual Studio 2017 versão 15,0 (RTW).
VS 2017 15,3 com suporte no Visual Studio 2017 versão 15,3.
VS 2019 16,0 com suporte no Visual Studio 2019 versão 16,0 (RTW).
VS 2019 16,10 com suporte na versão 16,10 do Visual Studio 2019.
Observações
R no /std:c++14 modo, as especificações de exceção dinâmicas permanecem inimplementadas e throw()
ainda são tratadas como um sinônimo para __declspec(nothrow) . No C++ 17, as especificações de exceção
dinâmicas foram, na maioria, removidas pelo P0003R5, deixando um vestige: throw() é preterido e necessário
se comportar como um sinônimo para noexcept . no /std:c++17 modo, MSVC agora está em conformidade
com o padrão, dando throw() o mesmo comportamento que noexcept , ou seja, imposição por demissão.
A opção do /Zc:noexceptTypes compilador solicita nosso comportamento antigo de __declspec(nothrow) . É
provável que seja throw() removido em uma versão futura do C++. Para ajudar com a migração de código em
resposta a essas alterações no Padrão e em nossa implementação, novos avisos do compilador para problemas
de especificação de exceção foram adicionados em /std:c++17 e /permissive- .
B Com suporte no /permissive- modo no Visual Studio 2017 versão 15.7. Para obter mais informações,
consulte Suporte à pesquisa de nome de duas fases é MSVC.
C A partir Visual Studio versão 16.6 de 2019, o compilador implementa totalmente o pré-processador C99 por
meio da /Zc:preprocessor opção . (Antes da versão 16.6, a partir do Visual Studio 2017 versão 15.8, o
compilador dá suporte ao pré-processador C99 por meio da opção /experimental:preprocessor do compilador.)
Essa opção está em por padrão quando a opção do /std:c11 compilador /std:c17 ou é especificada.
D Com suporte em /std:c++14 com um aviso supressível, C4984 .
E A implementação é suficiente para dar suporte à Biblioteca Padrão do C++20. Uma implementação completa
requer uma alteração de quebra binária.
F Recursos removidos quando /std:c++17 a opção do compilador ou posterior é especificada. Para reabilitar
esses recursos (para facilitar a transição para modos de linguagem mais novos), use estas macros:
_HAS_AUTO_PTR_ETC _HAS_FUNCTION_ALLOCATOR_SUPPORT , , e _HAS_OLD_IOSTREAMS_MEMBERS _HAS_UNEXPECTED .
A biblioteca de algoritmos paralelos do G C++17 está concluída. Concluído não significa que cada algoritmo é
paralelizado em todos os casos. Os algoritmos mais importantes foram paralelizados e as assinaturas de política
de execução são fornecidas mesmo quando não paralelizamos algoritmos. O header interno central da nossa
implementação, , contém as seguintes "Notas de Algoritmos Paralelos": O C++ permite que uma
implementação implemente algoritmos paralelos como chamadas para os <yvals_core.h> algoritmos seriais.
Essa implementação paraleliza várias chamadas de algoritmo comum, mas não todas.
Os seguintes algoritmos são paralelizados:
adjacent_difference , adjacent_find , all_of , any_of , count ,
, equal , exclusive_scan , find ,
count_if
find_end , find_first_of , find_if , find_if_not , for_each , for_each_n , inclusive_scan , is_heap ,
is_heap_until , is_partitioned , is_sorted , is_sorted_until , mismatch , none_of , partition , reduce ,
remove , remove_if , replace , replace_if , search , search_n , set_difference , set_intersection , sort ,
stable_sort , transform , transform_exclusive_scan , transform_inclusive_scan , transform_reduce
Atualmente, esses algoritmos não são paralelizados:

Esses algoritmos não mostram nenhuma melhoria de desempenho de paralelismo perceptível no hardware
de destino. Todos os algoritmos que simplesmente copiam ou permutam elementos sem branches
normalmente são limitados por largura de banda de memória:
copy , copy_n , fill , fill_n , move , reverse , reverse_copy , rotate , rotate_copy , shift_left ,
shift_right , swap_ranges
Há confusão sobre os requisitos de paralelismo do usuário para esses algoritmos, que provavelmente estão
na categoria acima:
generate , generate_n
O paralelismo efetivo desses algoritmos pode ser inviável:
partial_sort , partial_sort_copy
Esses algoritmos ainda não foram avaliados. Podemos implementar o paralelismo em uma versão futura:
copy_if , includes , inplace_merge , lexicographical_compare , max_element , merge , min_element ,
minmax_element , nth_element , partition_copy , remove_copy , remove_copy_if , replace_copy ,
replace_copy_if , set_symmetric_difference , set_union , stable_partition , unique , unique_copy
H Essa é uma implementação totalmente nova, incompatível com a versão anterior, necessária para o suporte a
symlink, correções de bugs e alterações no comportamento std::experimental exigido pelo padrão.
Atualmente, <filesystem> fornece o novo std::filesystem e o std::experimental::filesystem anterior. O
<experimental/filesystem> header fornece apenas a implementação experimental antiga. A implementação
experimental será removida na próxima versão de quebra de ABI das bibliotecas.
Eu suportei por um intrínseco do compilador.
O J é habilitado pelo ou posterior, mas como ele pode entrar em conflito com os Windows std::byte SDK em
alguns casos, ele tem uma macro de aceitação /std:c++17 fina. Para desabilitá-lo, defina _HAS_STD_BYTE como
0 .
K MSVC não dá suporte à _Complex palavra-chave ou tipos complexos nativos. O CRT Universal <complex.h>
usa macros específicas da implementação para obter o mesmo efeito. Para obter mais informações, consulte
Suporte matemático complexo em C.
L O CRT Universal não implementa os modificadores de conversão strftime E alternativa e O . Esses
modificadores são ignorados (por exemplo, %Oe comporta-se da mesma forma que %e ). Não há suporte para
os modificadores nas APIs de localidade subjacentes.
M O CRT Universal não implementa C11, aligned_alloc mas fornece e _aligned_malloc _aligned_free . Como
o Windows sistema operacional não dá suporte a alocações alinhadas, é improvável que essa função seja
implementada.
N A declaração é removida, mas a exportação para a função permanece para compatibilidade com backward.
O Determinadas funções de verificação de limites não são simplificadas ou têm assinaturas diferentes ou não
fazem parte do padrão C11 ou C17. Essas funções não são simplificadas: abort_handler_s , , , , , , , ,
ignore_handler_s memset_s set_constraint_handler_s snprintf_s snwprintf_s strerrorlen_s vsnwprintf_s .
Essas funções têm assinaturas diferentes: gmtime_s , , , , , localtime_s qsort_s strtok_s vsnprintf_s
wcstok_s . Essas funções não aparecem no padrão: clearerr_s , fread_s .
14 Esses recursos do C++17 e do C++20 estão sempre habilitados, mesmo quando /std:c++14 (o padrão) é
especificado. O motivo é porque o recurso foi implementado antes da introdução das opções ou porque a
implementação condicional era /std indevidamente complexa.
17 Esses recursos são habilitados pela opção /std:c++17 do compilador (ou /std:c++latest ).
20 Em versões Visual Studio 2019 versão 16.10, esses recursos são habilitados pela opção /std:c++latest do
compilador. Quando a implementação do C++20 for concluída, adicionaremos uma nova opção /std:c++20 de
compilador para habilitar esses recursos.
DR Esses recursos estão habilitados em todos os modos de opção /std do compilador C++. O comitê C++
Standard aprovou essa alteração como um Relatório de Defeito retroativo para C++11 e todas as versões
posteriores.
C11 O suporte do compilador para C11 e C17 requer Visual Studio 2019 versão 16.8 ou superior. Com exceção
do que foi marcado, o suporte à biblioteca C11 e C17 requer Windows 10 build do SDK 10.0.20211.0 ou
superior. Para obter mais informações sobre como instalar o suporte para C11 e C17, consulte Install C11 and
C17 support in Visual Studio.
O suporte à biblioteca 2104 C11 para esse recurso requer Windows 10 build do SDK 10.0.20348.0 (versão
2104) ou superior.
Confira também
Biblioteca Padrão do C++
Melhorias de conformidade do C++ Visual Studio
Novidades do Visual C++ em Visual Studio
Visual C++ histórico de alterações de 2003 a 2015
Visual C++ novidades de 2003 a 2015
Blog da equipe do C++
Plataformas com suporte (Visual C++)
Os aplicativos criados com o Visual Studio podem ser direcionados a várias plataformas, como as seguintes.
SIST EM A
O P ERA C IO N A L X86 X64 A RM A RM 64****
Windows XP X* X*
Windows Server X* X*
2003
Windows Vista X X
Windows Server X X
2008
Windows 7 X X
Windows Server X X
2012 R2
Windows 8 X X X
Windows 8.1 X X X
Windows 10 X X X X
Android ** X X X X
iOS ** X X X X
Linux *** X X X X
* Você pode usar o conjunto de ferramentas da plataforma Windows XP incluído no Visual Studio 2017, no
Visual Studio 2015, no Visual Studio 2013 e no Visual Studio 2012 atualização 1 para compilar projetos do
Windows XP e do Windows Server 2003. Para obter informações sobre como usar esse conjunto de
ferramentas da plataforma, consulte Configuring Programs for Windows XP (Configurando programas para
Windows XP). Para obter mais informações sobre como alterar o conjunto de ferramentas da plataforma,
consulte Como modificar a estrutura de destino e o conjunto de ferramentas da plataforma.
** É possível instalar a carga de trabalho Desenvolvimento Móvel com C++ no instalador do Visual Studio
2017 e posterior. Na instalação do Visual Studio 2015, escolha o componente opcional Visual C++ para
Desenvolvimento Móvel da Plataforma Cruzada para direcionar plataformas iOS ou Android. Para obter
mais informações, consulte Instalar o Visual C++ para Desenvolvimento Móvel da Plataforma Cruzada. Para
compilar o código do iOS, é necessário ter um computador Mac e atender a outros requisitos. Para obter uma
lista de pré-requisitos e instruções de instalação, consulte Instalar e configurar ferramentas de build usando o
iOS. É possível compilar código x86 ou ARM para coincidir com o hardware de destino. Use configurações x86
para compilar no simulador de iOS, no Emulador do Microsoft Visual Studio para Android e em alguns
dispositivos Android. Use configurações ARM para compilar em dispositivos iOS e na maioria dos dispositivos
Android.
*** É possível instalar a carga de trabalho Desenvolvimento para Linux com C++ no instalador do Visual
Studio 2017 e posterior para direcionar plataformas Linux. Para obter instruções, consulte Baixar, instalar e
configurar a carga de trabalho do Linux. Esse conjunto de ferramentas compila o executável no computador de
destino, permitindo builds para qualquer arquitetura com suporte.
**** O suporte a ARM64 está disponível no Visual Studio 2017 e posterior.
Para obter informações de como definir a configuração da plataforma de destino, consulte Baixar, instalar e
configurar a carga de trabalho do Linux (Como configurar projetos do Visual C++ para plataformas x64 de 64
bits de destino).
Veja também
Ferramentas e recursos do Visual C++ em edições do Visual Studio
Introdução
Ferramentas e funcionalidades do C++ em edições
do Visual Studio
Os recursos do C++ a seguir estão disponíveis no Visual Studio 2019. A menos que declarado de outra forma,
todos os recursos estão disponíveis em todas as edições: Visual Studio Community, Visual Studio Professional e
Visual Studio Enterprise. Alguns recursos exigem cargas de trabalho específicas ou componentes opcionais, que
você pode instalar com o Instalador do Visual Studio.
Plataformas
Windows Desktop
Plataforma Universal do Windows ((tablet, computador, Xbox, IoT e HoloLens))
Linux
Android
iOS
Compiladores
Compilador MSVC de 32 bits para x86, x64, ARM e ARM64
Compilador MSVC de 64 bits para x86, x64, ARM e ARM64
Compilador cruzado GCC para ARM
Clang/LLVM
No Windows, Clang/LLVM 7.0, direcionando x86 ou x64 (somente suporte a CMake). Outras versões
do Clang poderiam funcionar, mas não há suporte oficial para elas.
No Linux, há suporte a qualquer instalação do Clang/LLVM pela distribuição.
Cargas de trabalho do C++

O Visual Studio inclui as seguintes cargas de trabalho para desenvolvimento do C++. É possível instalar
qualquer uma ou todas elas juntamente com outras cargas de trabalho como Desenvolvimento para Desktop do
.NET, Desenvolvimento do Python, Desenvolvimento do Azure, Desenvolvimento de Extensão do Visual Studio e
outros.
Desenvolvimento para desktop com C++
Incluído:
Principais recursos de área de trabalho do C++
Componentes opcionais:
MSVC v142 – ferramentas de build do C++ para VS 2019 x64/x86 (v14.21)
SDK do Windows 10 (10.0.17763.0)
Depurador Just-In-Time
Ferramentas de criação de perfil do C++
Ferramentas CMake do C++ para Windows
ATL do C++ para ferramentas de build v142 (x86 e x64)
Adaptador de Teste para Boost.Test
Adaptador de Teste para Google Test
Live Share
IntelliCode
IntelliTrace (somente Enterprise)
MFC do C++ para ferramentas de build v142 (x86 e x64)
Suporte do C++/CLI para ferramentas de build v142 (14.21)
Módulos do C++ para ferramentas de build v142 (x64/x86 – experimental)
Compilador do Clang para Windows
IncrediBuild - Aceleração de Build
SDK do Windows 10 (10.0.17134.0)
SDK do Windows 10 (10.0.16299.0)
MSVC v140 – ferramentas de build do C++ para VS 2015 (v14.00)
Desenvolvimento de Linux com C++
Incluído:
Funcionalidades principais do C++
Runtime C Universal do Windows
Desenvolvimento do C++ para Linux
Ferramentas CMake do C++ para Linux
Ferramentas de desenvolvimento inseridas e de IoT
Desenvolvimento para a Plataforma Universal do Windows
Incluído:
Blend for Visual Studio
.NET Native e .NET Standard
Gerenciador de pacotes NuGet
Ferramentas da Plataforma Universal do Windows
SDK do Windows 10 (10.0.17763.0)
IntelliCode
Conectividade de dispositivos USB
Ferramentas da Plataforma Universal do Windows do C++ (v142)
Ferramentas da Plataforma Universal do Windows do C++ (v141)
Depurador de gráficos e criador de perfil de GPU do DirectX
SDK do Windows 10 (10.0.18362.0)
SDK do Windows 10 (10.0.17134.0)
SDK do Windows 10 (10.0.16299.0)
Ferramentas de arquitetura e análise
Desenvolvimento de jogos do C++
Incluído:
Runtime C Universal do Windows
Atualização dos Pacotes Redistribuíveis do C++ 2019
Ferramentas de criação de perfil do C++
SDK do Windows 10 (10.0.17763.0)
IntelliCode
SDK do Windows 10 (10.0.17134.0)
SDK do Windows 10 (10.0.16299.0)
Cocos
Instalador do Unreal Engine
Suporte do IDE do Android para Unreal Engine
Desenvolvimento móvel com C++
Incluído:
Instalação do SDK do Android (nível da API 25) (instalação local para Desenvolvimento Móvel com C++)
NDK do Android (R16B)
Apache Ant (1.9.3)
Ferramentas de desenvolvimento do Android para C++
IntelliCode
Google Android Emulator (Nível da API 25) (instalação local)
Intel HAXM (Hardware Accelerated Execution Manager) (instalação local)
NDK do Android (R16B) (32 bits)
Ferramentas de desenvolvimento do iOS para C++
Componentes individuais
É possível instalar esses componentes independentemente de qualquer carga de trabalho.
Diagnóstico do JavaScript
Live Share
runtime da Plataforma Universal do Windows do C++ para ferramentas de build v142
Publicação ClickOnce
Projetos do Instalador do Microsoft Visual Studio
Bibliotecas e cabeçalhos
Cabeçalhos e bibliotecas do Windows
CRT (Runtime C) Universal do Windows
Biblioteca Padrão C++
ATL
MFC
Biblioteca de classes .NET Framework
Biblioteca de suporte do C++ para .NET
OpenMP 2.0
Mais de 900 bibliotecas open-source por meio do catálogo de vcpkg
Sistemas de build e de projeto

CMake
Qualquer sistema de build por meio de Abrir Pasta
Builds de linha de comando (msbuild.exe)
Multiplataforma nativa
Multiplataforma gerenciada
Builds paralelos
Personalizações de build
Extensibilidade de páginas de propriedades
Modelos de projeto
Os seguintes modelos de projeto estão disponíveis dependendo de quais cargas de trabalho você instalou.
Área de trabalho do Windows:
Projeto em branco
Aplicativo de Console
Assistente de Área de Trabalho do Windows
Aplicativos da Área de Trabalho do Windows
Projeto Itens Compartilhados
Aplicativo do MFC
Biblioteca de vínculo dinâmico
Projeto CLR Vazio
Aplicativo de console do CLR
Biblioteca Estática
Projeto do CMake
Projeto ATL
Biblioteca de vínculo dinâmico do MFC
Biblioteca de classes do CLR
Projeto Makefile (Windows)
ActiveXControl do MFC
Projeto de Teste da Unidade Nativa
Google Test
Plataforma Universal do Windows (C++/CX):
Aplicativo em branco
Aplicativo DirectX 11 e XAML
Aplicativo DirectX 11
Aplicativo DirectX 12
Aplicativo de Teste de Unidade
DLL
componente do Windows Runtime
Biblioteca Estática
Projeto de Empacotamento de Aplicativo do Windows
Linux:
Aplicativo de console (Linux)
Projeto vazio (Linux)
Raspberry Pi Blink
Projeto Makefile (Linux)
Ferramentas
Vinculador Incremental (Link.exe)
Utilitário do Microsoft Makefile (Nmake.exe)
Gerador de Lib (Lib.exe)
Compilador de Recurso do Windows (Rc.exe)
Recurso do Windows para Conversor de Objeto (CvtRes.exe)
Utilitário de Manutenção de Informações de Procura (BscMake.exe)
Removedor de Decoração de Nomes do C++ (Undname.exe)
Despejo de COFF/PE (Dumpbin.exe)
Editor de COFF/PE (Editbin.exe)
MASM (Ml.exe)
Spy++
ErrLook
AtlTrace
Regras de inferência
Otimizações guiadas por perfil
Funcionalidades de depuração
Depuração nativa
natvis (visualização nativa de tipo)
Depuração de gráficos
Depuração gerenciada
Uso de GPU
Uso de memória
Depuração remota
Depuração SQL
Análise de código estático
Designers e Editores
XAML Designer
Designer/Editor de Estilo CSS
Designer/Editor de HTML
Editor de XML
Editor de Código-fonte
Recursos de produtividade: refatoração, mecanismo IntelliSense EDG, formatação de código C++
Designer de Formulários do Windows
Designer de dados
Editor de Recurso Nativo (arquivos .rc)
Editores de recursos
Editor de modelos
Designer de sombreador
Validação de dependência dinâmica (somente Enterprise)
Diagramas de camada de arquitetura (somente Enterprise)
Validação de arquitetura (somente Enterprise)
Clone de código (somente Enterprise)
Funcionalidades de dados
Designer de dados
Objetos de dados
Serviços Web
Gerenciador de Servidores
Automação e extensibilidade
Modelos de objeto de extensibilidade
Modelo de código
Modelo de Projeto
Modelo de editor de recursos
Modelo de assistente
Modelo de objeto do depurador
Ferramentas de gerenciamento de ciclo de vida do aplicativo

Teste de Unidade (Microsoft Native C++, Boost.Test, Google Test, CTest)
Mapa de códigos e grafos de dependência (Professional e Enterprise)
Cobertura de código (somente Enterprise)
Teste manual (somente Enterprise)
Teste exploratório (somente Enterprise)
Gerenciamento de caso de teste (somente Enterprise)
Integração de depurador do mapa de códigos (somente Enterprise)
Live Unit Testing (somente Enterprise)
IntelliTest (somente Enterprise)
Microsoft Fakes (Isolamento de teste de unidade) (somente Enterprise)
Cobertura de código (somente Enterprise)
Veja também
Instalar o Visual Studio
O que há de novo no Visual Studio
Tipos de projeto do C++ no Visual Studio
As tabelas a seguir mostram os recursos do Visual C++ disponíveis no Visual Studio 2017. Um X em uma célula
indica que o recurso está disponível; uma célula vazia indica que o recurso não está disponível. As observações
entre parênteses indicam que um recurso está disponível, mas é restrito.
Plataformas
VISUA L ST UDIO VISUA L ST UDIO VISUA L ST UDIO
EXP RESS PA RA EXP RESS PA RA C O M M UN IT Y / P RO F E VISUA L ST UDIO
P L ATA F O RM A W IN DO W S 10 W IN DO W S DESK TO P SSIO N A L EN T ERP RISE
Windows Desktop X X X
Plataforma Universal X X X
do Windows
(telefone, tablet,
computador, Xbox,
IoT e HoloLens)
Linux X X
Microsoft Store 8.1 X X
Windows Phone 8.0 X X
Android X X
iOS X X
Compiladores
EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
C O M P IL A DO R W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Compilador MSVC X X X X
X86 de 32 bits
Compilador cruzado X X X
X86_arm
Compilador MSVC X X
x64 de 64 bits
Compilador cruzado X X X X
X86_ x64
Bibliotecas e cabeçalhos
B IB L IOT EC A O U EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
C A B EÇ A L H O W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Cabeçalhos e (X) X X X
bibliotecas do
Windows e biblioteca
CRT
Biblioteca Padrão X X X X
C++
B IB L IOT EC A O U EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
C A B EÇ A L H O W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
ATL X X
MFC X X
Biblioteca de classes X X X
.NET Framework
Biblioteca de suporte X X X
do C++ para .NET
OpenMP 2.0 X X X X
Modelos de projeto
M O DELO W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Modelos XAML para X X X

UWP, Windows 8.1,
Windows Phone 8.0
Aplicativo Direct3D X X X
DLL (Universal do X X X
Windows)
Biblioteca Estática X X X
(Universal do
Windows)
componente do X X X
Windows Runtime
Aplicativo de Teste de X X X
Unidade (Universal
do Windows)
Projeto ATL X X
Biblioteca de Classes X X X
(CLR)
Aplicativo de Console X X X
CLR
Projeto CLR Vazio X X X
Assistente X X
personalizado
M O DELO W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Projeto em branco X X X
Projeto Makefile X X X
Controle ActiveX do X X
MFC
Aplicativo MFC X X
DLL do MFC X X
Projeto de Teste X X X X
Aplicativo de Console X X X
Win32
Projeto Win32 X X X
Ferramentas
F ERRA M EN TA W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Vinculador X X X X
Incremental
(Link.exe)
Utilitário de X X X
Manutenção de
Programas
(Nmake.exe)
Gerador de Lib X X X X
(Lib.exe)
Compilador de X X X X
Recurso do Windows
(Rc.exe)
Recurso do Windows X X X
para Conversor de
Objeto (CvtRes.exe)
Utilitário de X X X X
Manutenção de
Informações de
Procura
(BscMake.exe)
Removedor de X X X X
Decoração de Nomes
do C++
(Undname.exe)
Despejo de COFF/PE X X X X
(Dumpbin.exe)
Editor de COFF/PE X X X X
(Editbin.exe)
MASM (Ml.exe) X X
Spy++ X X
ErrLook X X
AtlTrace X X
Devenv.com X X
Regras de inferência X X
Atualizar projetos X X X X
.vcproj do VCBuild
para o MSBuild
(VCUpgrade.exe)
Otimizações guiadas X X
por perfil
Funcionalidades de depuração
REC URSO DE EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
DEP URA Ç Ã O W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Depuração nativa X X X X
natvis (visualização X X X X
nativa de tipo)
Depuração de X X X
gráficos
Depuração X X X
gerenciada
Uso de GPU X X X
Uso de memória X X X
REC URSO DE EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
DEP URA Ç Ã O W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Depuração remota X X X X
Depuração SQL X X
Análise de código Limitado Limitado X X

estático
Designers e Editores
DESIGN ER O U EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
EDITO R W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
XAML Designer X X X
Designer/Editor de X X X X
Estilo CSS
Designer/Editor de X X X X
HTML
Editor de XML X X X X
Editor de Código- X X X X
fonte
Funcionalidades de X X X X
produtividade:
Refatoração,
IntelliSense,
Formatação de
Código C++
Designer de X X X
Formulários do
Windows
Designer de dados X X
Editor de Recurso X X
Nativo (arquivos .rc)
Editores de recursos X X X X
Editor de modelos X X X
Designer de X X X
sombreador
Funcionalidades de dados
REC URSO DE DA DO S W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Designer de dados X X
Objetos de dados X X
Serviços Web X X
Gerenciador de X X
Servidores
Sistemas de build e de projeto

REC URSO DE B UIL D EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
O U DE P RO JETO W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Builds de linha de X X X X
comando
(msbuild.exe)
Multiplataforma X X X
nativa
Multiplataforma X X X
gerenciada
Builds paralelos X X X X
Personalizações de X X X X
build
Extensibilidade de X X X X
páginas de
propriedades
Automação e extensibilidade
A UTO M A Ç Ã O E EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
EXT EN SIB IL IDA DE W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Modelos de objeto X X
de extensibilidade
Modelo de código X X
Modelo de Projeto X X
Modelo de editor de X X
recursos
Modelo de assistente X X
A UTO M A Ç Ã O E EXP RESS PA RA EXP RESS PA RA P RO F ESSIO N A L / C O M VISUA L ST UDIO
EXT EN SIB IL IDA DE W IN DO W S W IN DO W S DESK TO P M UN IT Y EN T ERP RISE
Modelo de objeto do X X
depurador
Ferramentas de gerenciamento de ciclo de vida do aplicativo

Teste de unidade X X X X
(estrutura nativa)
Teste de unidade X X X
(estrutura
gerenciada)
Cobertura de código X
Teste manual X
Teste exploratório X
Gerenciamento de X
casos de teste
Mapa de códigos e somente leitura X

grafos de
dependência
Depuração do mapa X
de códigos
Veja também
Instalar o Visual Studio
O que há de novo no Visual Studio
Tipos de projeto do C++ no Visual Studio
Instalar o suporte C11 e C17 no Visual Studio
O suporte para padrões C11 e C17 requer Visual Studio 2019 versão 16.8 ou posterior. Para ver a
documentação desta versão, de definido o controle Visual Studio seletor de versão do Visual Studio 2019. Ele é
encontrado na parte superior do conteúdo desta página.
O suporte para padrões C11 e C17 está disponível a partir do Visual Studio 2019 versão 16.8. O suporte requer
um UCRT (Universal C Runtime) atualizado e as atualizações mais recentes do SDK do Windows, para funcionar
corretamente com o pré-processador compatível ( /Zc:preprocessor ).
Windows As versões do SDK correspondem Windows versões do sistema operacional. O suporte a C11 e C17
requer Windows SDK 10.0.20348.0 (versão 2104) ou posterior. Normalmente, o Windows SDK é uma opção
instalável na guia Componentes Individuais no Instalador do Visual Studio. Essa é a maneira recomendada de
atualizar o SDK para uso com Visual Studio. No entanto, no momento da redação, Windows SDK mais recente
não está disponível no Instalador do Visual Studio. Você pode seguir estas etapas para configurar o SDK mais
recente e criar o código C11 ou C17 no Visual Studio ou na linha de comando.
Pré-requisitos
Visual Studio 2019 versão 16.8 ou posterior instalada e em execução no computador. Recomendamos que
você use a versão mais recente disponível para o melhor suporte. Se Visual Studio ainda não estiver
instalado, confira Instalar o suporte ao C++ no Visual Studio para obter instruções de instalação. Na
instalação, inclua a carga de trabalho Desenvolvimento para desktop com C++.
Etapa 1: Baixar o SDK Windows 10 aplicativo

Você pode baixar o SDK Windows 10 mais recente na página Windows 10 SDK. Se você vir uma mensagem
informando "Não é possível encontrar a página solicitada", tente alterar a localidade na URL para en-us.
Escolha Baixar o instalador em Windows 10 SDK versão 2104 e Desenvolvimento de servidor para iniciar o
download. Versões posteriores do Windows SDK também funcionarão.
Quando o download for concluído, abra a pasta para o arquivo baixado. Normalmente, é a pasta Downloads e o
arquivo normalmente é chamado winsdksetup.exe de . Clique com o botão direito do mouse no arquivo para
abrir a caixa de diálogo Propriedades do arquivo. Na guia Geral, na seção Segurança, marque a caixa de
seleção Desbloquear. Escolha OK para salvar suas alterações.
Etapa 2: Instalar o Windows 10 SDK

Execute winsdksetup.exe para iniciar a instalação.
Na página Especificar Local, selecione Instalar o Windows Software Development Kit – neste computador e,
em seguida, escolha Próximo . <version> Na página Windows Privacidade dos Kits do Windows, selecione se
a Microsoft deve permitir que a Microsoft colete insights para os kits Windows 10 e escolha Próximo. Escolha
Aceitar para aceitar o contrato de licença. Na página Selecionar os recursos que você deseja instalar,
selecione estes recursos:
Windows Ferramentas de Assinatura do SDK para Aplicativos da Área de Trabalho
Windows SDK para Aplicativos Gerenciados UWP
Windows SDK para aplicativos C++ UWP
Windows SDK para aplicativos C++ x86 da área de trabalho (se você planeja criar para x86)
Windows SDK para Aplicativos amd64 do C++ da Área de Trabalho (se você planeja criar para x64)
Windows SDK para aplicativos arm do C++ da área de trabalho (se você planeja criar para ARM)
Windows SDK para Aplicativos arm64 do C++ da Área de Trabalho (se você planeja criar para ARM64)
Escolha Instalar para instalar os componentes selecionados do SDK. O SDK leva alguns minutos para concluir a
instalação. Quando ele for concluído, abra Visual Studio.
Etapa 3: Configurando o modo C11 ou C17 no Visual Studio

No Visual Studio, abra um projeto C novo ou existente e abra a caixa de diálogo Páginas de Propriedades do
projeto.
De configurar o projeto para usar o Windows 10 SDK que você acabou de instalar. Na página Geral das
Propriedades de Configuração, de definido a propriedade Windows versão do > SDK como 10.0 (versão mais
recente instalada) ou para a versão específica do SDK instalada.
Você também verá uma opção específica de C: C Language Standard. De definir essa propriedade como ISO
C11 Standard ( /std:c11 ) ou ISO C17 (2018) Standard ( /std:c17 ) .
A propriedade Padrão da Linguagem C++ é usada quando o idioma é C++. É o padrão quando a extensão de
arquivo é .cpp . A versão da propriedade C Language Standard é usada quando o idioma é C. É o padrão
quando a extensão de arquivo é .c . Para compilar usando C11 ou C17, coloque o código-fonte em um arquivo
ou de definir o código a .c ser compilado como C. Você pode definir essa propriedade para seu projeto na
página Propriedades de Configuração > C/C++ > Avançado. De definir a propriedade Compilar como para
Compilar como código C (/TC).
Parabéns, você definiu tudo o que precisa para criar código C11 e C17 Visual Studio!
Confira também
/std (Especificar a versão padrão do idioma)
Amostras do Visual Studio C++
Exemplos para o Visual Studio C++ estão disponíveis na Web. A Microsoft produziu muitos exemplos de C++
que demonstram funcionalidades diferentes em várias tecnologias. Aqui estão alguns dos locais para encontrar
exemplos adicionais:
Exemplos de Microsoft Docs-C++
Exemplos do Windows no GitHub
Exemplos de código do centro de desenvolvimento do Windows
Arquivo de exemplo do CodePlex
Exemplos de código do ADO
Exemplos de desenvolvimento de hardware para Windows
Exemplos de C++ arquivados no GitHub

O Visual Studio incluiu o código de exemplo C++ em versões anteriores. O código de exemplo foi instalado com
o Visual Studio ou estava disponível como um download separado. Muitos artigos em nossa documentação
referem-se a esses exemplos. Eles não são mais instalados pelo Visual Studio. Em vez disso, um repositório está
disponível no GitHub. As tabelas a seguir têm descrições para cada exemplo e links para o diretório do exemplo
no repositório.
IMPORTANT
Este código de exemplo destina-se a ilustrar um conceito e mostra somente o código que é relevante para esse conceito.
Ele pode não atender aos requisitos de segurança de um ambiente específico e não deve ser usado exatamente como
mostrado. Recomendamos que você adicione código de segurança e tratamento de erros para tornar seus projetos tão
seguros e robustos quanto for conveniente. A Microsoft fornece esse código de exemplo "como está", sem garantias.
Exemplos de ATL
Exemplos de ATL -avançado
N O M E DA A M O ST RA DESC RIÇ Ã O
ActiveDoc Demonstra como implementar um servidor de documentos

ativo.
Async Baixa dados de forma assíncrona de uma URL.
ATLButton Cria um botão que exibe a si mesmo com três bitmaps

diferentes, dependendo de seu estado.
ATLDuck Demonstra o uso de pontos de conexão com controles ATL.
ATLSecurity Mostra como usar as classes de segurança do ATL para

examinar as configurações de segurança.
ATLTraceTool Exibe a saída gerada pela ATLTRACE2 macro.
Connect Ilustra a implementação e o uso de pontos de conexão (as

interfaces IConnectionPointContainer e IConnectionPoint)
em um ambiente multi-threaded.
CThreadPool Mostra como usar um pool de threads em um aplicativo e

como a implementação de um pool de threads pode
melhorar o desempenho do aplicativo.
DCOM Demonstra como chamar um objeto COM (implementado

em um serviço do Windows) de vários clientes em execução
em computadores diferentes.
MFCATL Ilustra como os objetos COM ATL podem ser usados em um

servidor MFC EXE.
Exemplos de ATL – controles

ATLFire Demonstra como criar um controle em janela usando ATL.
CDInfo Reproduz faixas de áudio de CD e exibe informações sobre as

faixas em dicas de ferramenta e uma exibição de gráfico de
pizza.
CIRC Cria um controle que demonstra páginas de propriedades e

desenha um círculo.
Polygon Cria um controle que implementa propriedades

personalizadas, eventos, páginas de propriedades e
segurança de objeto.
SubEdit Cria um controle doclass do Windows.
Exemplos de ATL -geral

ATLCollections Demonstra o uso de ICollectionOnSTLImpl e e

CComEnumOnSTL a implementação de classes de política de
cópia personalizada.
ATLCon Demonstra um contêiner de controle simples.
ATLSafeArray Mostra como criar e manter SAFEARRAY s usando

CComSafeArray ; também como passar SAFEARRAY s de
um componente para um script.
AutoThread Demonstra como usar a CComAutoThreadModule classe.

Aviso sonoro Implementa uma interface de divisão de uma

coleção/enumeração de BSTR s.
CircColl Implementa uma coleção/enumeração de objetos usando

ATL e a biblioteca C++ padrão.
COMMap Demonstra macros de entrada de mapa de interface com

com suporte de COM do compilador.
Personalizadostring Mostra como usar um alocador de memória personalizado

para CStringT o para melhorar o desempenho em um
aplicativo multithread.
DispSink Demonstra o uso de um ponto de conexão em interfaces de

expedição.
Exemplos de ATL -OLEDB -Consumer

CatDB Exibe as informações de esquema, como tabelas e colunas,

de provedores de OLE DB.
DBViewer Demonstra um aplicativo de nível intermediário que

depende da CManualAccessor classe para assumir o
controle total de associações de dados para seus aplicativos.
DynamicConsumer Demonstra como usar classes de conjunto de linhas de

esquema e acessador dinâmico para ler metadados de um
banco de dados.
MultiRead Lê uma tabela em um banco de dados usando vários

threads.
Exemplos de ATL -OLEDB -Provider

AdvancedPV Implementa um provedor de OLE DB atualizável. Demonstra

algumas técnicas avançadas.
UpdatePV Implementa um provedor de OLE DB atualizável

(leitura/gravação).
Exemplos de CLR e linguagem-Windows Forms

BirthdayPicker Mostra como o mecanismo de recursos de .NET Framework

pode ser usado em aplicativos C++. Ele também demonstra
alguns componentes comuns do Window Forms.
Calculator Implementa uma calculadora de bolso simples usando C++

e as classes de Windows Forms de .NET Framework.
Rabisco (usando o MFC) Uma implementação do MFC da amostra de rabisco,

atualizada e estendida para incluir a nova funcionalidade
.NET.
Rabisco (Windows Forms) Uma Windows Forms implementação da amostra de rabisco,

atualizada e estendida para incluir a nova funcionalidade
.NET.
STLCLR Demonstra alguns dos recursos disponíveis ao usar a

biblioteca STL/CLR.
Exemplos de eventos COM

Comeventos Demonstra a manipulação de eventos usando COM.
Exemplos de ComTypeLibfor7
ACDual Adiciona interfaces duplas a um aplicativo de automação.
ADOSamp Implementa um aplicativo cliente/servidor de três camadas.
AllInOne Implementa um servidor usando ATL, expondo coleções STL

e controladas pelo suporte de COM do compilador em um
aplicativo MFC.
COMMap Demonstra macros de entrada de mapa de interface com

com suporte de COM do compilador.
Connect Ilustra o uso e a implementação de pontos de conexão (as

IConnectionPointContainer IConnectionPoint
interfaces e) em um ambiente multi-threaded.
DCOM Demonstra como chamar um objeto COM (implementado

em um serviço do Windows) de vários clientes em execução
em computadores diferentes.
FreeThrd Demonstra um cliente multithread e um servidor de thread

livre com suporte de COM do compilador.
InProc Demonstra um aplicativo de servidor de automação em

processo com suporte de COM do compilador.
Labrador Implementa um servidor EXE que não tem nenhuma

interface do usuário.
MFCCalc Demonstra um aplicativo de servidor de automação com

suporte de COM do compilador.
Exemplos de compilador
Exemplos de compilador-geral
ccWrapper Demonstra como mapear sinalizadores de compilador

C/C++ de outros compiladores para o compilador de Visual
C++ (cl.exe).
Exemplos de compilador – MASM

EuclidStep1 Um projeto C puro que demonstra o algoritmo do Euclid

para localizar o maior divisor comum.
EuclidStep2 Uma extensão de EuclidStep1 que é um projeto misto de C e

MASM. O núcleo do algoritmo do Euclid é movido do .c
arquivo para um .asm arquivo, com o .c arquivo
chamando para o .asm arquivo.
PrimesStep1 Um projeto C puro que demonstra o Sieve de Eratosthenes

para localizar números primos.
PrimesStep2 Uma extensão de PrimesStep1 que é um projeto misto de C

e MASM que move o algoritmo de núcleo para o .asm
arquivo.
PrimesStep3 Uma extensão de PrimesStep2 que adiciona um arquivo de

cabeçalho C separado e um .asm arquivo de inclusão para
declarar a função externa e a estrutura de dados global.
Amostras de CRT
CPUID Determina os recursos da CPU que está sendo executada.
CRT_Dbg1 Ilustra os recursos básicos de depuração das bibliotecas de

tempo de execução do C.
CRT_Dbg2 Demonstra as funções de gancho de depuração em tempo

de execução do C.
DFACObjs Mostra como usar a função de tempo de execução

_CrtDoForAllClientObjects C para iterar por meio de uma
lista vinculada de objetos cliente.
Report Ilustra as funções de relatório de depuração em tempo de

execução do C.
RTC Demonstra o recurso de verificações de erro em tempo de

execução.
SecureCRT Este exemplo demonstra como atualizar o código que usava

funções de CRT preteridas para aumentar a segurança do
código.
Amostras de depuração
EEAddIn Usa o avaliador de expressão Add-In API para estender o

avaliador de expressão do depurador nativo.
Amostras de fusão
Rastreador Fornece informações sobre assemblies dependentes do

aplicativo e o estado dos assemblies no cache do Fusion
nativo, em forma legível humana.
Exemplo de Hilo
Hilo Hilo é uma série de artigos e aplicativos de exemplo. Eles

demonstram o poder do Windows 7, do Visual Studio e do
C++ para criar aplicativos cliente de alto desempenho e
responsivos. O Hilo fornece código-fonte e orientações que
ajudarão você a projetar e desenvolver aplicativos Windows
atraentes e habilitados para toque próprios.
Este exemplo foi atualizado para Visual Studio 2013. Ele

inclui um Hot Fix para o arquivo
AsyncLoaderMemoryManager. cpp (nas linhas 36 e 37), que
trata de um problema de falha comum.
Exemplos internacionais
IME Demonstra como controlar o modo do editor de método de

entrada e como implementar o nível 3 do IME.
SatDLL Demonstra uma maneira recomendada para implementar

recursos multilíngües em um aplicativo Win32.
UniRes Demonstra o uso de arquivos de recursos Unicode.
Exemplos de linguagem-geral
Dados Demonstra o acesso simples a um banco de dados SQL.
MEDriver Ilustra o uso de eventos COM (acionados de um servidor

COM não gerenciado) por meio de um wrapper .NET
Framework, gerado automaticamente a partir da biblioteca
de tipos do servidor COM.
Nilo Demonstra ASP.NET Web Forms e ASP.NET Web Services.
QStat Mostra como criar uma DLL que encapsula o acesso a um

objeto COM e expõe sua funcionalidade para .NET
Framework clientes.
Rabisco Demonstra como desenvolver um aplicativo Windows Forms

MDI usando C++/CLI e as classes de .NET Framework.
TilePuzzle Demonstra a interoperabilidade entre componentes

gerenciados (escritos com C++ e C#) e componentes nativos
(escritos com C++ usando atributos COM).
Exemplos de MFC
Exemplos de MFC – avançado
Coletar Demonstra classes de coleções baseadas em modelo do

MFC C++ e classes de coleção predefinidas padrão.
Cubo Aplicativo OpenGL usando contextos de dispositivo MFC

juntamente com contextos de recurso OpenGL.
DLLHusk Compartilhando a versão de DLL da biblioteca de classes

base com um aplicativo e uma DLL personalizada.
DLLScreenCap Uma DLL regular que pode ser vinculada estática ou

dinamicamente à biblioteca Microsoft Foundation Class.
MTGDI Demonstração do compartilhamento de recursos GDI entre

vários threads usando o suporte SDI (interface de
documento único) da estrutura para documentos e
exibições.
MTMDI Ilustração de multithread, onde os eventos de interface do

usuário são processados em um thread de interface de
usuário separado.
MTRecalc Ilustração de multithread, em que os recálculos são feitos em

um thread de trabalho.
Mutexes Aplicativo baseado em caixa de diálogo que cria dois

CWinThread objetos e os usa para realizar uma tarefa sob o
controle do usuário.
Fala Demonstra som multimídia usando recursos definidos pelo

usuário.
Exemplos de MFC – controles

Botão Demonstra o uso de um menu ativo no local, uma página de

propriedades de estoque e a opção de controle da caixa
sobre.
CIRC Demonstra noções básicas do controle ActiveX. Isso inclui

pintura de controle, ações e propriedades personalizadas,
ações e eventos personalizados, uso de cores e fontes, a
página de propriedades fonte de estoque, a página de
propriedades padrão e controle de versão.
CmnCtrl Demonstra alguns dos novos controles disponíveis com

MFC em wiprlhext: o botão de link de comando ( CButton
), o controle de pager ( CPagerCtrl ), o botão de divisão (
CSplitButton ) e o controle de endereço de rede (
CNetAddressCtrl ).
Contêm Demonstra um aplicativo de contêiner de edição visual.
Imagem Demonstra como usar o MFC para criar um controle ActiveX

que baixa dados de forma assíncrona.
Licenças Um controle que impõe o uso de uma licença de tempo de

design e tempo de execução.
Localize Um controle com uma interface do usuário localizada que

demonstra o uso de bibliotecas de tipos separadas e DLLs
(bibliotecas de vínculo dinâmico) de recursos para
localização.
NETADDR Demonstra o uso do controle "net address Verifier" do

Windows Vista.
Amigo Controle que exibe as cores de uma paleta. Ele demonstra

propriedades somente leitura, propriedades de Get/Set
persistentes, propriedades parametrizadas persistentes e
propriedades de imagem.
Push Controle de subclasse de um controle de botão desenhado

pelo proprietário do Windows. Ele demonstra as
propriedades de ações, os eventos personalizados e os
contentores de imagem.
RegSvr Demonstra a invocação do código de Self-Registration.
Índia Um controle com a aparência visual de uma discagem de

rotação que demonstra a validação de dados da página de
propriedades.
TestHelp Um controle ActiveX que tem seu próprio arquivo de ajuda e

dicas de ferramenta.
Hora Um controle invisível no tempo de execução e dispara um

evento de temporizador em intervalos definidos. Demonstra
as funções de notificação e as propriedades de ambiente.
XList Um controle, uma subclasse de uma caixa de listagem do

Windows, que exibe texto ou itens de bitmap.
Exemplos de MFC -geral

Clip-Art O diretório ClipArt contém recursos de exemplo que você

pode usar para personalizar a aparência do seu aplicativo.
CmnCtrl1 Demonstra como criar e alterar os estilos de controles

comuns do Windows usando classes do MFC (parte 1).
CmnCtrl2 Demonstra como criar e alterar os estilos de controles

comuns do Windows usando classes do MFC (parte 2).
CTaskDialog Demonstra vários recursos da CTaskDialog classe.
CtrlBars Barra de ferramentas personalizada e barra de status, barra

de diálogo e paleta flutuante.
CtrlTest Caixa de listagem de desenho proprietário e menu, controle

personalizado, botão bitmap, controle de rotação.
DBVList Usa as CListView CDaoRecordset classes e para

implementar a funcionalidade de exibição de lista virtual
disponível para o controle Common de exibição de lista.
DIBLook Demonstra o uso de DIBs e paletas de cores.
DlgCbr32 Adicionar uma barra de ferramentas e uma barra de status a

um aplicativo baseado em caixa de diálogo.
DlgTempl Demonstra a criação dinâmica de modelos de caixa de

diálogo.
DockTool Barras de ferramentas de arrastar e flutuantes que são

encaixáveis.
Dynamenu Modificando dinamicamente a lista de itens em menus;

manipulando comandos não conhecidos no momento da
compilação; e atualizando o prompt de comando da barra de
status para esses comandos.
FileDlgWatcher Cria uma caixa de diálogo personalizada que ilustra quais

eventos são gerados quando você cria um CFileDialog .
Olá Ilustra uma janela de aplicativo único com um menu e uma

caixa sobre.
HelloApp Exemplo de MFC mínimo que ilustra que poucas linhas de

código são necessárias para fazer com que uma janela
apareça na tela.
ListHdr Demonstra como usar as classes do MFC de controle

comum CListCtrl e o CHeaderCtrl .
MDI Aplicativo MDI que não usa documentos e exibições.
MDIDocVw Versão atualizada do exemplo de MDI que usa a arquitetura

de documento/exibição.
MMXSwarm Demonstra como usar CImage o, o __m64 tipo de dados e

bitmaps independentes de dispositivo (DIBs).
Sem janela restrita Demonstra o uso de um CDialog objeto MFC como uma
caixa de diálogo sem janela restrita.
Multipad O editor de texto simples permite que o usuário abra e edite

vários arquivos de texto ao mesmo tempo.
Npp Demonstra como implementar um aplicativo de interface

(SDI) semelhante ao bloco de notas. Ele permite que você
edite mensagens de texto e envie-as para outros usuários
ou outros sistemas por meio da API de mensagens do
Windows ou MAPI.
PropDlg Folhas de Propriedades (caixas de diálogo).
Lista de listas Ilustra a seleção de linha completa em um controle comum

de exibição de lista.
Rabisco Fornece ilustrações simples de uma ampla variedade de

recursos do MFC.
SimpleImage Demonstra o carregamento, o redimensionamento, a

conversão e a gravação de imagens.
SnapVw Mostra como usar páginas de propriedades em uma janela

de quadro filho MDI.
Spiro Um jogo que mostra o uso CImageList e como usar os

contextos de exibição de memória em aplicativos que exigem
efeitos de animação.
Posição Demonstra vários CRectTracker estilos e opções.
VariantUse Demonstra o uso do tipo de dados Variant.
ViewEx Várias exibições, exibição de rolagem, janelas de divisão.
Exemplos do MFC – Internet

DHTMLExplore Demonstra o tratamento de eventos DHTML e o uso de

campo DDX DHTML.
HTMLEdit Encapsula o controle de edição do Internet Explorer

MSHTML.
MFCIE Demonstra o MFC CHtmlView e as CReBar classes.
Agendador Demonstra como criar uma caixa de diálogo baseada em

HTML usando as classes de bibliotecas de Visual C++.
Exemplos de MFC – OLE

ACDual Demonstra como adicionar suporte de interface dupla a um

servidor de automação baseado em MFC.
AutoClik Ilustra os recursos de automação. Inclui o AUTODRIV, um

aplicativo cliente de automação simples que orienta o
aplicativo de exemplo AUTOCLIK.
CalcDriv Cliente de automação.
DrawCli Aplicativo de desenho orientado a objeto completo que

também é um contêiner de edição visual do ActiveX.
HierSvr Demonstra um aplicativo de servidor com arrastar e soltar

OLE.
InProc Um servidor de automação em processo que pode ser

carregado como uma DLL no espaço de endereço do cliente.
IPDrive Um aplicativo cliente de automação simples que orienta o

aplicativo de exemplo INPROC.
MFCBind Mostra como criar um contêiner de documento ativo

(anteriormente conhecido como DocObject).
MFCCalc Um servidor de automação que implementa uma

calculadora simples.
OClient Aplicativo de contêiner de edição visual do ActiveX, com

arrastar e soltar.
OLEView Implementação de um pesquisador de objetos OLE por meio

de interfaces OLE personalizadas.
SuperPad Demonstra um servidor de edição visual que edita texto

usando CEditView.
TstCon Implementa um contêiner de controle ActiveX usando o

suporte do MFC para inserção de OLE. Você pode usar
TSTCON para testar controles ActiveX, alterar suas
propriedades e invocar seus métodos.
Desses Usa o suporte do MFC para controles de edição avançados

para criar um processador de texto básico.
Exemplos de MFC – utilitário

GUIDGen Um aplicativo MFC simples baseado em diálogo que gera

identificadores globais exclusivos.
Makehm Um aplicativo de console que produz um mapeamento entre

as identificações de recurso e os contextos de ajuda.
Exemplos de MFC -Visual C++ 2008 Feature Pack

CustomPages Demonstra como adicionar uma página personalizada à caixa

de diálogo personalização da barra de ferramentas.
DesktopAlertDemo Demonstra como implementar uma caixa de diálogo de

alerta da área de trabalho (semelhante à caixa de diálogo de
um aplicativo de mensagens instantâneas).
DlgToolTips Demonstra como implementar dicas de ferramenta

avançadas para controles em uma caixa de diálogo.
DrawClient Demonstra como integrar o suporte para uma faixa de faixas

em um aplicativo de desenho com suporte a contêiner de
edição.
DynamicMenu Demonstra como atualizar dinamicamente um menu na

barra de menus e um menu pop-up em tempo de execução.
Explorer Demonstra como implementar um Gerenciador de sistema

de arquivos que se assemelha ao explorador de arquivos. Ele
tem elementos e funcionalidades de interface do usuário
semelhantes.
IEDemo Demonstra como implementar um aplicativo semelhante ao

Internet Explorer, com elementos e recursos de interface do
usuário semelhantes.
MDITabsDemo Demonstra como criar um aplicativo que usa a nova

interface documentos MDI com guias em vez das janelas
filho MDI tradicionais.
MenuSubSet Demonstra como remover dinamicamente itens de menu e

submenus específicos na inicialização do aplicativo.
MSMoneyDemo Demonstra como usar o MFC para criar uma interface do

usuário semelhante ao Microsoft Money.
MSOffice2007Demo Demonstra como implementar um aplicativo de editor

semelhante a um aplicativo do Office 2007, com elementos
de interface do usuário semelhantes e recursos semelhantes
limitados. O exemplo MSOffice2007Demo implementa uma
interface do usuário de faixa de medida completa, assim
como um aplicativo do Office 2007. Alguns dos elementos
da faixa de faixas estão conectados aos recursos no
aplicativo.
NewControls Demonstra os recursos de muitos dos controles

implementados no MFC. Esses controles incluem botões
personalizáveis, controles seletores de cores e paletas, um
seletor de fontes, um editor de imagens, uma grade de
propriedades, um controle de edição mascarado e controles
de árvore e de Shell.
OutlookDemo Demonstra como criar um aplicativo semelhante ao Outlook

2003/2007.
OutlookMultiViews Demonstra como alternar entre várias exibições em um

único documento em um aplicativo SDI. O exemplo usa o
controle da barra do Outlook para listar os modos de
exibição disponíveis e alternar entre eles.
OwnerDrawMenu Ilustra como desenhar itens de menu pop-up

dinamicamente.
PaletteDemo Ilustra como criar uma barra de ferramentas de várias

colunas com uma área de informações de desenho
proprietário. Clique em 2, 3 ou 4 botões na barra de
ferramentas padrão para alterar em tempo de execução o
número de colunas da barra de ferramentas personalizada.
PropSheetDemo Ilustra os seguintes tipos de controle de folha de

propriedades: simples, com guias no lado esquerdo, com
controle de árvore no lado esquerdo, guias de estilo do
OneNote, lista de itens no lado esquerdo.
RebarTest Demonstra um controle rebar personalizável que hospeda

uma barra de ferramentas.
RibbonGadgets Ilustra vários controles que podem ser hospedados no

controle Ribbon. Na parte inferior do quadro principal, você
pode encontrar a janela de código-fonte com o texto do
código-fonte, que descreve como criar um gadget específico.
RibbonMDI Demonstra o uso do controle Ribbon com a interface de

vários documentos.
RollupPane Demonstra um painel "informações" flutuante, que se

acumula automaticamente. Você pode pressionar o botão
fixar na legenda do painel flutuante para ativar e desativar a
ativação.
SetPaneSize Demonstra como definir o tamanho do painel de encaixe

programaticamente.
Controle deslizante Demonstra como implementar um botão da barra de

ferramentas que hospeda um controle externo.
Estado da Demonstra como implementar um aplicativo que salva e

carrega Estados diferentes para a barra de menus, barras de
ferramentas e janelas de encaixe.
StatusBarDemo Demonstra como adicionar vários controles avançados a

uma barra de status.
TabbedView Demonstra como criar uma exibição que contém várias

exibições com guias, como as guias em uma pasta de
trabalho do Excel.
TabControl Demonstra o controle da guia MFC e as diferentes

aparências que usam diferentes propriedades e
gerenciadores visuais.
TasksPane Demonstra as classes do painel de tarefas do MFC e suas

diferentes aparências usando várias propriedades e
gerenciadores visuais.
ToolbarDateTimePicker Demonstra como integrar um controle seletor de data/hora

com a barra de ferramentas
ToolTipDemo Demonstra como usar os recursos avançados da dica de

ferramenta do MFC.
TrayMenu Ilustra a capacidade de usar os menus da barra de controle

do MFC com o ícone de bandeja do sistema. É semelhante
aos ícones de notificação no canto inferior direito da tela.
VisualStudioDemo Demonstra como implementar um aplicativo com muitos

dos mesmos recursos e funcionalidades da interface do
usuário do Visual Studio. Muitos dos elementos da interface
do usuário do Visual Studio são demonstrados, incluindo
uma barra de ferramentas de encaixe personalizável, Toolbar
e Windows.
Desses Demonstra como implementar um aplicativo que imita a

funcionalidade do WordPad, incluindo os elementos da
interface do usuário e alguns dos recursos.
WorkSpaceToolBar Demonstra como adicionar uma barra de ferramentas a um

painel de encaixe. Ele é semelhante à barra de ferramentas
em Gerenciador de Soluções no Visual Studio.
Exemplos de MFC -Windows Touch

GestureDemo Demonstra o suporte ao Windows Touch no MFC (requer

hardware de toque).
TouchDemo Demonstra o suporte ao Windows Touch no MFC (requer

hardware de toque).
Exemplos de ODBC
odbcsql Este exemplo demonstra como usar APIs ODBC para se

conectar ao e acessar o banco de dados.
Exemplos de so
GetImage Demonstra as APIs (interfaces de programação de aplicativo)

do Windows Image Acquisition (WIA).
Exemplos de UNIX
UNIX-ccWrapper Demonstra um wrapper que mapeia os sinalizadores dos

compiladores Sun forte e gcc para o compilador de
Microsoft Visual C++ (cl.exe).
Exemplos do Windows 8
O pacote de exemplo do Windows 8 inclui todos os exemplos de código do aplicativo desenvolvidos e
atualizados para o Windows 8. O pacote de exemplo fornece uma maneira conveniente de baixar todos os
exemplos de uma só vez. Os exemplos neste pacote de exemplo estão disponíveis em C#, C++, VB.NET e
JavaScript. A Galeria de exemplos do Windows contém exemplos de código que exercitam os vários novos
modelos de programação, plataformas, recursos e componentes disponíveis no Windows 8 e no Windows
Server 2012. Esses exemplos baixáveis contêm o arquivo da solução do Visual Studio (sln), os arquivos de
origem, os ativos, os recursos e os metadados necessários para compilar e executar com êxito.
Mais informações estão disponíveis sobre os modelos de programação, plataformas, linguagens e APIs
demonstrados em cada exemplo. Consulte a orientação, os tutoriais e os artigos de referência fornecidos na
documentação do Windows 8, disponível na central de desenvolvedores do Windows. Esses exemplos são
fornecidos no estado em que se encontram, para demonstrar a funcionalidade dos modelos de programação e
APIs de recursos para o Windows 8 e o Windows Server 2012.
Exemplo de transferência em segundo plano (Windows 8) Este exemplo demonstra o comportamento amigável, com
reconhecimento de custos e flexível da API de transferência
em segundo plano para aplicativos Windows Runtime. Os
cenários de exemplo fornecidos abrangem downloads de
arquivos e uploads.
Exemplo de CryptoWinRT (Windows 8) Este exemplo mostra como usar as novas APIs de
criptografia.
Exemplo de impressão (Windows 8) Este exemplo demonstra como os aplicativos podem integrar
a experiência de impressão do Windows. Os cenários
demonstrados neste exemplo incluem: impressão do
aplicativo usando a barra de botões e o contrato de
impressão, impressão de dentro da experiência do aplicativo
e muito mais.
Exemplo de HttpClient (Windows 8) Este exemplo demonstra o uso da classe HttpClient e da

interface IXMLHTTPRequest2 para carregar e baixar vários
tipos de conteúdo de um servidor HTTP usando os recursos
de rede fornecidos pelo Windows Runtime.
Exemplo de sensor do acelerômetro (Windows 8) Este exemplo mostra como usar a

Windows.Devices.Sensors.Accelerometer API. Este
exemplo permite que o usuário exiba as forças de aceleração
nos eixos X, Y e Z de um acelerômetro de 3 eixos. Você pode
escolher um dos três cenários.
Exemplo de nome de imagem da conta (Windows 8) Este exemplo demonstra diferentes maneiras de obter o
nome do usuário que está conectado no momento. Ele
também demonstra como obter e definir a imagem usada
para o bloco do usuário.
Exemplo de configurações de aplicativo (Windows 8) Este exemplo demonstra como usar os submenus API
ApplicationSettings e configurações para integrar a interface
do usuário de configurações do aplicativo com o botão
Configurações. O exemplo usa o
Windows.UI.ApplicationSettings namespace e
WinJS.UI.SettingsFlyout .
Aplicativo de dispositivo da Windows Store para exemplo de Este exemplo demonstra como criar um aplicativo de
câmera (Windows 8) dispositivo da Windows Store para uma câmera. Um
aplicativo de dispositivo da Windows Store é fornecido por
um IHV ou OEM para diferenciar a experiência de captura de
uma câmera específica.
Introdução ao exemplo de leitor de blog simples do C++ O exemplo demonstra alguns princípios básicos do
(Windows 8) desenvolvimento de aplicativos da Windows Store em C++
nativo usando XAML para definir a interface do usuário. É
uma versão de trabalho completa do aplicativo abordada no
Windows Developer Center.
Exemplo de leitura e gravação de dados (Windows 8) Este exemplo mostra como usar as classes DataReader e
DataWriter para armazenar e recuperar dados.
Exemplo de dados de aplicativo (Windows 8) Este exemplo mostra como armazenar e recuperar dados
que são específicos de cada usuário e aplicativo da Windows
Store usando as APIs de dados do aplicativo Windows
Runtime. Os dados do aplicativo incluem estado de sessão,
preferências do usuário e outras configurações.
Exemplo de acesso de driver personalizado (Windows 8) Este exemplo mostra como usar CreateDeviceAccessInstance
e IDeviceIoControl para acessar um dispositivo especializado.
Exemplo de ListView e GridView Essentials do XAML Este exemplo demonstra como usar os controles GridView e
(Windows 8) ListView.
Exemplo de métricas de animação (Windows 8) Este exemplo mostra como usar as APIs de métricas de
animação no Windows.UI.Core.AnimationMetrics para
acessar os parâmetros brutos que definem as animações na
biblioteca de animações do Windows.
Exemplo de msAudioCategory do Gerenciador de Este exemplo demonstra como selecionar a categoria de

reprodução (Windows 8) msAudioCategory correta para um fluxo de áudio-vídeo (AV)
para configurá-lo como um fluxo de reprodução de áudio.
Amostra de jogo de captura XAML DirectX 3D (Windows 8) Este exemplo demonstra a implementação de um jogo
simples de primeira pessoa 3-D usando DirectX (Direct3D
11,1, Direct2D, XInput e XAudio2) e XAML em um aplicativo
C++. O XAML é usado para a exibição de cabeçotes e as
mensagens de estado do jogo.
Exemplo de rolagem, panorâmica e zoom do XAML Este exemplo demonstra como usar o controle ScrollViewer
(Windows 8) para panorâmica e zoom.
Exemplo de controle FlipView XAML (Windows 8) Este exemplo demonstra como usar o controle FlipView para
permitir que os usuários percorram uma coleção.
Exemplo de sensor girômetro (Windows 8) Este exemplo mostra como usar a

Windows.Devices.Sensors.Gyrometer API. Este exemplo
permite que o usuário exiba a velocidade angular ao longo
do eixo X, Y-e Z para um girômetro de 3 eixos.
Exemplo de SDK do aplicativo de dispositivo para Este exemplo mostra como criar um aplicativo de dispositivo
impressoras (Windows 8) para impressoras que podem ser ativadas no contrato de
bloco, o contrato printTaskSettings e do sistema de
notificação exibido por backgroundTask em resposta ao
evento de driver de impressão.
Exemplo de tarefa em segundo plano (Windows 8) Este exemplo mostra como criar e registrar tarefas em
segundo plano usando o Windows Runtime API de tarefa
em segundo plano. Uma tarefa em segundo plano é
disparada por um evento de sistema ou hora e pode ser
restrita por uma ou mais condições.
Exemplo de StreamSocket (Windows 8) Este exemplo demonstra os conceitos básicos da classe

StreamSocket usando os recursos de rede fornecidos pelo
Windows Runtime. O componente cliente do exemplo cria
um soquete TCP para fazer uma conexão de rede, usa o
soquete para enviar dados e muito mais.
Exemplo de notificações agendadas (Windows 8) Este exemplo mostra como usar atualizações de bloco
agendadas e recorrentes e notificações do sistema para um
aplicativo. Essa capacidade permite que você especifique um
tempo preciso para entregar a notificação, mesmo que o
aplicativo não esteja em execução.
Exemplo complementar do Gerenciador de reprodução Este exemplo demonstra como selecionar a categoria de
(Windows 8) msAudioCategory correta para um fluxo de vídeo de áudio
para configurá-lo como um fluxo de reprodução de áudio.
Exemplo de OrientationSensor (Windows 8) Este exemplo mostra como usar a

Windows.Devices.Sensors.OrientationSensor API. Ele
permite que o usuário exiba a matriz de rotação e os valores
de Quaternion que refletem a orientação atual do
dispositivo.
Exemplo de acesso a arquivos (Windows 8) Este exemplo mostra como criar, ler, gravar, copiar e excluir
um arquivo, como recuperar propriedades de arquivo e
como rastrear um arquivo ou pasta para que seu aplicativo
possa acessá-lo novamente. Este exemplo usa
Windows.Storage Windows.Storage.AccessCache API e.
Exemplo de armazenamento removível (Windows 8) O exemplo de armazenamento removível demonstra como

transferir arquivos de e para dispositivos de armazenamento
removíveis. Este exemplo requer um dispositivo de
armazenamento removível conectado ao sistema, como uma
câmera, um player de mídia, um telefone celular ou um pen
drive USB.
Amostra XAML SurfaceImageSource DirectX Interop Este exemplo demonstra como usar um
(Windows 8) SurfaceImageSource para incluir conteúdo do DirectX em
seu aplicativo XAML. Este exemplo usa C++ e C#.
Exemplo de conexão com WebSockets (Windows 8) Este exemplo demonstra como usar Websockets em um
aplicativo da Windows Store conectado. O exemplo aborda a
funcionalidade básica, como fazer uma conexão, enviar e
receber dados e fechar a conexão.
Configurar chaves para o exemplo de mídia (Windows 8) Este exemplo demonstra como configurar as chaves de mídia
de hardware em um teclado. Em seguida, como usar as
chaves configuradas para controlar um fluxo de vídeo de
áudio pressionando ou clicando em reproduzir, pausar, parar
e assim por diante.
Amostra de animações de personalidade XAML (Windows 8) Este exemplo demonstra como usar as animações de
personalidade internas em seu aplicativo.
Exemplo de notificações do sistema (Windows 8) Este exemplo mostra como usar notificações do sistema:
aquelas que aparecem como pop-up notificações no canto
superior direito da tela. Um usuário pode selecionar o
sistema de notificação (toque ou clique) para iniciar o
aplicativo associado.
Exemplo de aplicativo de seletor de contato (Windows 8) Este exemplo demonstra como usar o seletor de contatos
para selecionar um ou mais contatos. Ele também inclui uma
implementação básica das APIs de seletor de contato para
demonstrar como exibir uma lista de contatos para o
usuário.
Exemplo de jogo de labirinto de mármore DirectX (Windows Este exemplo demonstra como criar um jogo 3D básico
8) usando o DirectX. Esse jogo é um jogo simples de labirinto
em que o jogador é desafiador a lançar uma mármore por
meio de um labirinto de armadilhas usando controles de
inclinação.
Exemplo de aplicativo de cartão postal DirectX (Windows 8) Este exemplo demonstra a implementação de um aplicativo
simples da Windows Store usando o DirectX com C++ para
a criação de cartão postal usando DirectX e
interoperabilidade XAML.
Exemplo de jogo de captura do DirectX 3D (Windows 8) Este exemplo demonstra a implementação de um jogo
simples de primeira pessoa 3-D usando DirectX (Direct3D
11,1, Direct2D, XInput e XAudio2) em um aplicativo C++.
Exemplo de controle AppBar XAML (Windows 8) Este exemplo demonstra como usar o controle AppBar para
apresentar navegação, comandos e ferramentas aos
usuários. A barra de aplicativos fica oculta por padrão e
aparece quando os usuários passam um dedo da borda
superior ou inferior da tela.
Exemplo de formatação de data e hora (Windows 8) Este exemplo demonstra como usar a classe
DateTimeFormatter no
Windows.Globalization.DateTimeFormatting namespace
para exibir datas e horas de acordo com as preferências do
usuário.
Exemplo de blocos secundários (Windows 8) Este exemplo mostra como fixar e usar um bloco secundário.
Esse é um bloco que acessa diretamente uma seção
específica, não padrão ou uma experiência dentro de um
aplicativo, como um jogo salvo ou um amigo específico em
um aplicativo de rede social.
Exemplo de teste de inserção de toque de entrada (Windows Este exemplo usa um quebra-cabeça de formas de polígono
8) para demonstrar como tratar a entrada do ponteiro,
implementar testes de clique personalizados para entrada
por toque e manipulações de processo em um aplicativo da
Windows Store usando C++ e DirectX.
Exemplo de informações de rede (Windows 8) Este exemplo demonstra como usar as APIs de informações
de rede Windows Runtime.
Exemplo de entrada de tinta simplificada (Windows 8) Este exemplo demonstra como usar a funcionalidade de tinta
nos aplicativos da Windows Store.
Exemplo de StorageDataSource e GetVirtualizedFilesVector Este exemplo mostra como recuperar e exibir imagens na
(Windows 8) biblioteca de imagens do usuário.
Exemplo de invocação de gesto baseado em borda Este exemplo mostra como escutar eventos que ocorrem na
(Windows 8) interface do usuário baseada em borda, usando a
EdgeGesture classe.
Verificar se a sessão atual é um exemplo remoto (Windows Este exemplo demonstra o uso da
8) Windows.System.RemoteDesktop API.
Exemplo de recursos e localização de aplicativos (Windows 8) Este exemplo mostra como usar recursos de aplicativo para
separar conteúdo localizável do código do aplicativo. O
exemplo usa os
Windows.ApplicationModel.Resources.Core
Windows.Globalization namespaces e, e
WinJS.Resources .
Exemplo de menu de contexto (Windows 8) Este exemplo mostra como criar um menu de contexto e
como substituir o menu de contexto padrão por texto. Este
exemplo usa Windows.UI.Popups a API, incluindo o
PopupMenu e o evento oncontextmenu.
Exemplo de geolocalização (Windows 8) O exemplo de localização geográfica demonstra como usar a

API de geolocalização para obter a localização geográfica do
PC do usuário. Um aplicativo pode usar a API de
geolocalização para obter o local uma vez ou pode controlar
continuamente o local.
Exemplo de caixa de diálogo de mensagem (Windows 8) Este exemplo demonstra como usar um MessageDialog para
exibir caixas de diálogo, definir comandos e suas ações e
alterar o botão padrão. O Windows.UI.Popups namespace
contém a classe MessageDialog.
Exemplo de extensão de mídia MediaStreamSource Este exemplo mostra como dar suporte ao conceito de
(Windows 8) MediaStreamSource do Microsoft Silverlight em um
aplicativo da Windows Store.
Exemplo de texto vertical DirectWrite (Windows 8) Este exemplo usa DirectWrite e Direct2D para exibir
corretamente o texto vertical em uma forma de layout
personalizado.
Exemplo de rotação da cadeia de permuta DXGI (Windows 8) Este exemplo demonstra o método IDXGISwapChain1::
SetRotation e como você pode usar o método em conjunto
com conteúdo de rotação para melhorar o desempenho da
apresentação.
Exemplo de efeitos de imagem personalizada do Direct2D Este exemplo demonstra como implementar efeitos de
(Windows 8) Direct2D personalizados usando pixel, vértice e
sombreadores de computação padrão.
Exemplo de entrada do DirectX Touch (Windows 8) Este exemplo demonstra a navegação por toque e mouse de
um ambiente 3D em um aplicativo C++ com Direct3D.
Exemplo do XInput Game Controller (Windows 8) Este exemplo demonstra o uso das APIs XInput em um
aplicativo C++. Ele lê a entrada de um controlador de jogo
do Xbox e exibe dados sobre os movimentos de adesivo
analógico e pressionamentos de botão.
Exemplo de interoperabilidade do Direct3D-Direct2D Este exemplo mostra como interoperar com Direct2D e
(Windows 8) DirectWrite para gravar texto em um destino de
renderização do Direct3D. É uma maneira eficaz de criar
exibições de cabeçotes e de leitura baseadas em texto, como
painéis de pontuação em jogos e aplicativos 3-D.
Amostra de distribuição (Windows 8) Este exemplo demonstra um aplicativo básico da Windows

Store para Windows 8 que pode recuperar feeds de um
serviço Web. Este exemplo é fornecido atualmente nas
linguagens de programação JavaScript, C#, C++ e VB.
Exemplo de blocos e crachás do aplicativo (Windows 8) Este exemplo mostra como usar um bloco de aplicativo, que
é a representação e o ponto de partida para seu aplicativo
na tela inicial. Ele também mostra como usar uma notificação
nesse bloco. É um método para o aplicativo retransmitir
informações de status para o usuário quando o aplicativo
não está em execução.
Exemplo de usuário XAML e controles personalizados Este exemplo demonstra como criar e usar elementos XAML
(Windows 8) UserControl e criar controles personalizados para seus
projetos.
Exemplo de carregamento de recursos do Direct3D Este exemplo demonstra o carregamento de recursos do

(Windows 8) Direct3D para aplicativos C++ com DirectX.
ListView XAML e GridView Personalizando amostra de Este exemplo demonstra o modelo de interação do
interatividade (Windows 8) ListView controle.
Exemplo de controle de WebView XAML (Windows 8) Este exemplo demonstra como usar o WebView controle
para exibir uma URL, carregar HTML, interagir com o script
dentro de um WebView e usar o WebViewBrush .
Exemplo de sensor de bússola (Windows 8) Este exemplo demonstra como usar a

Windows.Devices.Sensors.Compass API. Este exemplo
permite que o usuário exiba a bússola de leitura como um
norte magnético e, dependendo do sensor instalado, um
valor real-norte.
Exemplo de orientação de tela (Windows 8) Este exemplo demonstra como usar a DisplayProperties
classe para definir a orientação de exibição em um aplicativo.
Exemplo de modos de interpolação Direct2D (Windows 8) Este exemplo mostra os vários modos de interpolação
usados pelo Direct2D.
Exemplo de preferências de globalização (Windows 8) Este exemplo demonstra como usar a

Windows.System.UserProfile.GlobalizationPreferences
classe para obter as preferências de globalização do usuário.
Ele também mostra como usar as GeographicRegion
classes e Language .
Exemplo de realização de geometria de Direct2D (Windows Este exemplo mostra como o mosaico de geometria de
8) vários núcleos pode ajudar a reduzir o tempo de
renderização de geometria. O uso de máscaras de opacidade
e malhas é uma alternativa à renderização de geometria
tradicional que pode ser melhor em algumas situações.
Exemplo de mapeamento de fonte de idioma (Windows 8) Este exemplo demonstra como obter recomendações de
fontes específicas de idioma usando a LanguageFontGroup
classe no Windows.Globalization.Fonts namespace.
Exemplo de sensor inclinômetro (Windows 8) Este exemplo mostra como usar a

Windows.Devices.Sensors.Inclinometer API. Este
exemplo permite que o usuário exiba os ângulos de
inclinação sobre o eixo X-, Y-e Z para um inclinômetro de 3
eixos.
Exemplo de estilo de alto contraste XAML (Windows 8) Este exemplo demonstra várias técnicas para implementar o
suporte para o modo de alto contraste em seu aplicativo. O
suporte para o modo de alto contraste é importante para
tornar seu aplicativo acessível a pessoas com problemas de
eyesight.
Exemplo de recursos de dispositivo de entrada (Windows 8) Este exemplo demonstra como consultar os dispositivos de
entrada que estão conectados ao dispositivo do usuário. E
como dar suporte aos modos de entrada ponteiro, toque,
caneta/caneta, mouse e teclado dos aplicativos da Windows
Store.
Exemplo de políticas EAS para clientes de email (Windows 8) Este exemplo mostra como os clientes de email podem
recuperar informações do dispositivo e trabalhar com
políticas de Exchange Active Sync (EAS) fornecidas. Os
aplicativos da Windows Store podem configurar seus clientes
de email para permanecer em conformidade com as políticas
EAS determinadas.
Exemplo de DatagramSocket (Windows 8) Este exemplo demonstra os conceitos básicos da

DatagramSocket classe usando os recursos de rede
fornecidos pelo Windows Runtime. O componente cliente do
exemplo cria um soquete UDP, usa o soquete para enviar e
receber dados e fecha o soquete.
Exemplo do DirectWrite Hello World (Windows 8) Este exemplo mostra como usar DirectWrite e Direct2D para
renderizar o texto "Olá, Mundo" em um CoreWindow .
Exemplo de compactação (Windows 8) Este exemplo demonstra como ler dados estruturados de
um arquivo e gravar dados compactados em um novo
arquivo e como ler dados compactados e gravar dados
descompactados em um novo arquivo. Muitos aplicativos
precisam compactar e descompactar dados.
Exemplo de plano de fundo de status de rede (Windows 8) Este exemplo demonstra como determinar uma alteração no
perfil de conexão com a Internet registrando um
manipulador de tarefa em segundo plano para o evento de
alteração de status da rede usando uma condição presente
da Internet.
Exemplo de informações do pacote de aplicativo (Windows Este exemplo mostra como obter informações de pacote
8) usando a API de empacotamento Windows Runtime. Os
usuários adquirem seu aplicativo da Windows Store como
um pacote de aplicativo. O Windows usa as informações em
um pacote de aplicativo para instalar o aplicativo por
usuário.
Exemplo de LightSensor (Windows 8) Este exemplo mostra como usar a

Windows.Devices.Sensors.LightSensor API. Este exemplo
permite que o usuário exiba a leitura de luz ambiente como
um valor LUX. Você pode escolher um dos dois cenários:
eventos de dados do LightSensor, leituras do sensor de luz
atual e muito mais.
Exemplo de provisionamento de conta de banda larga móvel Este exemplo demonstra como usar a API do agente de
(Windows 8) provisionamento de banda larga móvel do Windows 8 (
Windows.Networking.NetworkOperators.ProvisioningAgent
) para configurar o Windows 8 com as informações de
conectividade necessárias e o provisionamento de acesso.
Reprodução de mídia para amostra (Windows 8) Este exemplo demonstra a API Play to. Ele mostra como
você pode expandir seu aplicativo de mídia para transmitir
vídeo, áudio e imagens para outros dispositivos em sua rede
local.
Exemplo de teclado de toque de entrada (Windows 8) Este exemplo demonstra como iniciar o teclado de toque
automaticamente em controles personalizados que não são
derivados de controles de plataforma. O exemplo
implementa controles personalizados que exigem entrada de
teclado e não são derivados de controles XAML padrão.
Exemplo de biblioteca de animação XAML (Windows 8) Este exemplo demonstra como animar elementos e aplicar
funções de atenuação às animações para obter vários
efeitos.
Amostra de ajuste (Windows 8) O estado encaixado é um dos quatro Estados de exibição de

aplicativo possíveis. Ajustar um aplicativo redimensiona o
aplicativo para 320 pixels de largura, o que permite que ele
compartilhe a tela com outro aplicativo. O encaixe permite
que dois aplicativos fiquem visíveis ao mesmo tempo.
Exemplo de transcodificação de mídia (Windows 8) Este exemplo demonstra como usar a

Windows.Media.Transcoding API para transcodificar um
arquivo de vídeo em um aplicativo da Windows Store.
Transcodificação é a conversão de um arquivo de mídia
digital como, por exemplo, um arquivo de vídeo ou de áudio,
de um formato para outro.
Amostra de transformações XAML bidimensional (Windows Este exemplo demonstra como usar transformações
8) bidimensionais para modificar como os elementos são
exibidos em seu aplicativo. Uma transformação define como
mapear, ou transformar, pontos de um espaço de
coordenadas em outro espaço de coordenadas.
Exemplo de gravação de leitura de dados XML IXmlReader e Este exemplo demonstra como usar IXmlReader e
IXmlWriter (Windows 8) IXmlWriter em seu aplicativo da Windows Store com o
C++. Eles são usados para ler e gravar dados XML de um
arquivo de texto formatado em XML simples. Essas
interfaces fazem parte das APIs do Windows Win32 e COM,
mas têm suporte do Windows Runtime.
Captura de mídia usando o exemplo de dispositivo de Este exemplo demonstra como usar a MediaCapture API
captura (Windows 8) para capturar vídeo, áudio e imagens de um dispositivo de
captura, como uma webcam.
Exemplo de pop-up XAML (Windows 8) Este exemplo demonstra como criar e usar o elemento
Popup XAML em seus projetos.
Exemplo de CameraCaptureUI (Windows 8) Este exemplo demonstra como usar a

Windows.Media.Capture.CameraCaptureUI API, que exibe
uma interface do usuário de tela inteira para capturar fotos
ou vídeos. A interface do usuário de captura de câmera
fornece controles para alternar de foto para vídeo, um
temporizador para fazer fotos com atraso de tempo e muito
mais.
Exemplo de reprodução de arquivo de áudio XAudio2 Este exemplo demonstra o uso de XAudio2 em um
(Windows 8) aplicativo.
Exemplo do hilo C++ (Windows 8) Este exemplo demonstra como criar um aplicativo da
Windows Store completo usando C++ e XAML. O exemplo
de foto do hilo fornece orientação para desenvolvedores de
C++ que desejam criar um aplicativo do Windows 8 usando
C++, XAML e o Windows Runtime modernos.
Exemplo de processador de texto personalizado DirectWrite Este exemplo mostra como implementar um processador de
(Windows 8) texto personalizado para DirectWrite.
Exemplo de enumeração de fonte DirectWrite (Windows 8) Este exemplo mostra como usar DirectWrite para listar as
fontes na coleção de fontes do sistema em um dispositivo
do usuário.
Exemplo de transformação de perspectiva Direct2D Este exemplo mostra como usar a DrawBitmap API para
(Windows 8) exibir uma imagem com uma transformação de perspectiva
aplicada a ela.
Exemplo de CameraOptionsUI (Windows 8) Este exemplo demonstra como usar as opções de câmera em
um aplicativo de dispositivo. A CameraOptionsUI API exibe
uma interface do usuário para ajustar as configurações da
câmera. Este exemplo requer uma webcam.
Exemplo de reprodução do controlador de áudio XInput Este exemplo demonstra a reprodução de XAudio2 para um
(Windows 8) dispositivo XInput, como um headset, em um aplicativo.
Exemplo de efeito de transformação 3D Direct2D (Windows Este exemplo demonstra os diferentes métodos para
8) transformar uma imagem em um espaço 3D.
Exemplo de autorização de conta do Windows (Windows 8) Este exemplo demonstra como usar os membros do
Windows.Security.Authentication.OnlineId namespace
para autenticar um usuário com sua conta da Microsoft no
modo de delegação. E como enviar tokens adquiridos para
APIs do Live Connect usando o protocolo REST.
Exemplo de formatação de número e análise (Windows 8) Este exemplo demonstra como usar as DecimalFormatter
classes, CurrencyFormatter , PercentFormatter e
PermilleFormatter no
Windows.Globalization.NumberFormatting namespace.
Eles são usados para exibir e analisar números, moedas e
valores percentuais.
Exemplo de oferta e recuperação de recursos do DXGI Este exemplo demonstra o uso do DXGI
(Windows 8) IDXGIDevice2::OfferResources e
IDXGIDevice2::ReclaimResources APIs em um aplicativo
C++ com DirectX.
Exemplo de agente de autenticação da Web (Windows 8) Este exemplo demonstra a API do agente de autenticação da
Web WinRT. Ele permite que você habilite conexões de logon
único (SSO) para provedores OAuth como Facebook,
Google, Microsoft e Twitter.
Exemplo de efeito de fluxo de áudio XAudio2 (Windows 8) Este exemplo demonstra o streaming de áudio em um
aplicativo C++ usando as APIs XAudio2 e Media
Foundation.
Exemplo de tela inicial (Windows 8) Este exemplo mostra como imitar a tela inicial que o
Windows exibe para seu aplicativo, posicionando uma
imagem semelhante corretamente quando o Windows
ignora a tela inicial exibida.
Exemplo de tarefa de segundo plano do SMS (Windows 8) Este exemplo mostra como usar a API do SMS de banda
larga móvel do Windows 8 ( Windows.Devices.Sms ) com a
API de tarefa em segundo plano (
Windows.ApplicationModel.Background ) para enviar e
receber mensagens de texto SMS.
Exemplo de envio de mensagem do SMS, recebimento e Este exemplo mostra como usar a API de SMS de banda
gerenciamento de SIM (Windows 8) larga móvel do Windows 8 ( Windows.Devices.Sms ).
Exemplo de aplicativo de avaliação e compra no aplicativo Este exemplo demonstra como usar a API de licenciamento
(Windows 8) fornecida pela Windows Store para determinar o status da
licença de um aplicativo ou de um recurso habilitado por
uma compra no aplicativo.
Exemplo de entrada de texto do teclado de toque de entrada Este exemplo mostra como habilitar exibições otimizadas no
(Windows 8) teclado de toque. Ele funciona usando escopos de entrada e
tipos de entrada com controles no WinJS.UI namespace e
com os TextBox RichEdit controles e XAML.
Exemplo de edição de texto XAML (Windows 8) Este exemplo demonstra como usar controles de entrada de
texto em seu aplicativo.
Exemplo de pool de threads (Windows 8) Este exemplo mostra como executar itens de trabalho de
forma assíncrona usando a API do pool de threads Windows
Runtime.
Exemplo de provedor de janela de núcleo de automação da Este exemplo demonstra como criar um provedor de
interface do usuário (Windows 8) automação de interface do usuário da Microsoft. Ele
disponibiliza informações programáticas sobre um aplicativo
da Windows Store para tecnologias acessíveis, como leitores
de tela. O exemplo é um aplicativo Direct2D.
Exemplo de acessibilidade XAML (Windows 8) Este exemplo mostra como adicionar suporte básico de
acessibilidade ao seu aplicativo.
Exemplo de playlist (Windows 8) Este exemplo demonstra como criar, salvar, exibir e editar
uma lista de reprodução de arquivos de áudio. Este exemplo
usa classes que estão no Windows.Media.Playlists
namespace.
Exemplo de cliente de servidor de mídia (Windows 8) Este exemplo demonstra como criar um cliente de servidor
de mídia usando a API do servidor de mídia. O exemplo de
servidor de mídia demonstra como procurar um servidor de
mídia digital programaticamente em sua rede local e exibir
todos os seus arquivos de vídeo.
Exemplo de aplicativo do Direct2D Magazine (Windows 8) Este exemplo mostra como usar Direct2D, DirectWrite,
Windows Imaging Component (WIC) e XAML para criar um
aplicativo com uma apresentação de tipo de revista.
Exemplo de conta de banda larga móvel e gerenciamento de Este exemplo mostra como usar a API de banda larga móvel
dispositivos (Windows 8) do Windows 8 ( Windows.Networking.NetworkOperators )
empregada por MNO (operadores de rede móvel). Ele
demonstra como usar as APIs MobileBroadbandAccount
para recuperar e exibir contas de banda larga móvel
disponíveis.
Exemplo de proximidade (Windows 8) Este exemplo demonstra como usar as PeerFinder classes
e ProximityDevice para se comunicar com computadores
próximos. Você pode usar a Proximity API para trocar
mensagens pequenas durante um gesto de toque ou
configurar uma conexão de soquete entre aplicativos pares.
Criando um Windows Runtime exemplo de componente em Este exemplo mostra como criar um componente em
processo (C + + CX) (Windows 8) C++/CX que é usado em C++/CX, JavaScript e código de
cliente C#. O projeto OvenServer contém uma classe de
tempo de execução chamada Oven , que implementa uma
IOven interface e uma IAppliance interface.
Exemplo de preferências de rotação automática do Este exemplo mostra como usar a DisplayProperties
dispositivo (Windows 8) classe para tratar e verificar eventos de rotação do
dispositivo.
Exemplo de comunicação em tempo real (Windows 8) Este exemplo demonstra como usar o recurso de baixa
latência para habilitar aplicativos de comunicação em tempo
real.
Exemplo de compartilhamento de aplicativo de origem de Este exemplo demonstra como um aplicativo pode
conteúdo (Windows 8) compartilhar conteúdo com outro aplicativo. Este exemplo
usa classes do Windows.ApplicationModel.DataTransfer
namespace.
Exemplo de contrato de pesquisa (Windows 8) Este exemplo mostra como permitir que os usuários
pesquisem seu aplicativo quando selecionam o botão
Pesquisar e abrem o painel de pesquisa. E, como usar o
painel de pesquisa para exibir sugestões para as consultas
dos usuários.
Exemplo de notificações brutas (Windows 8) Este exemplo mostra como usar notificações brutas, que são
notificações por push sem nenhuma interface do usuário
associada que executa uma tarefa em segundo plano para o
aplicativo.
Exemplo de efeitos de imagem básica do Direct2D (Windows Este exemplo mostra como carregar uma imagem, aplicar o
8) efeito de desfoque gaussiano a ela e, em seguida, exibi-la em
um Windows::UI::Core::CoreWindow .
Exemplo de efeitos de Direct2D no primitivos (Windows 8) Este exemplo mostra como aplicar efeitos de imagem a
primitivos Direct2D. Este exemplo desenha retângulos
arredondados usando Direct2D e, em seguida, desenha o
texto de DirectWrite no meio dos retângulos. Em seguida,
ele aplica um grafo de efeito a ele.
Exemplo de StreamSocket de ControlChannelTrigger O exemplo mostra como usar a ControlChannelTrigger

(Windows 8) classe em um aplicativo da Windows Store. Ele usa um TCP
StreamSocket , portanto, o aplicativo sempre está
conectado e sempre pode ser acessado. Este exemplo
demonstra o uso de notificações de rede em segundo plano.
Exemplo de StreamWebSocket de ControlChannelTrigger O exemplo mostra como usar a ControlChannelTrigger

(Windows 8) classe para habilitar um aplicativo da Windows Store usando
um StreamWebSocket para estar sempre conectado e
sempre acessível. Este exemplo demonstra o uso de
notificações de rede em segundo plano.
Exemplo de inicialização de associação (Windows 8) Este exemplo mostra como iniciar o aplicativo padrão do
usuário para o tipo de arquivo ou um protocolo. Você
também pode aprender como habilitar seu aplicativo para
ser o aplicativo padrão para um tipo de arquivo ou um
protocolo.
Exemplo de AtomPub (Windows 8) Este exemplo demonstra como acessar, criar, atualizar e
remover feeds de conteúdo agregados da Web. Ele usa a
implementação Windows Runtime do padrão de publicação
Atom.
Exemplo de registro de certificado (Windows 8) Este exemplo demonstra como criar e registrar um
certificado em uma hierarquia de certificação. Para obter
uma cópia de avaliação do Windows 8, vá para o Windows 8.
Para obter uma cópia de avaliação do Microsoft Visual Studio
2012, vá para o Visual Studio 2012.
Exemplo de aplicativo da área de transferência (Windows 8) Este exemplo demonstra como um aplicativo pode usar
comandos da área de transferência, incluindo copiar, colar,
recortar e mover. Este exemplo usa classes do
Windows.ApplicationModel.DataTransfer namespace.
Exemplo de modos de efeito composto Direct2D (Windows Este exemplo mostra a ampla variedade de modos
8) compostos e de mistura disponíveis em Direct2D.
Exemplo de mapeamento de choque de Direct3D (Windows Este exemplo demonstra o mapeamento de relevo usando
8) um mapa normal e iluminação por pixel.
Detalhes do calendário e exemplo de matemática (Windows Este exemplo demonstra como usar a Calendar classe no
8) Windows.Globalization namespace para manipular e
processar datas com base em um sistema de calendário e as
preferências de globalização do usuário.
Exemplo de enumeração de dispositivo (Windows 8) Este exemplo mostra como usar a API de enumeração de
dispositivo para localizar os dispositivos disponíveis e
procurar informações do dispositivo. O exemplo apresenta
dois cenários: no primeiro cenário, a API de enumeração de
dispositivo é usada para procurar interfaces de dispositivo
específicas.
Exemplo de texto de parágrafo DirectWrite (Windows 8) Este exemplo mostra como usar DirectWrite e Direct2D para
renderizar texto de parágrafo para um CoreWindow . E,
aplique a justificativa e o espaçamento de caracteres ao
layout.
Respondendo à aparência do exemplo de teclado na tela [Esta documentação é preliminar e está sujeita a alterações.]
(Windows 8) Este exemplo mostra como escutar e responder à aparência
do teclado virtual na tela. Quando o foco é dado a um
elemento que requer entrada de texto em um dispositivo
que não tem um teclado.
Exemplo de vinculação de dados XAML (Windows 8) Este exemplo demonstra técnicas básicas de vinculação de
dados usando a classe Binding e a extensão de marcação
Binding.
Exemplo de tutorial do Direct3D (Windows 8) Este exemplo é um tutorial de cinco lições. Ele fornece uma
introdução à API do Direct3D e apresenta os conceitos e o
código usados em muitos dos outros exemplos do DirectX.
Exemplo de aplicativo de ajuste de foto de efeitos Direct2D Este exemplo mostra várias técnicas comuns de manipulação
(Windows 8) de fotos usando efeitos Direct2Ds. Este exemplo é dividido
em várias partes. Lição 1: mostra as noções básicas de como
carregar e desenhar uma imagem usando efeitos de
Direct2D.
Exemplo de sessão de áudio do Windows (WASAPI) Demonstra como realizar várias tarefas relacionadas a áudio
(Windows 8) usando a API de sessão de áudio do Windows (WASAPI).
Exemplo de nome de domínio do usuário (Windows 8) Este exemplo demonstra a funcionalidade relacionada ao
domínio fornecida pela UserInformation classe do
Windows.System.UserProfile namespace. A classe
UserInformation permite que um aplicativo obtenha e defina
informações sobre o usuário.
Exemplo de gerenciamento de mensagens USSD (Windows Este exemplo demonstra o gerenciamento de conta de rede
8) usando o protocolo USSD com dispositivos de banda larga
móvel compatíveis com GSM. USSD é normalmente usado
para gerenciamento de conta de um perfil de banda larga
móvel pelo operador de rede móvel (MNO).
Amostra do otimizador de viagens do Bing Maps (Windows O exemplo demonstra como usar o JavaScript e o Visual
8) C++ e criar o aplicativo para o Windows 8 denominado
otimizador de viagens do Bing Maps. O otimizador de
viagens do Bing Maps usa JavaScript para definir a interface
do usuário e o C++ para um algoritmo de custo
computacional em paralelo.
Texto animado de Direct2D e DirectWrite em um exemplo de Este exemplo mostra como usar Direct2D e DirectWrite para
caminho (Windows 8) renderizar uma cadeia de caracteres de texto ao longo de
um caminho geométrico animado e não linear. O aplicativo
renderiza "Olá, mundo!" repetidas várias vezes em idiomas
diferentes ao longo de uma curva de Bézier.
Exemplo de autenticação de hotspot Wi-Fi (Windows 8) Este exemplo demonstra como usar a API de banda larga
móvel do Windows 8 (
Windows.Networking.NetworkOperators ) para
autenticação Wi-Fi HotSpot. Use esse mecanismo como uma
alternativa para configurar credenciais estáticas para um
ponto de Wi-Fi HotSpot.
Exemplo de imagens XAML (Windows 8) Este exemplo demonstra várias técnicas para exibir e
manipular imagens em seu aplicativo usando o controle
Image e a classe BitmapImage.
Exemplo de aplicativo de grupo doméstico (Windows 8) Este exemplo demonstra como usar um HomeGroup para
abrir, Pesquisar e compartilhar arquivos. Este exemplo usa
algumas das HomeGroup opções encontradas no e no
Windows.Storage.Pickers
Windows.Storage.KnownFolders .
Exemplo de contraste e configurações da interface do Este exemplo mostra como usar as APIs de configurações da
usuário (Windows 8) interface do usuário em um aplicativo C# ou JavaScript
básico.
Exemplo de enumeração de pasta (Windows 8) Este exemplo mostra como listar os arquivos e as pastas de
nível superior dentro de um local. (Por exemplo, uma pasta,
um dispositivo ou um local de rede.) E como usar consultas
para listar todos os arquivos dentro de um local
classificando-os em grupos de arquivos.
Exemplo de seletor de arquivo (Windows 8) Este exemplo mostra como acessar arquivos e pastas,
permitindo que o usuário os escolha por meio dos seletores
de arquivos. E como salvar um arquivo para que o usuário
possa especificar o nome, o tipo de arquivo e o local de um
arquivo a ser salvo.
Exemplo de contratos de seletor de arquivo (Windows 8) Este exemplo mostra como um aplicativo pode fornecer
arquivos, um local de salvamento e atualizações de arquivo
em tempo real para outros aplicativos por meio do seletor
de arquivos. Isso é feito participando do contrato de seletor
de abertura de arquivo, contrato de seletor de salvamento
de arquivo e contrato de atualizador de arquivo em cache.
Exemplo de pesquisa de arquivo programático (Windows 8) Este exemplo mostra como consultar arquivos em locais
como uma pasta, uma biblioteca, um dispositivo ou um local
de rede. Ele usa a Windows.Storage.Search API. As APIs
importantes neste exemplo incluem: QueryOptions classe,
StorageFileQueryResult classe e outras.
Exemplo de miniatura de arquivo e pasta (Windows 8) Este exemplo mostra como recuperar miniaturas de arquivos
e pastas. Ele usa a Windows.Storage.FileProperties API.
Exemplo de manipulações de entrada e gestos (C++) Este exemplo demonstra como manipular a entrada do
(Windows 8) ponteiro e as manipulações de processo e os gestos com as
GestureRecognizer APIs em um aplicativo da Windows
Store usando C++ e DirectX.
Exemplo do gerador de fractal do Direct3D HLSL (Windows Este exemplo demonstra o uso de sombreadores de
8) computação Direct3D HLSL e DirectCompute para criar
imagens de fractal.
Exemplo de efeitos de iluminação de Direct2D XAML Este exemplo demonstra os efeitos de iluminação disponíveis
(Windows 8) em efeitos de Direct2D. As propriedades de efeito de
iluminação são controladas por controles de interface XAML
e, em seguida, exibidas usando Direct2D por meio de um
SwapChainBackgroundPanel XAML.
Exemplo de impressão Direct2Dapp (Windows 8) Este exemplo demonstra como adicionar suporte de
impressão Direct2D a um aplicativo da Windows Store. Este
exemplo mostra como usar os recursos do Direct2D para
renderizar o conteúdo de um aplicativo da Windows Store
para impressão. E como enviar o conteúdo renderizado para
a impressora.
Exemplo de imagens e efeitos de impressão Direct2D Este exemplo demonstra como imprimir imagens Direct2D e
(Windows 8) efeitos de Direct2D em um aplicativo da Windows Store.
Exemplo de texto animado Direct2D (Windows 8) Este exemplo mostra como renderizar texto rapidamente
usando o método Direct2D FillOpacityMask . O exemplo
também responde ao toque. Um pinça de dois dedos pode
ser usado para ampliar e reduzir o texto.
Exemplo de efeitos pós-processamento do Direct3D Este exemplo demonstra o pós-processamento do Direct3D

(Windows 8) 11,1 em uma cena simples do cubo rotativo, usando buffers
intermediários em escala horizontal.
Exemplo de ELS (serviços lingüísticos estendidos) (Windows Este exemplo demonstra o uso de ELS (serviços lingüísticos
8) estendidos) em um aplicativo da Windows Store. O exemplo
implementa cenários que demonstram o uso dos três
serviços ELS disponíveis. Os cenários demonstram como
solicitar um serviço específico.
Exemplo de teste de clique DirectWrite (Windows 8) Este exemplo mostra como usar os recursos de teste de
clique do DirectWrite. Eles são usados para determinar qual
parte do texto exibido está sendo clicado ou tocado.
Exemplo de objeto embutido DirectWrite (Windows 8) Este exemplo mostra como inserir um objeto embutido em
um layout de texto, como uma imagem.
Amostra de desenho baseado em vetor XAML (Windows 8) Este exemplo demonstra como desenhar gráficos baseados
em vetor em seu aplicativo.
Exemplo de controle de chamada Bluetooth (Windows 8) O exemplo de Bluetooth CallControl demonstra como
configurar o dispositivo de comunicações Bluetooth padrão
para manipular chamadas. Há as versões JavaScript, C#, C++
e VB.Net deste exemplo. Este exemplo requer conhecimento
de eventos do Windows e manipulação de eventos.
Exemplo de lista de comandos Direct2D (Windows 8) Este exemplo demonstra o uso de uma lista de comandos.
Ele é usado para gravar um conjunto de comandos de vetor,
criar um pincel de imagem na lista de comandos e, em
seguida, preencher uma geometria de retângulo com ele. A
lista de comandos preserva a independência de resolução do
vetor.
Exemplo de XMLHttpRequest de ControlChannelTrigger O exemplo mostra como usar a ControlChannelTrigger

(Windows 8) classe para habilitar um aplicativo da Windows Store usando
o IXMLHTTPRequest2 para estar sempre conectado e
sempre acessível. Este exemplo demonstra o uso de
notificações de rede em segundo plano em um aplicativo da
Windows Store.
Exemplo de esboço do controlador JavaScript e XInput Este exemplo demonstra como encapsular a API do XInput
(Windows 8) C++ em um componente Windows Runtime. Em seguida,
ele o chama de um aplicativo da Windows Store usando
JavaScript. Este exemplo implementa um aplicativo de
esboço que permite que você use o controlador de jogo do
Xbox para selecionar a espessura da linha e muito mais.
Exemplo de efeito de matriz Direct2D convolve (Windows 8) Este exemplo demonstra o efeito de Direct2D efeitos de
matriz convolve. Este exemplo tem algumas matrizes de
kernel de convolução de exemplo: passagem (sem operação),
Desfoque de caixa (largura 5), detecção de borda simples,
nitidez simples, relevo, mancha vertical (altura 10)
contratando e mais.
Exemplo de implementação da cadeia de permuta do DirectX Este exemplo mostra como receber CoreWindow eventos
(Windows 8) em um aplicativo nativo e como conectar uma cadeia de
permuta do DirectX à exibição do aplicativo.
Exemplo de selecionador de credenciais (Windows 8) Este exemplo mostra como usar a

Windows.Security.Credentials.UI.CredentialPicker
classe para recuperar credenciais. Essas credenciais podem
ser passadas para APIs que as exigem, por exemplo,
HttpClient .
Exemplo de animação Direct2D (Windows 8) Este exemplo mostra como usar Direct2D para renderizar e
animar um primitivo Direct2D ao longo de um caminho de
espiral.
Exemplo de compartilhamento de aplicativo de destino de Este exemplo demonstra como um aplicativo pode receber
conteúdo (Windows 8) conteúdo compartilhado de outro aplicativo. Este exemplo
usa classes dos Windows.ApplicationModel.DataTransfer
Windows.ApplicationModel.DataTransfer.Share
namespaces e.
Exemplo de Direct2D salvar no arquivo de imagem Este exemplo mostra como renderizar para a tela usando
(Windows 8) Direct2D e DirectWrite. E como salvar a imagem renderizada
em disco usando a API do WIC.
Dimensionamento de acordo com o exemplo de DPI Este exemplo descreve como criar um aplicativo que é
(Windows 8) dimensionado de acordo com a densidade de pixel da tela.
Ele carrega imagens da escala direita ou substitui o
dimensionamento padrão. Este exemplo usa a
Windows.Graphics.Display API.
Criando um Windows Runtime exemplo de componente em Este exemplo mostra como criar um componente em C# que
processo (C#) (Windows 8) é usado em C++/CX, JavaScript e código de cliente C#. O
projeto OvenServer contém uma classe de tempo de
execução chamada Oven , que implementa uma IOven
interface e uma IAppliance interface.
Exemplo do lado do cliente de notificações periódicas e por Este exemplo mostra como um aplicativo cliente pode se
push (Windows 8) registrar e escutar notificações por push enviadas de um
servidor Web. As notificações por push podem ser usadas
para atualizar um selo ou um bloco, gerar uma notificação
do sistema ou iniciar uma tarefa em segundo plano.
Exemplo de API de dispositivo portátil (Windows 8) Este exemplo mostra como acessar a IPortableDevice API
com de um aplicativo C++. Para saber como acessar a
IPortableDevice API com de um aplicativo C++ de área
de trabalho, consulte o exemplo de API com de dispositivos
portáteis.
Exemplo de PlayToReceiver (Windows 8) Este exemplo demonstra como criar um software de

reprodução para o destinatário. Para anunciar o software
tocar no destinatário, clique no botão iniciar destinatário.
Para parar o receptor, clique no botão parar destinatário.
Exemplo de personalização da tela de bloqueio (Windows 8) Este exemplo demonstra como usar a LockScreen API para
definir a imagem da tela de bloqueio do usuário atual. Este
exemplo usa classes do Windows.System.UserProfile
namespace.
Exemplo de armário de credenciais (Windows 8) Este exemplo demonstra como usar as APIs do WinRT
PasswordVault e como usar o BitLocker de credencial para
armazenar credenciais da Web. Cenários específicos incluem
um único usuário com um único recurso e vários usuários
com um único recurso.
Amostra de reprodução de vídeo C++ do mecanismo de Este exemplo demonstra a reprodução de vídeo usando a
mídia nativo (Windows 8) MediaEngine API em um aplicativo C++ nativo.
Exemplo de extensões de mídia (Windows 8) Este exemplo demonstra como usar extensões de mídia.
Você pode aplicar efeitos ao vídeo, decodificar vídeo e criar
fluxos de mídia usando manipuladores de esquema.
Exemplo de aplicativos de tela de bloqueio (Windows 8) Este exemplo mostra como um aplicativo pode ter uma
presença na tela de bloqueio — a tela que é mostrada
quando o computador está bloqueado — com uma
notificação para fornecer informações de status básicas ou
um bloco para fornecer um status mais detalhado.
Exemplo de exibição de texto XAML (Windows 8) Este exemplo demonstra como controlar a aparência do
texto em seu aplicativo.
Exemplo de SimpleOrientationSensor (Windows 8) Este exemplo mostra como usar a

Windows.Devices.Sensors.SimpleOrientationSensor API.
Exemplo do Direct3D Sprite (Windows 8) Este exemplo fornece uma implementação de Direct3D de
comportamentos de lote Sprite, semelhante à SpriteBatch
API XNA. Sprites são bitmaps 2D que podem ser
transformados e gerenciados de forma independente em
uma cena 3D, normalmente usados em jogos de 2-d.
Exemplo do Direct3D estereoscópico 3D (Windows 8) Este exemplo demonstra como adicionar um efeito de 3D
estereoscópico a aplicativos C++ usando o Direct3D. Ele
também demonstra como responder às alterações do
sistema estéreo no Direct3D. O efeito de 3D estereoscópico
requer uma exibição que ofereça suporte a estéreo 3-D.
Criando um componente Windows Runtime DLL com C++ Este exemplo mostra como criar um componente DLL em
Sample (Windows 8) processo no Microsoft Visual C++. Ele é usado em C++/CX,
JavaScript e código de cliente C#. O projeto OvenServer
contém uma classe de tempo de execução chamada Oven ,
que implementa uma IOven interface.
Criando um componente Windows Runtime EXE com C++ Este exemplo mostra como criar um componente EXE fora
Sample (Windows 8) do processo no Microsoft Visual C++. Ele é usado em
C++/CX, JavaScript e código de cliente C#. O projeto
OvenServer contém uma classe de tempo de execução
chamada Oven , que implementa uma IOven interface.
Ajuda e comunidade do Microsoft C/C++
Aqui está onde obter ajuda e informações sobre como escrever código C++ e usar as ferramentas de
desenvolvimento do Visual Studio.
Exemplos
Exemplos de código para desenvolvedores: contém código de exemplo para download da Microsoft e
colaboradores da Comunidade.
Documentação do produto
C++ no Visual Studio: contém referência e documentação conceitual sobre Visual C++.
Centro de desenvolvedores do Windows: contém informações sobre como usar o C++ e outras
linguagens para desenvolver aplicativos para o Windows 10.
Documentação online e offline
Você pode exibir o conteúdo de desenvolvedor online da Microsoft. Este conteúdo é atualizado regularmente.
Você também pode baixar e exibir o conteúdo localmente no Visualizador da Ajuda offline. A documentação
offline é organizada por livros de conteúdo relacionado, que também são atualizados periodicamente. Você
pode baixar os livros do seu interesse à medida que se tornarem disponíveis. Para obter mais informações,
consulte Microsoft Help Viewer.
Muitas seções da documentação também estão disponíveis em formato PDF. Essas seções têm um link baixar
PDF abaixo do sumário em docs.Microsoft.com.
Sites relacionados
Blog da equipe do c++: contém postagens em vários assuntos de especialistas da equipe de produtos
C++ da Microsoft.
Channel 9: contém entrevistas e palestras em vídeo. Use a caixa de pesquisa na página inicial do Channel
9 para localizar o conteúdo do C++.
Site do Visual Studio: contém artigos e notícias sobre o Visual Studio e as ferramentas de
desenvolvimento relacionadas. Esse site também hospeda os downloads do Visual Studio e os arquivos
redistribuíveis.
Microsoft docs Q&A: fóruns oficiais da Microsoft, onde você pode postar perguntas sobre C++ e Visual
Studio e obter respostas da Microsoft e de especialistas na Comunidade.
Comunidade de desenvolvedores do Visual Studio C++: fóruns para relatar problemas no compilador e
nas ferramentas do c++ ou no IDE, ou para fazer sugestões de produtos. Você pode votar em suas ideias
favoritas ou relatórios de bugs ou adicionar um novo. Este site é monitorado pela equipe de
desenvolvimento.
Como relatar um problema com o conjunto de
ferramentas ou a documentação do Microsoft C++
Se você encontrar problemas no compilador, no vinculador ou em outras ferramentas e bibliotecas do Microsoft

C++ (MSVC), vamos querer saber sobre eles. Quando o problema está em nossa documentação, queremos
saber sobre isso também.
Como relatar um problema de conjunto de ferramentas do C++

A melhor maneira de nos informar sobre um problema é enviar um relatório que inclua uma descrição do
problema que você descobriu. Ele precisa ter todos os detalhes sobre como criar o seu programa. E tem que
incluir uma reprodução, um caso de teste completo que possamos usar para reproduzir o problema em nossos
computadores. Essas informações nos permitem verificar rapidamente se o problema está em seu código e não
em seu ambiente local. Ele ajuda a determinar se ele afeta outras versões do compilador e diagnosticar a causa.
Nas seções a seguir, você poderá ler sobre o que faz um bom relatório. Descrevemos como gerar uma
reprodução para o tipo de problema encontrado e como enviar seu relatório para a equipe de produto. Os
relatórios são importantes para nós e para outros desenvolvedores como você. Obrigado por nos ajudar a
melhorar o Microsoft C++!
Como preparar seu relatório

É importante criar um relatório de alta qualidade, porque é difícil para nós reproduzirmos o problema
encontrado sem informações completas. Quanto melhor for seu relatório, mais efetivamente poderemos recriar
e diagnosticar o problema.
No mínimo, o relatório precisa conter:
As informações de versão completas do conjunto de ferramentas que você está usando.
A linha de comando completa cl.exe usada para compilar seu código.
Uma descrição detalhada do problema encontrado.
Uma reprodução: um exemplo de código-fonte completo, simplificado e independente que demonstra o
problema.
Continue lendo para saber mais sobre as informações específicas necessárias, onde você pode encontrá-las e
sobre como criar uma boa reprodução.
A versão do conjunto de ferramentas
Precisamos de informações completas de versão e a arquitetura de destino do conjunto de ferramentas que
causa o problema. Isso serve para que possamos testar sua reprodução com o mesmo conjunto de ferramentas
em nossos computadores. Se pudermos reproduzir o problema, essas informações também nos fornecerão um
ponto de partida para investigar quais outras versões do conjunto de ferramentas têm o mesmo problema.
Para relatar a versão completa de seu compilador
1. Abra o Prompt de Comando do Desenvolvedor correspondente à arquitetura de versão e à
configuração do Visual Studio usada para compilar o projeto. Por exemplo, se você compila usando o
Visual Studio de 2017 em x64 para destinos x64, escolha Prompt de Comando de Ferramentas
Nativas do x64 para VS 2017 . Para obter mais informações, consulte Atalhos de prompt de comando
do desenvolvedor.
2. Na janela do console de prompt de comando do desenvolvedor, insira o comando cl /Bv .
A saída deverá ser parecida com:
C:\Users\username\Source>cl /Bv
Microsoft (R) C/C++ Optimizing Compiler Version 19.14.26428.1 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Compiler Passes:
C:\Program Files (x86)\Microsoft Visual
Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\cl.exe: Version 19.14.26428.1
Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\c1.dll: Version 19.14.26428.1
Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\c1xx.dll: Version 19.14.26428.1
Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\c2.dll: Version 19.14.26428.1
Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\link.exe: Version 14.14.26428.1
Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\mspdb140.dll: Version 14.14.26428.1
Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\1033\clui.dll: Version 19.14.26428.1
cl : Command line error D8003 : missing source filename
Copie e cole toda a saída em seu relatório.

A linha de comando
Precisamos da linha de comando exata, cl.exe e todos os argumentos usados para compilar seu código. Isso
serve para que possamos compilá-lo exatamente da mesma forma em nossos computadores. É importante
porque o problema que você encontrou pode existir apenas ao compilar com um determinado argumento ou
combinação de argumentos.
O melhor lugar para localizar essas informações é o log de build imediatamente após você passar pelo
problema. Isso garante que a linha de comando contenha exatamente os mesmos argumentos que podem
contribuir para o problema.
Para relatar o conteúdo da linha de comando
1. Localize o arquivo CL.command.1.tlog e abra-o. Por padrão, esse arquivo está localizado em sua pasta
documentos no \ Visual Studio versão \ projetos \ SolutionName \ ProjectName \ Configuration \
ProjectName. tlog \ CL. Command. 1. tlog ou em sua pasta User em \ Source \ repositórios \
SolutionName \ ProjectName \ Configuration \ ProjectName. tlog \ CL. Command. 1. tlog. Ele pode estar
em um local diferente se você usa outro sistema de compilação ou se alterou o local padrão para seu
projeto.
Dentro desse arquivo, você encontrará os nomes dos arquivos de seu código-fonte seguidos pelos
argumentos de linha de comando usados para compilá-los, cada um em linhas separadas.
2. Localize a linha que contém o nome do arquivo de código fonte onde o problema ocorre. A linha abaixo
dela contém os argumentos de comando cl.exe correspondentes.
Copie e cole toda a linha de comando em seu relatório.
Uma descrição do problema
Precisamos de uma descrição detalhada do problema encontrado. Isso serve para que possamos garantir que
teremos o mesmo efeito em nossos computadores. Também é útil às vezes que saibamos o que você estava
tentando fazer e o que você esperava que acontecesse.
Uma boa descrição fornece as mensagens de erro exatas emitidas pelo conjunto de ferramentas ou o
comportamento de runtime exato que você vir. Precisamos dessas informações para confirmar se reproduzimos
o problema corretamente. Inclua toda a saída do compilador, não apenas a última mensagem de erro.
Precisamos ver tudo o que levou ao problema relatado. Se você puder duplicar o problema usando o
compilador de linha de comando, essa saída do compilador é o que preferimos. O IDE e outros sistemas de
compilação podem filtrar as mensagens de erro que você vê ou capturar somente a primeira linha de uma
mensagem de erro.
Se o problema é que o compilador aceita código inválido e não gera um diagnóstico, inclua isso em seu
relatório.
Para relatar um problema de comportamento de runtime, inclua uma cópia exata do que o programa imprime
e o que você espera ver. Idealmente, você vai inserir isso na saída da instrução em si, por exemplo,
printf("This should be 5: %d\n", actual_result); . Se o programa falhar ou travar, mencione isso também.
Adicione outros detalhes que puderem nos ajudar a diagnosticar o problema encontrado, como soluções
alternativas que você possa ter descoberto. Evite repetir informações encontradas em outro lugar no relatório.
A reprodução
Uma reprodução é um exemplo de código-fonte completo e independente. Ela demonstra o problema
encontrado de forma reproduzível, por isso o nome. Precisamos de uma reprodução para que possamos
reproduzir o erro em nossos computadores. O código deve ser suficiente por si só para criar um executável
básico que compila e executa. Ou que compilaria e executaria caso você não encontrasse o problema. Uma
reprodução não é um snippet de código. Ela deve ter classes e funções completas e conter todas as diretivas
#include necessárias, mesmo para os cabeçalhos padrão.
O que compõe uma boa reprodução
Uma boa reprodução é:
Muito. As reproduções devem ter o menor tamanho possível enquanto ainda demonstram exatamente o
problema encontrado. As reproduções não precisam ser complexas ou realistas. Elas precisam apenas
mostrar o código que está em conformidade com o padrão ou para a implementação documentada do
compilador. Caso não haja um diagnóstico, sua reprodução deve mostrar o código que não é compatível.
As reproduções simples e objetivas, contendo apenas o código necessário para demonstrar o problema,
são as melhores. Se você puder eliminar ou simplificar o código de modo que ele permaneça compatível
e deixe o problema inalterado, faça isso. Não é necessário incluir contraexemplos de códigos que
funcionam.
Independente. As reproduções devem evitar dependências desnecessárias. Se você puder reproduzir o
problema sem bibliotecas de terceiros, faça isso. Se puder reproduzir o problema sem nenhum código de
biblioteca além de instruções de saída simples (por exemplo, puts("this shouldn't compile"); ,
std::cout << value; e printf("%d\n", value); ), faça isso. O ideal é que o exemplo possa ser
condensado em um único arquivo de código-fonte, sem referência a nenhum cabeçalho de usuário.
Reduzir a quantidade de código que precisamos considerar como um possível colaborador para o
problema é extremamente útil para nós.
Com a versão mais recente do compilador. As reproduções devem usar a atualização mais recente
da versão mais recente do conjunto de ferramentas sempre que possível. Ou use a versão mais recente
de pré-lançamento da próxima atualização ou da próxima versão principal. Em versões mais recentes, os
problemas que podem ocorrer nas versões mais antigas do conjunto de ferramentas frequentemente
foram corrigidos. As correções são implementadas em versões mais antigas apenas em circunstâncias
excepcionais.
Comparadas com outros compiladores , se for relevante. As reproduções que envolvem código C++
portátil devem verificar o comportamento em relação a outros compiladores se possível. O padrão C++
acaba por determinar a correção do programa e nenhum compilador é perfeito. No entanto, quando o
Clang e o GCC aceitam seu código sem um diagnóstico e o MSVC não, você provavelmente encontrou
um bug em nosso compilador. (Outras possibilidades incluem diferenças no comportamento do UNIX e
do Windows, ou níveis diferentes de implementação de padrões do C++ e assim por diante.) Quando
todos os compiladores rejeitam seu código, é provável que seu código esteja incorreto. Ver mensagens
de erro diferentes pode ajudá-lo a diagnosticar o problema por conta própria.
Você pode encontrar listas de compiladores online nos quais pode testar seu código em Compiladores
C++ Online no site do ISO C++ ou nesta Lista de Compiladores C++ Online no GitHub. Alguns exemplos
específicos incluem o Wandbox e o Gerenciador do compilador.
NOTE
Os sites de compiladores online não são afiliados à Microsoft. Muitos sites de compilador online são executados
como projetos pessoais. Alguns desses sites podem estar indisponíveis quando você ler isto, mas uma pesquisa
deve localizar outros que você pode usar.
Problemas no compilador, no vinculador e em bibliotecas tendem a ter aspectos particulares. O tipo de

problema encontrado determinará o tipo de reprodução que você deverá incluir em seu relatório. Sem uma
reprodução apropriada, não temos nada para investigar. Aqui estão alguns dos tipos de problemas que você
pode encontrar. Incluímos instruções sobre como gerar o tipo de reprodução que você deve usar para relatar
cada tipo de problema.
Falha de front-end (analisador)
As falhas de front-end ocorrem durante a fase de análise do compilador. Normalmente, o compilador emite Erro
Fatal C1001 e faz referência ao arquivo de código-fonte e ao número de linha no qual o erro aconteceu. Ele
frequentemente menciona um arquivo chamado msc1.cpp, mas você pode ignorar esse detalhe.
Para esse tipo de falha, forneça uma Reprodução pré-processada.
Aqui está o exemplo de saída do compilador para esse tipo de falha:
SandBoxHost.cpp
d:\o\dev\search\foundation\common\tools\sandbox\managed\managed.h(929):
fatal error C1001: An internal error has occurred in the compiler.
(compiler file 'msc1.cpp', line 1369)
To work around this problem, try simplifying or changing the program near the
locations listed above.
Please choose the Technical Support command on the Visual C++
Help menu, or open the Technical Support help file for more information
d:\o\dev\search\foundation\common\tools\sandbox\managed\managed.h(929):
note: This diagnostic occurred in the compiler generated function
'void Microsoft::Ceres::Common::Tools::Sandbox::SandBoxedProcess::Dispose(bool)'
Internal Compiler Error in d:\o\dev\otools\bin\x64\cl.exe. You will be prompted
to send an error report to Microsoft later.
INTERNAL COMPILER ERROR in 'd:\o\dev\otools\bin\x64\cl.exe'
Falha de back-end (geração de código)

As falhas de back-end ocorrem durante a fase de geração do código do compilador. Normalmente, o compilador
emite Fatal Error C1001 e pode não fazer referência ao arquivo de código-fonte e ao número de linha
associados ao problema. Ele frequentemente menciona o compilador de arquivo\utc\src\p2\main.c, mas você
pode ignorar esse detalhe.
Para esse tipo de falha, forneça uma Reprodução de vinculação se você estiver usando a LTCG (Geração de
Código Durante o Tempo de Vinculação), habilitada pelo argumento de linha de comando /GL para cl.exe. Caso
contrário, forneça uma Reprodução pré-processada.
Este é um exemplo de saída do compilador para uma falha de back-end em que a LTCG não é usada. Se a saída
do compilador tiver a aparência a seguir, você deverá fornecer uma Reprodução pré-processada.
repro.cpp
\\officefile\public\tadg\vc14\comperror\repro.cpp(13) : fatal error C1001:
An internal error has occurred in the compiler.
(compiler file 'f:\dd\vctools\compiler\utc\src\p2\main.c', line 230)
To work around this problem, try simplifying or changing the program near the
locations listed above.
INTERNAL COMPILER ERROR in
'C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\BIN\cl.exe'
Se a linha que começa com INTERNAL COMPILER ERROR menciona link.exe, em vez de cl.exe, a LTCG estava
habilitada. Forneça uma reprodução de vinculação nesse caso. Quando não está claro na mensagem de erro se
o LTCG estava habilitado, examine os argumentos da linha de comando. Você os copiou do log de build em uma
etapa anterior do argumento de linha de comando /GL .
Falha de vinculador
As falhas de vinculador ocorrerem durante a fase de vinculação, depois que o compilador foi executado.
Normalmente, o vinculador emitirá o Erro das Ferramentas de Vinculador LNK1000.
NOTE
Se a saída menciona C1001 ou envolve a Geração de Código Durante o Tempo de Vinculação, confira Falha de back-end
(geração de código) em vez disso.
Para esse tipo de falha, forneça uma Reprodução de vinculação.

Aqui está a saída do compilador de exemplo para esse tipo de falha:
z:\foo.obj : error LNK1000: Internal error during IMAGE::Pass2
Version 14.00.22816.0
ExceptionCode = C0000005
ExceptionFlags = 00000000
ExceptionAddress = 00007FF73C9ED0E6 (00007FF73C9E0000)
"z:\tools\bin\x64\link.exe"
NumberParameters = 00000002
ExceptionInformation[ 0] = 0000000000000000
ExceptionInformation[ 1] = FFFFFFFFFFFFFFFF
CONTEXT:
Rax = 0000000000000400 R8 = 0000000000000000

Rbx = 000000655DF82580 R9 = 00007FF840D2E490
Rcx = 005C006B006F006F R10 = 000000655F97E690
Rdx = 000000655F97E270 R11 = 0000000000000400
Rsp = 000000655F97E248 R12 = 0000000000000000
Rbp = 000000655F97EFB0 E13 = 0000000000000000
Rsi = 000000655DF82580 R14 = 000000655F97F390
Rdi = 0000000000000000 R15 = 0000000000000000
Rip = 00007FF73C9ED0E6 EFlags = 0000000000010206
SegCs = 0000000000000033 SegDs = 000000000000002B
SegSs = 000000000000002B SegEs = 000000000000002B
SegFs = 0000000000000053 SegGs = 000000000000002B
Dr0 = 0000000000000000 Dr3 = 0000000000000000
Dr1 = 0000000000000000 Dr6 = 0000000000000000
Dr2 = 0000000000000000 Dr7 = 0000000000000000
Se a vinculação incremental está habilitada e a falha ocorreu apenas após uma vinculação inicial bem-sucedida,
isto é, apenas após a primeira vinculação completa na qual a vinculação incremental posterior se baseia, forneça
também uma cópia dos arquivos de objeto (.obj) e de biblioteca (.lib) que correspondem aos arquivos de origem
modificados após a vinculação inicial ter sido concluída.
Geração de código incorreto
A geração de código incorreto é rara. Isso acontece quando o compilador gera código incorreto por engano, o
que faz com que o aplicativo falhe no runtime. Em vez disso, ele deve gerar código ou detectar um problema no
momento da compilação. Se você acreditar que o problema encontrado resulta na geração de código incorreto,
trate o relatório da mesma forma que uma Falha de back-end (geração de código).
Para esse tipo de falha, ofereça uma reprodução de vinculação se estiver usando o argumento de linha de
comando /GL para cl.exe. Caso contrário, forneça uma Reprodução pré-processada.
Como gerar uma reprodução

Para nos ajudar a identificar a origem do problema, é vital ter uma boa reprodução. Antes de executar qualquer
uma das etapas descritas abaixo para tipos específicos de reproduções, tente condensar o código que
demonstra o problema tanto quanto possível. Tente eliminar ou minimizar dependências, cabeçalhos
necessários e bibliotecas. Limite as opções do compilador e as definições de pré-processador usadas, se
possível.
A seguir estão as instruções para gerar os vários tipos de reproduções que você usará para relatar diferentes
tipos de problemas.
Reproduções pré -processadas
Uma reprodução pré-processada é um único arquivo de origem que demonstra um problema. Ele é gerado pela
saída do pré-processador C. Para criar um, use a opção do compilador /p no arquivo de origem de reprodução
original. Essa opção alinha os cabeçalhos incluídos para remover dependências em arquivos de origem e de
cabeçalho adicionais. A opção também resolve macros, condicionais #ifdef e outros comandos de pré-
processador que podem depender de seu ambiente local.
NOTE
As reproduções pré-processadas não são tão úteis para problemas que podem ser resultantes de bugs em nossa
implementação de biblioteca padrão porque geralmente queremos substituir nossa implementação mais recente, em
andamento, para ver se já corrigimos o problema. Nesse caso, não pré-processe a reprodução e, se você não puder
reduzir o problema para um único arquivo de origem, compacte seu código em um arquivo .zip ou semelhante ou
considere usar uma reprodução de projeto do IDE. Para obter mais informações, consulte Outras reproduções.
Para pré-processar um arquivo de código-fonte

1. Capture os argumentos de linha de comando usados para criar sua reprodução, conforme descrito em
Para relatar o conteúdo da linha de comando.
configuração do Visual Studio usada para compilar o projeto.
3. Mude para o diretório que contém seu projeto de reprodução.
4. Na janela do console de prompt de comando do desenvolvedor, insira o comando cl /P arguments
filename.cpp. Para argumentos, use a lista de argumentos capturados acima. filename.cpp é o nome do
arquivo de origem da reprodução. Esse comando replica a linha de comando usada para a reprodução,
mas interrompe a compilação após a fase de pré-processamento. Ele grava o código-fonte pré-
processado em filename.i.
Se você estiver pré-processando o arquivo de código de origem do C++/CX, ou estiver usando o recurso de
módulos do C++, algumas etapas adicionais serão necessárias. Para obter mais informações, veja as seguintes
abaixo.
Após ter gerado o arquivo pré-processado, é recomendável certificar-se de que o problema ainda é reproduzido
quando você compila o arquivo pré-processado.
Para confirmar que o arquivo pré-processado ainda reproduz o erro
1. Na janela do console do prompt de comando, insira o comando cl argumentos /TP nomedoarquivo.i
para dizer ao cl.exe para compilar o arquivo pré-processado como um arquivo de origem C++. Os
argumentos são os mesmos argumentos capturados acima, mas com os argumentos /D e /I removidos.
Isso ocorre porque eles já foram incluídos no arquivo pré-processado. nomedoarquivo.i é o nome do
arquivo pré-processado.
2. Confirme que o problema é reproduzido.
Por fim, anexe a reprodução pré-processada nomedoarquivo.i ao seu relatório.
Reproduções de código do C++/CXWinRT/UWP pré -processadas
Se você estiver usando C++/CX para criar o executável, algumas etapas adicionais serão necessárias para criar e
validar uma reprodução pré-processada.
Para pré-processar um código-fonte C++/CX
1. Crie um arquivo de origem pré-processado conforme descrito no arquivo Para pré-processar um arquivo
de código-fonte.
2. Pesquise o arquivo nomedoarquivo.i gerado para diretivas #using .
3. Faça uma lista de todos os arquivos referenciados. Omita todos os arquivos Windows*.winmd,
platform.winmd e mscorlib.dll.
Para se preparar para validar que o arquivo pré-processado ainda reproduz o problema,
1. Crie um diretório para o arquivo pré-processado e copie-o para o novo diretório.
2. Copie os arquivos .winmd da lista #using para o novo diretório.
3. Crie um arquivo vccorlib.h vazio no novo diretório.
4. Edite o arquivo pré-processado para remover todas as diretivas #using para mscorlib.dll.
5. Edite o arquivo pré-processado para alterar qualquer caminho absoluto para apenas os nomes de
arquivo vazio para os arquivos .winmd copiados.
Confirme que o arquivo pré-processado ainda reproduz o problema, conforme acima.
Reproduções de módulos do C++ pré -processadas
Se você estiver usando o recurso de módulos do compilador C++, algumas etapas diferentes serão necessárias
para criar e validar uma reprodução pré-processada.
Para pré-processar um arquivo de código-fonte que usa um módulo
3. Mude para o diretório que contém seu projeto de reprodução.
filename.cpp. Os argumentos são os argumentos capturados acima e filename.cpp é o nome do arquivo
de origem que consome o módulo.
5. Altere para o diretório que contém o projeto de reprodução que criou a interface do módulo (a saída .ifc).
6. Capture os argumentos de linha de comando usados para criar sua interface de módulo.
modulename.ixx. Os argumentos são os argumentos capturados acima e modulename.ixx é o nome do
arquivo que cria a interface de módulo.
Após ter gerado os arquivos pré-processados, é recomendável certificar-se de que o problema ainda é
reproduzido usando o arquivo pré-processado.
Para confirmar que o arquivo pré-processado ainda reproduz o erro
1. Na janela do console de prompt de comando do desenvolvedor, volte para o diretório que contém seu
projeto de reprodução.
2. Digite o comando cl argumentos /TP nomedoarquivo.i como acima, para compilar o arquivo pré-
processado como se fosse um arquivo de origem do C++.
3. Confirme que o problema ainda é reproduzido pelo arquivo pré-processado.
Finalmente, anexe os arquivos de reprodução pré-processados (nomedoarquivo.i e nomedomódulo.i) junto com
a saída de .ifc ao seu relatório.
Reproduções de vinculação
Uma reprodução de link é o conteúdo gerado pelo vinculador de um diretório, especificado pela variável de
ambiente de _ reprodução de link ou como um argumento para a opção de vinculador /LINKREPRO . Ela
contém artefatos de compilação que demonstram coletivamente um problema que acontece no tempo de
vinculação. Os exemplos incluem uma falha de back-end que envolve a Geração de Código Durante o Tempo de
Vinculação (LTCG) ou uma falha de vinculador. Esses artefatos de compilação são os necessários como entrada
de vinculador para que o problema possa ser reproduzido. Uma reprodução de link pode ser criada facilmente
usando essa variável de ambiente. Ela habilita o recurso de geração de reprodução interno do vinculador.
Para gerar uma reprodução de link usando a variável de ambiente link_repro
3. Na janela do console de prompt de comando do desenvolvedor, mude para o diretório que contém seu
projeto de reprodução.
4. Digite mkdir linkrepro para criar um diretório chamado linkrepro para a reprodução do link. Você pode
usar um nome diferente para capturar outra reprodução de link.
5. Digite o comando set link_repro=linkrepro para definir a variável de ambiente link_repro para o
diretório que você criou. Se o Build for executado de um diretório diferente, como geralmente é o caso
para projetos mais complexos, defina o link _ reproduzo para o caminho completo para o diretório de
reprodução de link em vez disso.
6. Para compilar o projeto de reprodução no Visual Studio, na janela do console de prompt de comando do
desenvolvedor, digite o comando devenv . Isso garante que o valor da variável de ambiente link_repro
esteja visível para o Visual Studio. Para compilar o projeto na linha de comando, use os argumentos de
linha de comando capturados acima para duplicar a compilação de reprodução.
7. Compile seu projeto de reprodução e confirme se o problema esperado ocorreu.
8. Feche o Visual Studio se você o usou para executar a compilação.
9. Na janela do console de prompt de comando do desenvolvedor, digite o comando set link_repro= para
limpar a variável de ambiente link_repro .
Por fim, empacote a reprodução ao compactar todo o diretório linkrepro em um arquivo. zip ou semelhante e
anexá-lo ao relatório.
A opção de vinculador /LINKREPRO tem o mesmo efeito que a variável de ambiente de _ reprodução de link
. Você pode usar a opção /LINKREPROTARGET para especificar o nome a ser filtrado para a reprodução do link
gerado. Para usar o /LINKREPROTARGET , você também deve especificar a opção de vinculador /out .
Para gerar uma reprodução de link usando a opção/LINKREPRO
1. Crie um diretório para manter a reprodução do link. Vamos nos referir ao caminho de diretório completo
que você criará como diretório-caminho. Use aspas duplas em volta do caminho se ele incluir espaços.
2. Adicione o comando /LINKREPRO:Directory-Path à linha de comando do vinculador. No Visual Studio,
abra a caixa de diálogo páginas de propriedades do seu projeto. Selecione a > página de propriedade
da linha de comando do vinculador de propriedades de configuração > . Em seguida, insira a opção
/LINKREPRO:Directory-Path na caixa Opções adicionais . Escolha OK para salvar suas alterações.
3. Compile seu projeto de reprodução e confirme se o problema esperado ocorreu.
Por fim, empacote a reprodução ao compactar o diretório de reprodução do link do caminho do diretório inteiro
em um arquivo. zip ou semelhante e anexá-lo ao relatório.
Outras reproduções
Se você não puder reduzir o problema para um único arquivo de origem ou reprodução pré-processado, e o
problema não exigir uma reprodução de link, podemos investigar um projeto do IDE. Todas as orientações sobre
como criar uma boa reprodução ainda se aplicam: o código deve ser mínimo e autônomo. O problema deve
ocorrer em nossas ferramentas mais recentes e, se for relevante, não deve ser visto em outros compiladores.
Crie sua reprodução como um projeto do IDE mínimo e empacote-o compactando toda a estrutura do diretório
em um arquivo .zip ou semelhante e anexe-o ao relatório.
Maneiras de enviar o relatório

Há várias boas maneiras de enviar seu relatório para nós. Você pode usar o relatório interno do Visual Studio
uma ferramenta problemáticaou a página da comunidade de desenvolvedores do Visual Studio . Também há um
botão Comentários sobre o produto no final desta página. A escolha depende se você deseja usar as
ferramentas internas no IDE para obter capturas de tela e organizar seu relatório. Caso prefira não fazê-lo, você
pode usar diretamente o site da Comunidade de Desenvolvedores.
NOTE
Independentemente de como você enviar seu relatório, a Microsoft respeita sua privacidade. A Microsoft está
comprometida com a conformidade com todas as leis e regulamentos de privacidade de dados. Para obter informações
sobre como tratamos os dados que você nos envia, confira a Política de privacidade da Microsoft.
Usar a ferramenta Relatar um Problema

A ferramenta Relatar um Problema no Visual Studio é uma maneira de os usuários do Visual Studio relatarem
problemas com apenas alguns cliques. Ele exibe um formulário simples para enviar informações detalhadas
sobre o problema encontrado. Em seguida, você pode enviar seu relatório sem precisar sair do IDE.
Relatar o problema usando a ferramenta Relatar um Problema no IDE é fácil e prático. Você pode acessá-la na
barra de título escolhendo o ícone Enviar Comentários ao lado da caixa de pesquisa Início Rápido . Ou você
pode encontrá-lo na barra de menus em ajuda > enviar comentários para > relatar um problema .
Ao escolher relatar um problema, pesquise primeiro na Comunidade de Desenvolvedores para tentar encontrar
problemas semelhantes. Se o problema já tiver sido relatado anteriormente, vote a favor do relatório e adicione
comentários com informações adicionais específicas. Se você não encontrar nenhum problema semelhante,
escolha o botão Relatar problema novo na parte inferior da caixa de diálogo Comentários do Visual Studio e
siga as etapas para relatar o problema.
Usar as páginas da Comunidade de Desenvolvedores do Visual Studio
As páginas da Comunidade de Desenvolvedores do Visual Studio são outra maneira prática para relatar
problemas e encontrar soluções relacionadas ao Visual Studio e ao compilador do C++, às ferramentas e às
bibliotecas. Há páginas específicas da comunidade de desenvolvedores para o Visual Studio, Visual Studio para
Mac, .net, C++, Azure DevOpse Azure DevOps Server.
Nas guias da comunidade, próximo à parte superior de cada página, há uma caixa de pesquisa. Você pode usá-la
para encontrar postagens que relatam problemas semelhantes ao seu. Você poderá encontrar uma solução ou
outras informações úteis relacionadas ao seu problema já disponíveis. Se alguém já tiver relatado o mesmo
problema anteriormente, vote a favor e comente nesse relatório em vez de criar um novo relatório de problema.
Para comentar, votar ou relatar um problema novo, você poderá ser solicitado a entrar sua conta do Visual
Studio. Na primeira vez que entrar, você terá que concordar em dar acesso ao aplicativo da Comunidade de
Desenvolvedores ao seu perfil.
Para problemas com o compilador C++, vinculador e outras ferramentas e bibliotecas, primeiro pesquise a
página da comunidade de desenvolvedores do c++ . Se você pesquisar seu problema e ele não tiver sido
relatado anteriormente, escolha o botão Relatar um problema ao lado da caixa de pesquisa. Você poderá
incluir o código de reprodução e a linha de comando, capturas de tela, links para discussões relacionadas e
qualquer outra informação que achar relevante e útil.
TIP
Para ver outros tipos de problemas que possam ser encontrados no Visual Studio não relacionados ao conjunto de
ferramentas do C++ (Por exemplo, problemas de interface do usuário, funcionalidade IDE corrompida ou falhas gerais),
use a ferramenta Relatar um problema no IDE. Isso é a melhor opção, devido a suas funcionalidades de captura de tela
e sua capacidade de registrar ações de interface do usuário que levam ao problema encontrado. Esses tipos de erros
também podem ser pesquisados no site da comunidade de desenvolvedores do Visual Studio. Para obter mais
informações, consulte como relatar um problema com o Visual Studio.
Relatórios e privacidade
Todas as informações em relatórios e quaisquer comentários e respostas são publicamente
visíveis por padrão . Normalmente, isso é uma vantagem, pois permite que toda a comunidade veja os
problemas, as soluções e alternativas encontradas por outros usuários. No entanto, se você está preocupado em
tornar seus dados ou a sua identidade pública, por motivos de propriedade intelectual ou de privacidade, há
opções.
Se você está preocupado com a revelação da sua identidade, crie uma conta Microsoft que não divulgue todos
os detalhes sobre você. Use essa conta para criar seu relatório.
Não coloque algo que você deseja manter par ticular no título ou no conteúdo do relatório inicial,
que é público. Em vez disso, diga que você enviará detalhes em particular em um comentário separado. Para
ter certeza de que o relatório será direcionado às pessoas certas, inclua cppcompiler na lista de tópicos do seu
relatório de problemas. Depois de criar o relatório de problemas, é possível especificar quem pode ver suas
respostas e anexos.
Para criar um relatório de problemas para informações particulares
1. No relatório que você criou, escolha Adicionar comentário para criar sua descrição privada do
problema.
2. No editor de resposta, use o controle de lista suspensa abaixo dos botões Enviar e Cancelar para
especificar o público-alvo para a sua resposta. Somente as pessoas que você especificar podem ver essas
respostas privadas e imagens, links ou código que você incluir. Escolha Visível por moderadores e o
car taz original para limitar a visibilidade aos funcionários da Microsoft e a você mesmo.
3. Adicione a descrição e quaisquer outras informações, imagens e anexos de arquivo necessários para a
reprodução. Escolha o botão Enviar para enviar essas informações em particular.
Há um limite de 2 GB para arquivos anexados e de no máximo 10 arquivos. Para uploads maiores, solicite
uma URL de upload no seu comentário particular.
Quaisquer respostas sob esse comentário têm a mesma visibilidade restrita que você especificou. Isso é
verdadeiro mesmo se o controle de lista suspensa em respostas não mostra o status de visibilidade restrito
corretamente.
Para manter sua privacidade e manter suas informações confidenciais ocultas do público, seja cuidadoso.
Mantenha todas as interações com a Microsoft nas respostas ao comentário restrito. Respostas a outros
comentários podem gerar a divulgação acidental de informações confidenciais.
Como relatar um problema na documentação do C++

Usamos os problemas do GitHub para acompanhar os problemas relatados em nossa documentação. Agora
você pode criar problemas do GitHub diretamente de uma página de conteúdo, o que permite interagir de
forma muito mais sofisticada com escritores e equipes de produto. Se você encontrar um problema com um
documento, um exemplo de código inválido, uma explicação confusa, uma omissão crítica ou até mesmo um
erro de digitação, fale conosco – é fácil. Role até a parte inferior da página e selecione Entre para fornecer
comentários sobre a documentação . Você precisará criar uma conta no GitHub caso ainda não tenha uma.
Quando tem uma conta do GitHub, você pode ver todos os problemas de sua documentação e o status dela.
Você também recebe notificações quando as alterações são feitas no problema relatado por você. Para obter
mais informações, confira Em breve, um novo sistema de comentários em docs.microsoft.com.
Você pode criar um problema de documentação no GitHub quando usa o botão de comentários de
documentação. O problema será automaticamente preenchido com algumas informações sobre a página na
qual você criou o problema. É assim que podemos saber onde o problema está localizado, portanto, não edite
essas informações. Acrescente apenas os detalhes sobre o que está incorreto e, se desejar, uma correção
sugerida. Nossos documentos C++ são de software livre então, se quiser enviar você mesmo uma correção, é
possível. Para obter mais informações sobre como você pode contribuir com nossa documentação, confira
nosso Guia de colaboração no GitHub.
Instalar o suporte a C e C++ Visual Studio
Se você ainda não baixou e instalou Visual Studio ferramentas do Microsoft C/C++, veja como começar.
Instalação do Visual Studio 2019

Bem-vindo ao Visual Studio 2019. Nesta versão, é fácil escolher e instalar apenas os recursos que você precisa.
E, devido a seu volume mínimo reduzido, ele é instalado rapidamente e com menos impacto no sistema.
NOTE
Este tópico se aplica à instalação do Visual Studio no Windows. Visual Studio Code é um ambiente de desenvolvimento
leve e de plataforma cruzada executado em sistemas Windows, Mac e Linux. O Microsoft C/C++ para Visual Studio Code
extensão dá suporte ao IntelliSense, depuração, formatação de código, preenchimento automático. Visual Studio para Mac
dá suporte ao Microsoft C++, mas dá suporte a linguagens .NET e desenvolvimento de plataforma cruzada. Para obter
instruções de instalação, consulte Instalar Visual Studio para Mac.
Quer saber mais sobre quais são as outras novidades nesta versão? Consulte as notas Visual Studio versão do .
Pronto para instalar? Guiaremos você no processo, passo a passo.
Etapa 1 - Verificar se o computador está pronto para o Visual Studio
Antes de começar a instalação do Visual Studio:
1. Verifique os requisitos do sistema. Esses requisitos ajudam você a saber se o computador dá suporte ao
Visual Studio 2019.
2. Aplique as atualizações mais recentes do Windows. Essas atualizações garantem que o computador tenha
as atualizações de segurança mais recentes e os componentes de sistema obrigatórios para o Visual
Studio.
3. Reinicialize. Isso garante que todas as instalações ou atualizações pendentes não atrapalhem a instalação
do Visual Studio.
4. Libere espaço. Remova arquivos e aplicativos desnecessários de %SystemDrive%, por exemplo,
executando o aplicativo Limpeza de Disco.
Para solucionar dúvidas sobre a execução de versões anteriores do Visual Studio lado a lado com o Visual Studio
2019, veja a página Direcionamento e compatibilidade da plataforma Visual Studio 2019.
Etapa 2 - Baixar o Visual Studio
Em seguida, baixe o arquivo bootstrapper do Visual Studio. Para fazer isso, escolha o botão a seguir para ir para
a página Visual Studio download. Selecione a edição do Visual Studio que você deseja e escolha o botão
Avaliação gratuita ou Download gratuito.
B AIXAR O V ISU AL
S TU D IO
Etapa 3 - Instalar o instalador do Visual Studio

Execute o arquivo de bootstrapper que você baixou para instalar o Instalador do Visual Studio. Esse novo
instalador leve inclui tudo o que você precisa para instalar e personalizar o Visual Studio.
1. Da sua pasta Downloads , clique duas vezes no inicializador que corresponde ou é semelhante a um dos
seguintes arquivos:
vs_community.exe para Visual Studio Community
vs_professional.exe para Visual Studio Professional
vs_enterprise.exe para Visual Studio Enterprise
Se você receber um aviso de Controle de Conta de Usuário, escolha Sim para permitir que o
bootstrapper seja executado.
2. Solicitaremos que você confirme os Termos de Licença da Microsoft e a Política de Privacidade
daMicrosoft. Escolha Continuar .
Etapa 4 – escolher cargas de trabalho
Depois que o instalador for instalado, você poderá usá-lo para personalizar sua instalação selecionando as
cargas de trabalho ou conjuntos de recursos que você deseja. Veja aqui como fazer isso.
1. Encontre a carga de trabalho desejada na tela Instalando o Visual Studio .
Para suporte principal a C e C++, escolha a carga de trabalho "Desenvolvimento para área de trabalho
com C++". Ela vem com o editor de núcleo padrão, que inclui o suporte à edição de código básico para
mais de 20 linguagens, a capacidade de abrir e editar o código de qualquer pasta sem precisar de um
projeto e o controle do código-fonte integrado.
Cargas de trabalho adicionais suportam outros tipos de desenvolvimento. Por exemplo, escolha a carga
de trabalho "Desenvolvimento Windows Plataforma Universal" para criar aplicativos que usam o runtime
Windows para o Microsoft Store. Escolha "Desenvolvimento de jogos com C++" para criar jogos que
usam DirectX, Unreal e Cocos2d. Escolha "Desenvolvimento do Linux com C++" para direcionar
plataformas Linux, incluindo desenvolvimento de IoT.
O painel Detalhes da instalação lista os componentes incluídos e opcionais instalados por cada carga
de trabalho. Você pode selecionar ou desmarcar componentes opcionais nesta lista. Por exemplo, para
dar suporte ao desenvolvimento usando os Visual Studio 2017 ou 2015, escolha os componentes
opcionais MSVC v141 ou MSVC v140. Você pode adicionar suporte para MFC, a extensão de linguagem
de Módulos experimentais, IncrediBuild e muito mais.
2. Depois de escolher as cargas de trabalho e os componentes opcionais que deseja, escolha Instalar .
Em seguida, serão exibidas telas de status que mostram o progresso da instalação do Visual Studio.
TIP
A qualquer momento após a instalação, você pode instalar as cargas de trabalho ou os componentes não instalados
inicialmente. Se você tiver Visual Studio, acesse Ferramentas Obter Ferramentas e > Recursos... que abre o Instalador do
Visual Studio. Outra opção é abrir o Instalador do Visual Studio no menu Iniciar. Assim, é possível escolher as cargas
de trabalho ou os componentes que você deseja instalar. Em seguida, escolha Modificar .
Etapa 5 – escolher componentes individuais (opcional)

Se você não quiser usar o recurso Cargas de Trabalho para personalizar Visual Studio instalação do Visual
Studio ou se quiser adicionar mais componentes do que uma carga de trabalho instalada, poderá fazer isso
instalando ou adicionando componentes individuais da guia Componentes individuais. Escolha o que você
deseja e siga os prompts.
Etapa 6 - Instalar pacotes de idiomas (opcional)

Por padrão, o programa do instalador tenta encontrar a correspondência do idioma do sistema operacional
quando ele é executado pela primeira vez. Para instalar o Visual Studio em um idioma de sua escolha, escolha a
guia Pacotes de idioma do Instalador do Visual Studio e siga os prompts.
Alterar o idioma de instalação da linha de comando

Outra maneira de alterar o idioma padrão é executar o instalador a partir da linha de comando. Por exemplo, é
possível forçar o instalador a ser executado em inglês usando o seguinte comando:
vs_installer.exe --locale en-US . O instalador se lembrará dessa configuração quando for executado na
próxima vez. O instalador dá suporte aos seguintes tokens de idioma: zh-cn, zh-tw, cs-cz, en-us, es-es, fr-fr, de-
de, it-it, ja-jp, ko-kr, pl-pl, pt-br, ru-ru e tr-tr.
Etapa 7 – Alterar o local de instalação (opcional)
Você pode reduzir o volume de instalação do Visual Studio na unidade do sistema. Você pode optar por mover o
cache de download, os componentes compartilhados, os SDKs e as ferramentas para unidades diferentes e
manter o Visual Studio na unidade que executá-los com mais rapidez.
IMPORTANT
Você pode selecionar uma unidade diferente apenas quando você instala o Visual Studio pela primeira vez. Se você já tiver
instalado e quiser alterar unidades, precisará desinstalar o Visual Studio e, em seguida, reinstalá-lo.
Etapa 8 – Começar a desenvolver

1. Após a conclusão da instalação do Visual Studio, escolha o botão Iniciar para ver a introdução ao
desenvolvimento com o Visual Studio.
2. Na janela inicial, escolha Criar um novo projeto.
3. Na caixa de pesquisa, insira o tipo de aplicativo que deseja criar para ver uma lista de modelos
disponíveis. A lista de modelos depende das cargas de trabalho escolhidas durante a instalação. Para ver
os diferentes modelos, escolha diferentes cargas de trabalho.
Você também pode filtrar sua pesquisa para uma linguagem de programação específica usando a lista
suspensa Linguagem de programação . Você também pode filtrar usando as listas Plataforma e Tipo
de projeto .
4. O Visual Studio abre seu novo projeto e você está pronto para codificar!

No Visual Studio 2017, é fácil escolher e instalar apenas os recursos necessários. E, devido a seu volume mínimo
reduzido, ele é instalado rapidamente e com menos impacto no sistema.
Pré -requisitos
Uma conexão de Internet de banda larga. O Visual Studio instalador pode baixar vários gigabytes de
dados.
Um computador que executa o Microsoft Windows 7 ou versões posteriores. Recomendamos o Windows
10 para obter a melhor experiência de desenvolvimento. Certifique-se de que as atualizações mais
recentes sejam aplicadas ao seu sistema antes de instalá-Visual Studio.
Espaço livre suficiente em disco. Visual Studio requer pelo menos 7 GB de espaço em disco e pode levar
50 GB ou mais se muitas opções comuns estão instaladas. É recomendável instalá-lo na unidade C:.
Para obter detalhes sobre o espaço em disco e os requisitos do sistema operacional, consulte Visual Studio do
sistema da família de produtos. O instalador informa quanto espaço em disco é necessário para as opções
selecionadas.
Baixar e instalar
1. Para baixar o instalador Visual Studio 2017 mais recente para Windows, acesse a página Microsoft Visual
Studio Downloads mais antigos. Expanda a seção 2017 e escolha o botão Baixar.
TIP
A edição Community é para desenvolvedores individuais, aprendizado em sala de aula, pesquisa acadêmica e
desenvolvimento de software livre. Para outros usos, instale o Visual Studio 2017 Professional ou o Visual Studio
2017 Enterprise.
2. Encontre o arquivo do instalador que você baixou e execute-o. O arquivo baixado pode ser exibido no
navegador ou você pode encontrá-lo na pasta Downloads. O instalador precisa de privilégios de
Administrador para ser executado. Você pode ver uma caixa de diálogo Controle de Conta de Usuário
solicitando que você dê permissão para permitir que o instalador faça alterações em seu sistema; escolha
Sim. Se você estiver tendo problemas, encontre o arquivo baixado no Explorador de Arquivos, clique
com o botão direito do mouse no ícone do instalador e escolha Executar como Administrador no menu
de contexto.
3. O instalador apresenta uma lista de cargas de trabalho, que são grupos de opções relacionadas para
áreas de desenvolvimento específicas. O suporte para C++ agora faz parte de cargas de trabalho
opcionais que não estão instaladas por padrão.
Para C e C++, selecione a carga de trabalho Desenvolvimento para desktop com C++ e, em seguida,
escolha Instalar .
4. Quando a instalação for concluída, escolha o botão Iniciar para iniciar Visual Studio.
Na primeira vez que você Visual Studio, será solicitado que você entre com uma conta da Microsoft. Caso
não tenha uma, você pode criá-la gratuitamente. Você também deve escolher um tema. Não se preocupe,
você poderá alterá-lo mais tarde se quiser.
Pode levar Visual Studio alguns minutos para se preparar para uso na primeira vez que você o executar.
Veja como é a aparência em um rápido tempo de tempo:
Visual Studio começa muito mais rapidamente quando você o executar novamente.
5. Quando Visual Studio, verifique se o ícone de sinalizador na barra de título está realçada:
Se estiver realçada, selecione-a para abrir a janela Notificações. Se houver atualizações disponíveis para
Visual Studio, recomendamos instalá-las agora. Quando a instalação for concluída, reinicie Visual Studio.

Para instalar Visual Studio 2015, acesse a página Microsoft Visual Studio Downloads mais antigos. Expanda a
seção 2015 e escolha o botão Baixar. Execute o programa de instalação baixado e escolha Instalação
personalizada e, em seguida, escolha o componente C++. Para adicionar suporte a C e C++ a uma instalação
Visual Studio 2015 existente, clique no Windows botão Iniciar e digite Adicionar Remover Programas . Abra o
programa na lista de resultados e encontre a instalação Visual Studio 2015 na lista de programas instalados.
Clique duas vezes nele e, em seguida, escolha Modificar e selecione os Visual C++ componentes a instalar.
Em geral, é altamente recomendável que você use a versão mais recente do Visual Studio mesmo se precisar
compilar seu código usando o compilador Visual Studio 2015. Para obter mais informações, consulte Usar a
multiplataforma nativa no Visual Studio para compilar projetos antigos.
Quando Visual Studio estiver em execução, você estará pronto para continuar para a próxima etapa.
Próximas etapas
Criar um projeto C++
https://docs.microsoft.com/
Criar um projeto de aplicativo de console C++
O ponto de partida usual para um programador de C++ é um aplicativo "Olá, mundo!" executado na linha de
comando. Isso é o que você criará em Visual Studio nesta etapa.
Pré-requisitos
Ter o Visual Studio com o desenvolvimento de Desktop com carga de trabalho do C++ instalada e em
execução no seu computador. Se ele ainda não estiver instalado, confira Instalar suporte para C++ no Visual
Studio.
Criar seu projeto de aplicativo

O Visual Studio usa os projetos para organizar o código em um aplicativo e as soluções para organizar seus
projetos. Um projeto contém todas as opções, configurações e regras usadas para criar seus aplicativos. Ele
gerencia a relação entre todos os arquivos do projeto e todos os arquivos externos. Para criar seu aplicativo,
primeiro, crie um novo projeto e uma nova solução.
1. No Visual Studio, abra o menu Arquivo e escolha Novo > Project para abrir a caixa de diálogo Criar um
novo Project. Selecione o modelo aplicativo de console que tem as marcas C++, Windows e
Console e, em seguida, escolha Próximo .
2. Na caixa de diálogo Configurar seu novo projeto, insira HelloWorld na caixa Project de edição de
nome. Escolha Criar para criar o projeto.
Visual Studio cria um novo projeto. Ele está pronto para você adicionar e editar seu código-fonte. Por
padrão, o modelo aplicativo de console preenche seu código-fonte com um aplicativo "Olá, Mundo":
Quando o código for assim no editor, você estará pronto para ir para a próxima etapa e criar seu
aplicativo.
Houve um problema.
1. No Visual Studio, abra o menu Arquivo e escolha Novo > Project para abrir a caixa de diálogo Novo
Project.
2. Na caixa de Project, selecione Instalado > Visual C++ se ele ainda não estiver selecionado e, em
seguida, escolha o modelo Project vazio. No campo Nome, insira HelloWorld. Escolha OK para criar o
projeto.
Visual Studio cria um projeto novo e vazio. Ele está pronto para você se especializar para o tipo de aplicativo que
deseja criar e para adicionar seus arquivos de código-fonte. Você fará isso em seguida.
Houve um problema.
Tornar seu projeto um aplicativo de console

Visual Studio pode criar todos os tipos de aplicativos e componentes para Windows e outras plataformas. O
modelo Project vazio não é específico sobre o tipo de aplicativo que ele cria. Um aplicativo de console é
executado em um console ou janela de prompt de comando. Para criar um, você deve Visual Studio criar seu
aplicativo para usar o subsistema de console.
1. No Visual Studio, abra o menu Project e escolha Propriedades para abrir a caixa de diálogo Páginas de
Propriedades HelloWorld.
2. Na caixa de diálogo Páginas de Propriedades, selecione Propriedades de Configuração > Linker >
System e, em seguida, escolha a caixa de edição ao lado da propriedade Subsistema. No menu
suspenso exibido, selecione Console (/SUBSYSTEM:CONSOLE) . Escolha OK para salvar suas
alterações.
Visual Studio agora sabe como criar seu projeto para ser executado em uma janela do console. Em seguida, você
adicionará um arquivo de código-fonte e inserirá o código do aplicativo.
Houve um problema.
Adicionar um arquivo de código-fonte

1. No Gerenciador de Soluções , selecione o projeto HelloWorld. Na barra de menus, escolha Project ,
Adicionar Novo Item para abrir a caixa de diálogo Adicionar Novo Item.
2. Na caixa de diálogo Adicionar Novo Item, selecione Visual C++ em Instalado se ele ainda não
estiver selecionado. No painel central, selecione Arquivo C++ (.cpp). Altere o Nome para
HelloWorld.cpp. Escolha Adicionar para fechar a caixa de diálogo e criar o arquivo.
O Visual Studio cria um novo arquivo de código-fonte vazio e o abre em uma janela do editor, pronto para
inserir o código-fonte.
Houve um problema.
Adicionar código ao arquivo de origem

1. Copie esse código para a janela do editor HelloWorld.cpp.
#include <iostream>
int main()
{
std::cout << "Hello, world!" << std::endl;
return 0;
}
O código deve ter esta aparência na janela do editor:
Quando o código for assim no editor, você estará pronto para ir para a próxima etapa e criar seu aplicativo.
Houve um problema.
Próximas etapas
Criar e executar um projeto C++
Guia de Solução de Problemas

Venha aqui para soluções para problemas comuns ao criar seu primeiro projeto C++.
Criar seu projeto de aplicativo: problemas
A caixa de Project novo deve mostrar um modelo de Aplicativo de Console que tenha as marcas C++,
Windows e Console. Se você não a vir, há duas causas possíveis. Ele pode ser filtrado para fora da lista ou
pode não estar instalado. Primeiro, verifique os menus suspensos de filtro na parte superior da lista de modelos.
De defini-los como C++, Windows e Console . O modelo aplicativo de console C++ deve aparecer; caso
contrário, a carga de trabalho Desenvolvimento para desktop com C++ não está instalada.
Para instalar o Desenvolvimento de área de trabalho com C++, você pode executar o instalador na caixa de
diálogo Novo Project. Escolha o link Instalar mais ferramentas e recursos na parte inferior da lista de
modelos para iniciar o instalador. Se a caixa de diálogo Controle de Conta de Usuário solicitar permissões,
escolha Sim. No instalador, certifique-se de que a carga de trabalho Desenvolvimento da área de trabalho
com C++ está marcada. Em seguida, escolha Modificar para atualizar sua Visual Studio instalação.
Se outro projeto com o mesmo nome já existir, escolha outro nome para seu projeto. Ou exclua o projeto
existente e tente novamente. Para excluir um projeto existente, exclua a pasta da solução (a pasta que contém o
arquivo helloworld.sln) no Explorador de Arquivos.
Go back.
Se a caixa Project nova caixa de diálogo não mostrar uma entrada Visual C++ em Instalado, sua cópia do
Visual Studio provavelmente não terá a carga de trabalho Desenvolvimento de área de trabalho com C++
instalada. Você pode executar o instalador na caixa de diálogo Novo Project. Escolha o link Abrir Instalador
do Visual Studio para iniciar o instalador novamente. Se a caixa de diálogo Controle de Conta de Usuário
solicitar permissões, escolha Sim. Atualize o instalador, se necessário. No instalador, certifique-se de que a carga
de trabalho Desenvolvimento da área de trabalho com C++ está marcada e escolha OK para atualizar sua
Visual Studio instalação.
Se outro projeto com o mesmo nome já existir, escolha outro nome para seu projeto. Ou exclua o projeto
existente e tente novamente. Para excluir um projeto existente, exclua a pasta da solução (a pasta que contém o
arquivo helloworld.sln) no Explorador de Arquivos.
Go back.
Tornar seu projeto um aplicativo de console: problemas
Se você não vir o Linker listado em Propriedades de Configuração, escolha Cancelar para fechar a caixa de
diálogo Páginas de Propriedades. Certifique-se de que o projeto HelloWorld está selecionado
Gerenciador de Soluções antes de tentar novamente. Não selecione a solução HelloWorld ou outro item no
Gerenciador de Soluções .
O controle suspenso não aparece na caixa de edição de propriedade SubSystem até que você selecione a
propriedade . Clique na caixa de edição para selecioná-la. Ou, você pode pressionar Tab para percorrer os
controles da caixa de diálogo até que o subsistema seja realçado. Escolha o controle suspenso ou pressione Alt
+ seta para abri-lo.
Voltar
Adicionar um arquivo de código -fonte: problemas
Não há problema se você fornecer um nome diferente ao arquivo de código-fonte. No entanto, não adicione
mais de um arquivo que contenha o mesmo código ao seu projeto.
Se você adicionou o tipo de arquivo errado ao seu projeto, como um arquivo de cabeçalho, exclua-o e tente
novamente. Para excluir o arquivo, selecione-o em Gerenciador de soluções . Em seguida, pressione a tecla
delete .
Volte.
Adicionar código ao arquivo de origem: problemas
Se você fechou acidentalmente a janela do editor de arquivo de código-fonte, você pode abri-la facilmente
novamente. Para abri-lo, clique duas vezes em HelloWorld. cpp na janela Gerenciador de soluções .
Se os rabiscos vermelhos aparecerem em qualquer coisa no editor de código-fonte, verifique se o seu código
corresponde ao exemplo em ortografia, pontuação e caso. O caso é significativo no código C++.
Volte.
Desenvolver e executar um projeto de aplicativo de
console C++
Você criou um projeto de aplicativo de console do C++ e entrou em seu código. Agora você pode criar e
executar o Visual Studio. Em seguida, execute-o como um aplicativo autônomo na linha de comando.
Pré-requisitos
Ter o Visual Studio com o desenvolvimento de Desktop com carga de trabalho do C++ instalada e em
execução no seu computador. Se ele ainda não estiver instalado, siga as etapas em Instalar o suporte ao
C++ no Visual Studio.
Criar um aplicativo "Olá, Mundo!" projeto e insira seu código-fonte. Se você ainda não tiver feito essa
etapa, siga as etapas em Criar um projeto de aplicativo de console do C++.
Se Visual Studio for assim, você estará pronto para criar e executar seu aplicativo:
Crie e execute seu código em Visual Studio

1. Para compilar o projeto, escolha Compilar Solução no menu Compilar . A janela de Saída mostra os
resultados do processo de build.
2. Para executar o código, na barra de menus, escolha Depurar , Iniciar sem depuração .
Uma janela do console é aberta e, em seguida, executa seu aplicativo. Quando você inicia um aplicativo
de console no Visual Studio, ele é executado em seu código e, em seguida, imprime "Pressione qualquer
tecla para continuar. . ." para dar a oportunidade de ver a saída.
Parabéns! Você criou seu primeiro aplicativo de console "Olá, mundo!" no Visual Studio! Pressione uma tecla
para ignorar a janela do console e retornar ao Visual Studio.
Houve um problema.
Executar o código em uma janela de comando

Normalmente, você executará aplicativos de console no prompt de comando, não no Visual Studio. Depois que
seu aplicativo for criado por Visual Studio, você poderá execute-o em qualquer janela de comando. Veja como
encontrar e executar seu novo aplicativo em uma janela de prompt de comando.
1. No Gerenciador de Soluções , selecione a solução HelloWorld (não o projeto HelloWorld) e clique com
o botão direito do mouse para abrir o menu de contexto. Escolha Abrir Pasta no Explorador de
Arquivos para abrir uma Explorador de Arquivos na pasta da solução HelloWorld.
2. Na janela Explorador de Arquivos, abra a pasta Depurar. Essa pasta contém seu aplicativo,
HelloWorld.exe e alguns outros arquivos de depuração. Mantenha a tecla Shift e clique com o botão
direito do mouse HelloWorld.exe abrir o menu de contexto. Escolha Copiar como caminho para copiar
o caminho para seu aplicativo para a área de transferência.
3. Para abrir uma janela do prompt de comando, pressione Windows+R para abrir a caixa de diálogo
Executar. Insira cmd.exe na caixa de texto Abrir e escolha OK para executar uma janela de prompt de
comando.
4. Na janela do prompt de comando, clique com o botão direito do mouse para colar o caminho em seu
aplicativo no prompt de comando. Pressione Enter para executar seu aplicativo.
Parabéns, você criou e executará um aplicativo de console no Visual Studio!

Houve um problema.
Próximas etapas
Depois de ter criado e executado esse aplicativo simples, você estará pronto para projetos mais complexos. Para
obter mais informações, consulte Using the Visual Studio IDE for C++ Desktop Development. Ele tem
explicações passo a passo mais detalhadas que exploram as funcionalidades do Microsoft C++ Visual Studio.
Guia de Solução de Problemas

Venha aqui para soluções para problemas comuns ao criar seu primeiro projeto C++.
Criar e executar seu código em Visual Studio: problemas
Se as alternâncias vermelhas aparecerem em qualquer coisa no editor de código-fonte, o build poderá ter erros
ou avisos. Verifique se o código corresponde ao exemplo de ortografia, pontuação e caso.
Go back.
Execute seu código em uma janela de comando: problemas
Se o caminho mostrado em Explorador de Arquivos terminar em \ \ HelloWorld HelloWorld, você abriu o
projeto HelloWorld em vez da solução HelloWorld. Você ficará confuso com uma pasta Depurar que não contém
seu aplicativo. Navegue até um nível Explorador de Arquivos para acessar a pasta da solução, o primeiro
HelloWorld no caminho. Essa pasta também contém uma pasta Depurar e você encontrará seu aplicativo lá.
Você também pode navegar até a pasta de depuração da solução na linha de comando para executar seu
aplicativo. Seu aplicativo não será executado de outros diretórios sem especificar o caminho para o aplicativo.
No entanto, você pode copiar seu aplicativo para outro diretório e executar nele. Também é possível copiá-lo
para um diretório especificado pela variável de ambiente PATH e, em seguida, execute-o em qualquer lugar.
Se você não vir Copiar como caminho no menu de atalho, descarte o menu e segure a tecla Shift enquanto a
abre novamente. Esse comando é apenas para sua conveniência. Você também pode copiar o caminho para a
pasta da barra de pesquisa Explorador de Arquivos, colar na caixa de diálogo Executar e, em seguida, inserir o
nome do executável no final. É apenas um pouco mais de digitação, mas tem o mesmo resultado.
Go back.
Criar uma calculadora de console em C++
comando. Isso é o que você criará primeiro Visual Studio neste artigo e, em seguida, passaremos para algo mais
desafiador: um aplicativo de calculadora.
Pré-requisitos
Tenha Visual Studio com a carga de trabalho Desenvolvimento da área de trabalho com C++ instalada e
em execução no computador. Se ele ainda não estiver instalado, confira Instalar suporte para C++ no Visual
Studio.

também gerencia a relação entre todos os arquivos de projeto e todos os arquivos externos. Para criar seu
aplicativo, primeiro, crie um novo projeto e uma nova solução.
1. Se tiver começado a usar o Visual Studio, você verá a caixa de diálogo do Visual Studio 2019. Escolha
Criar um novo projeto para começar.
Caso contrário, na barra de menus Visual Studio, escolha Arquivo > > Novo Project . A janela Criar
um novo projeto é aberta.
2. Na lista de modelos de projeto, escolha Aplicativo de Console e, em seguida, escolha Avançar .
IMPORTANT
É preciso que você escolha a versão do C++ do modelo do Aplicativo de Console . Ele tem as marcas C++ ,
Windows e Console , enquanto o ícone tem "++" no canto.
3. Na caixa de diálogo Configurar novo projeto , selecione a caixa de edição Nome do projeto , dê ao
novo projeto o nome CalculatorTutorial e, em seguida, escolha Criar .
Um aplicativo de console do Windows C++ vazio é criado. Os aplicativos de console usam uma janela de
console do Windows para exibir a saída e aceitar a entrada do usuário. No Visual Studio, uma janela do
editor é aberta e mostra o código gerado:
// CalculatorTutorial.cpp : This file contains the 'main' function. Program execution begins and ends
there.
//
#include <iostream>
int main()
{
std::cout << "Hello World!\n";
}
// Run program: Ctrl + F5 or Debug > Start Without Debugging menu

// Debug program: F5 or Debug > Start Debugging menu
// Tips for Getting Started:

// 1. Use the Solution Explorer window to add/manage files
// 2. Use the Team Explorer window to connect to source control
// 3. Use the Output window to see build output and other messages
// 4. Use the Error List window to view errors
// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add
existing code files to the project
// 6. In the future, to open this project again, go to File > Open > Project and select the .sln
file
Verificar se o novo aplicativo compila e executa

O modelo para um novo aplicativo de console do Windows cria um aplicativo simples "Olá, Mundo" em C++.
Neste ponto, você pode ver como o Visual Studio compila e executa os aplicativos que você cria diretamente no
IDE.
tecla para fechar esta janela. . ." para dar a oportunidade de ver a saída. Parabéns! Você criou seu
primeiro aplicativo de console "Olá, mundo!" no Visual Studio!
3. Pressione uma tecla para ignorar a janela do console e retornar ao Visual Studio.
Agora você tem as ferramentas para compilar e executar seu aplicativo após cada alteração para verificar se o
código ainda funciona conforme o esperado. Posteriormente, mostraremos como depurá-lo se ele não
funcionar bem.
Editar o código
Agora vamos examinar o código neste modelo em um aplicativo de calculadora.
1. No arquivo CalculatorTutorial.cpp, edite o código para corresponder a este exemplo:
there.
//
#include <iostream>
int main()
{
cout << "Calculator Console Application" << endl << endl;
cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b"
<< endl;
return 0;
}

file
Noções básicas sobre o código:

As instruções #include permitem que você consulte a código localizado em outros arquivos. Às
vezes, você pode ver um nome de arquivo entre colchetes angulares ( ); outras vezes, ele está
entre <> aspas (" " ). Em geral, os colchetes angulares são usados ao fazer referência à biblioteca
padrão C++, enquanto as aspas são usadas para outros arquivos.
A linha using namespace std; informa ao compilador para esperar que coisas da Biblioteca Padrão
C++ sejam usadas nesse arquivo. Sem essa linha, cada palavra-chave da biblioteca precisaria ser
precedida por um std:: para indicar seu escopo. Por exemplo, sem essa linha, cada referência a
cout precisaria ser escrito como std::cout . A using instrução é adicionada para tornar o
código mais limpo.
A palavra-chave cout é usada para imprimir a saída padrão em C++. O << operador informa ao
compilador para enviar o que está à direita dele para a saída padrão.
A palavra-chave endl é como a tecla Enter; encerra a linha e move o cursor para a próxima linha. É
uma melhor prática para colocar um \n dentro da cadeia de caracteres (contido por "") para fazer
a mesma coisa, uma vez que endl sempre libera o buffer e pode prejudicar o desempenho do
programa, mas já que esse é um aplicativo muito pequeno, endl é usado em vez disso para
melhor legibilidade.
Todas as instruções C++ devem terminar com ponto e vírgula e todos os aplicativos C++ devem
conter uma função main() . Essa função é o que o programa é executado no início. Todo o código
deve estar acessível de main() para ser usado.
2. Para salvar o arquivo, insira Ctrl+S ou escolha o ícone Salvar ao lado da parte superior do IDE, o ícone
de disquete na barra de ferramentas na barra de menus.
3. Para executar o aplicativo, pressione CTRL+F5 ou vá para o menu Depurar e escolha Iniciar Sem
Depuração . Você deve ver uma janela do console em exibição com o texto especificado no código.
4. Feche a janela do console ao terminar.
Adicionar código para fazer alguns cálculos matemáticos
É hora de adicionar alguma lógica de matemática.
Para adicionar uma classe de Calculadora
1. Vá para o menu Projeto e escolha Adicionar Classe . Na caixa de edição Nome de Classe , digite
Calculadora. Selecione OK . Dois novos arquivos são adicionados ao seu projeto. Para salvar todos os
arquivos alterados de uma vez, pressione Ctrl+Shift+S . É um atalho de teclado para Arquivo > Salvar
Tudo. Também há um botão de barra de ferramentas para Salvar Tudo , um ícone de dois disquetes,
encontrado ao lado do botão Salvar . Em geral, é uma boa prática executar Salvar Tudo com frequência,
para que você não perca nenhum arquivo ao salvar.
Uma classe é como um blueprint para um objeto que faz algo. Nesse caso, definimos uma calculadora e
como ela deve funcionar. O assistente Adicionar Classe usado acima criou arquivos .h e .cpp que têm o
mesmo nome que a classe. Você pode ver uma lista completa dos arquivos de projeto na Gerenciador
de Soluções, visível no lado do IDE. Se a janela não estiver visível, você poderá abri-la na barra de
menus: escolha Exibir > Gerenciador de Soluções .
Agora você deve ter três guias abertas no editor: CalculatorTutorial.cpp, Calculator.h e Calculator.cpp. Se
você fechar acidentalmente uma delas, poderá reabri-la clicando duas vezes na janela Gerenciador de
Soluções janela.
2. Em Calculator.h , remova as linhas Calculator(); e ~Calculator(); que foram geradas, já que você não
precisa delas aqui. Em seguida, adicione a seguinte linha de código para que o arquivo agora tenha esta
aparência:
#pragma once
class Calculator
{
public:
double Calculate(double x, char oper, double y);
};
Compreender o código
A linha que você adicionou declara uma nova função chamada Calculate , que usaremos para
executar operações matemáticas para adição, subtração, multiplicação e divisão.
O código C++ é organizado em arquivos de cabeçalho (.h) e de origem (.cpp). Várias outras
extensões de arquivo têm suporte pelos vários compiladores, mas estes são os principais
conhecer. Funções e variáveis normalmente são declaradas, ou seja, recebem um nome e um tipo,
nos arquivos de cabeçalho, e implementadas ou recebem uma definição nos arquivos de origem.
Para acessar código definido em outro arquivo, você pode usar #include "filename.h" , em que
'filename.h' é o nome do arquivo que declara as variáveis ou funções que você deseja usar.
As duas linhas que você excluiu declararam um construtor e um destruidor para a classe. Para
uma classe simples como essa, o compilador as cria para você e seus usos estão além do escopo
deste tutorial.
É uma boa prática organizar seu código em arquivos diferentes com base no que ele faz, de modo
que seja fácil encontrar o código de que você precisa mais tarde. Em nosso caso, definimos a
classe Calculator separadamente do arquivo que contém a função main() , mas podemos
planejar fazer referência à classe Calculator em main() .
3. Você verá um rabisco verde aparecer sob Calculate . Ocorre porque ainda não definimos a função
Calculate no arquivo .cpp. Passe o mouse sobre a palavra, clique na lâmpada (neste caso, uma chave de
fenda) que aparece em pop-up e escolha Criar uma definição de 'Calculate' em Calculator.cpp .
Um pop-up será exibido, possibilitando uma espiada na alteração de código que foi feita em outro
arquivo. O código foi adicionado ao Calculator.cpp.
Atualmente, retorna apenas 0,0. Vamos mudar isso. Pressione Esc para fechar o pop-up.
4. Alterne para o arquivo Calculator.cpp na janela do editor. Remova as seções Calculator() e
~Calculator() (como fez no arquivo .h) e adicione o seguinte código a Calculate() :
#include "Calculator.h"
double Calculator::Calculate(double x, char oper, double y)

{
switch(oper)
{
case '+':
return x + y;
case '-':
return x - y;
case '*':
return x * y;
case '/':
return x / y;
default:
return 0.0;
}
}
A função Calculate consome um número, um operador e um segundo número e, em seguida,
executa a operação solicitada nos números.
A instrução de opção verifica que operador foi fornecido e somente executa o caso que
corresponde a essa operação. O padrão: caso é uma contingência se o usuário digita um operador
que não é aceito, de modo que o programa não seja interrompido. Em geral, é melhor manipular
uma entrada de usuário inválida de uma maneira mais elegante, mas isso está além do escopo
deste tutorial.
A double palavra-chave denota um tipo de número que dá suporte a decimais. Dessa forma, a
calculadora pode lidar com matemática decimal e de inteiros. A função é necessária para sempre
retornar esse número devido ao no início do código (isso indica o tipo de retorno da função), que
é o motivo pelo qual retornamos Calculate 0,0 mesmo no caso double padrão.
O arquivo .h declara a função protótipo, que informa ao compilador antecipadamente quais
parâmetros são necessários e que tipo de retorno esperar dele. O arquivo .cpp tem todos os
detalhes de implementação da função.
Se você compilar e executar o código novamente neste ponto, ele ainda será encerrado depois de perguntar
qual operação executar. Em seguida, você modificará a função main para fazer alguns cálculos.
Para chamar funções de membro da classe Calculadora
1. Agora vamos atualizar a função main em CalculatorTutorial.cpp:
there.
//
#include <iostream>
int main()
{
double x = 0.0;
double y = 0.0;
double result = 0.0;
char oper = '+';

<< endl;
Calculator c;
while (true)
{
cin >> x >> oper >> y;
result = c.Calculate(x, oper, y);
cout << "Result is: " << result << endl;
}
return 0;
}
Uma vez que os programas C++ sempre começam com a função main() , precisamos chamar o
outro código daí, portanto, uma instrução #include é necessária.
Algumas variáveis iniciais x , y , oper e result são declaradas para armazenar o primeiro
número, o segundo número, o operador e o resultado final, respectivamente. É sempre uma boa
prática fornecer alguns valores iniciais para evitar um comportamento indefinido, o que é feito
aqui.
A linha Calculator c; declara um objeto chamado 'c' como uma instância da classe Calculator .
A classe em si é apenas o blueprint para como as calculadoras funcionam; o objeto é a calculadora
específica que faz os cálculos.
A instrução while (true) é um loop. O código dentro do loop continua sendo executado
repetidamente enquanto a condição em () se aplicar. Como a condição é simplesmente listada
como true , ela é sempre verdadeira, portanto, o loop é executado para sempre. Para fechar o
programa, o usuário deve fechar manualmente a janela do console. Caso contrário, o programa
sempre esperará a nova entrada.
A palavra-chave cin é usada para aceitar a entrada do usuário. Esse fluxo de entrada é inteligente
o suficiente para processar uma linha de texto inserida na janela do console e colocá-la dentro de
cada uma das variáveis listadas, em ordem, supondo que a entrada do usuário corresponda à
especificação necessária. Você pode modificar essa linha para aceitar diferentes tipos de entrada,
por exemplo, mais de dois números, embora a função Calculate() também precise ser atualizada
para lidar com isso.
A expressão c.Calculate(x, oper, y); chama a função Calculate definida anteriormente e
fornece os valores de entrada inseridos. A função retorna um número que é armazenado em
result .
Por fim, result é impresso no console para que o usuário veja o resultado do cálculo.
Compilar e testar o código novamente
Agora é hora de testar o programa novamente para verificar se que tudo está funcionando bem.
1. Pressione Ctrl+F5 para recompilar e iniciar o aplicativo.
2. Insira 5 + 5 e pressione Enter . Verifique se o resultado será 10.
Depurar o aplicativo
Uma vez que o usuário é livre para digitar qualquer coisa na janela do console, vamos garantir que a
calculadora lide com alguma entrada conforme o esperado. Em vez de executar o programa, vamos depurá-lo
para que seja possível inspecionar o que ele está fazendo em detalhes, passo a passo.
Para executar o aplicativo no depurador
1. Defina um ponto de interrupção na linha result = c.Calculate(x, oper, y); , logo após o usuário ter sido
solicitado a inserir a entrada. Para definir um ponto de interrupção, clique Para fazer isso, clique ao lado
da linha na barra vertical cinza ao longo da borda esquerda da janela do editor. Um ponto vermelho é
exibido.
Agora quando depuramos o programa, ele sempre pausa a execução nessa linha. Já temos uma ideia
superficial de que o programa funciona para casos simples. Como não queremos pausar a execução toda
vez, vamos tornar o ponto de interrupção condicional.
2. Clique com o botão direito do mouse no ponto vermelho que representa o ponto de interrupção e
escolha Condições . Na caixa de edição para a condição, insira (y == 0) && (oper == '/') . Escolha o
botão OK quando tiver terminado. A condição é salva automaticamente.
Agora vamos pausar a execução no ponto de interrupção especificamente se você tentar uma divisão por
0.
3. Para depurar o programa, pressione F5 ou escolha o botão da barra de ferramentas Depurador Local
do Windows que tem um ícone de seta verde. Em seu aplicativo de console, se você digitar algo como
"0-5", o programa se comportará normalmente e continuará em execução. No entanto, se você digitar
"10 / 0", ele fará uma pausa no ponto de interrupção. Você pode até mesmo colocar qualquer número de
espaços entre o operador e os números. cin é inteligente o suficiente para analisar a entrada de modo
adequado.
Janelas úteis no depurador
Sempre que você depura seu código, pode perceber que algumas novas janelas aparecem. Essas janelas podem
ajudar a sua experiência de depuração. Dê uma olhada na janela Autos . A janela Autos mostra os valores atuais
das variáveis usadas pelo menos três linhas antes e até a linha atual. Para ver todas as variáveis dessa função,
alterne para a janela Locais . Na verdade, você pode modificar os valores dessas variáveis enquanto depura para
ver que efeito elas teriam sobre o programa. Neste caso, podemos deixá-las de lado.
Também é possível apenas focalizar variáveis no código em si para ver seus valores atuais em que a execução
está em pausa momento. Verifique se a janela do editor está em foco clicando nela primeiro.
Para continuar a depuração

1. A linha amarela à esquerda mostra o ponto atual de execução. A linha atual que chama Calculate , assim,
pressione F11 para Depurar a função. Você se encontrará no corpo da função Calculate . Atenção ao
Depurar ; se fizer isso muitas vezes, poderá perder muito tempo. Ela entra em qualquer código que você
usa na linha em que você está, incluindo funções de biblioteca padrão.
2. Agora que o ponto de execução está no início da função Calculate , pressione F10 para ir para a próxima
linha na execução do programa. F10 também é conhecido como Depuração Parcial . Você pode usar
Depuração Parcial para mover de uma linha para outra, sem aprofundar-se nos detalhes do que está
ocorrendo em cada parte da linha. Em geral, você deve usar Depuração Parcial em vez de Depurar , a
menos que queira aprofundar-se no código que está sendo chamado de outro lugar (como você fez para
alcançar o corpo de Calculate ).
3. Continue usando F10 para realizar a Depuração Parcial de cada linha até que você voltar para a função
main() no outro arquivo e pare na linha cout .
Parece que o programa está fazendo o que é esperado: ele usa o primeiro número e o divide pelo
segundo. Na linha cout , focalize a variável result ou dê uma olhada result na janela Autos . Você
verá que seu valor está listado como "inf", o que não parece correto, então vamos corrigi-lo. A linha
cout somente gera qualquer valor que esteja armazenado em result , portanto, quando você avança
mais uma linha usando F10 , a janela do console exibe:
Esse resultado acontece porque a divisão por zero é indefinida, portanto, o programa não tem uma
resposta numérica para a operação solicitada.
Para consertar o erro de "dividir por zero"
Vamos tratar da divisão por zero de modo mais simples para que um usuário possa entender o problema.
1. Faça as seguintes alterações a CalculatorTutorial.cpp. (Você pode deixar o programa em execução durante
a edição, graças a um recurso do depurador chamado Editar e Continuar ):
there.
//
#include <iostream>
int main()
{
double x = 0.0;
double y = 0.0;
char oper = '+';

cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b" << endl;
Calculator c;
while (true)
{
if (oper == '/' && y == 0)
{
cout << "Division by 0 exception" << endl;
continue;
}
else
{
}
}
return 0;
}
2. Agora pressione F5 uma vez. A execução do programa continua até ele precisar pausar para pedir
entrada do usuário. Insira 10 / 0 novamente. Agora, é impressa uma mensagem mais útil. O usuário é
solicitado a fornecer mais entradas e o programa continua em execução normalmente.
NOTE
Quando você edita o código no modo de depuração, há um risco de o código se tornar obsoleto. Isso acontece
quando o depurador ainda está executando seu código antigo e não ainda o atualizou com suas alterações. O
depurador abre em pop-up uma caixa de diálogo para informá-lo quando isso acontece. Às vezes, pode ser
necessário pressionar F5 para atualizar o código que está sendo executado. Em particular, se você fizer uma
alteração dentro de uma função enquanto o ponto de execução está dentro daquela função, precisará sair da
função e voltar para ela para obter o código atualizado. Se isso não funcionar por alguma razão e você vir uma
mensagem de erro, você poderá interromper a depuração clicando no quadrado vermelho na barra de
ferramentas abaixo dos menus na parte superior do IDE e iniciar a depuração novamente inserindo F5 ou
escolhendo a seta " reproduzir" verde ao lado do botão Parar na barra de ferramentas.
Noções básicas sobre os atalhos de Executar e Depurar

F5 (ou Depurar > Iniciar Depuração ) iniciará uma sessão de depuração se uma ainda não
estiver ativa e executará o programa até atingir um ponto de interrupção ou o programa precisar
de entrada do usuário. Se nenhuma entrada do usuário for necessária e nenhum ponto de
interrupção estiver disponível para ser atingido, o programa será encerrado e a janela do console
fechará mesmo quando o programa for encerrado. Se você tiver algo parecido com um programa
"Olá, Mundo" para ser executado, use CTRL+F5 ou defina um ponto de interrupção antes de
inserir F5 para manter a janela aberta.
CTRL + F5 (ou Depurar > Iniciar sem Depuração ) executa o aplicativo sem entrar no modo
de depuração. Isso é um pouco mais rápido do que a depuração e a janela do console permaneça
aberta depois de o programa terminar a execução.
F10 (conhecido como Depuração Parcial ) permite que você itere pelo código linha por linha e
visualize como o código é executado e quais valores de variáveis estão em cada etapa de
execução.
F11 (conhecido como Depurar ) funciona da mesma forma que Depuração Parcial , exceto que
depura todas as funções chamadas na linha de execução. Por exemplo, se a linha que está sendo
executada chamar uma função, pressionar F11 moverá o ponteiro para o corpo da função, de
modo que você possa seguir o código da função que está em execução antes de voltar para a
linha em que começou. Pressionar F10 faz a depuração parcial da chamada de função e apenas se
move para a próxima linha; a chamada de função ainda acontece, mas o programa não pausa para
mostrar o você está fazendo.
Feche o aplicativo
Se ele ainda estiver em execução, feche a janela de console para o aplicativo de calculadora.
O aplicativo finalizado
Parabéns! Você concluiu o código para o aplicativo de calculadora e o compilou e depurou no Visual Studio.
Próximas etapas
Saiba mais sobre o Visual Studio para C++
comando. É isso que você criará no Visual Studio neste artigo e, em seguida, passaremos para algo mais
desafiador: um aplicativo de calculadora.
Pré-requisitos
tenha Visual Studio com o desenvolvimento de Desktop com a carga de trabalho do C++ instalada e em
execução no seu computador. Se ele ainda não estiver instalado, confira Instalar suporte para C++ no Visual
Studio.

também gerencia a relação entre todos os arquivos de projeto e todos os arquivos externos. Para criar seu
aplicativo, primeiro, crie um novo projeto e uma nova solução.
1. na barra de menus em Visual Studio, escolha arquivo > novo > Project . A janela Novo Projeto é
aberta.
2. Na barra lateral esquerda, verifique se Visual C++ está selecionado. No centro, escolha Aplicativo de
Console do Windows .
3. Na caixa de edição Nome na parte inferior de edição, dê um nome ao novo projeto CalculatorTutorial e,
em seguida, escolha OK .
Um aplicativo de console do Windows C++ vazio é criado. Os aplicativos de console usam uma janela de
console do Windows para exibir a saída e aceitar a entrada do usuário. No Visual Studio, uma janela do
editor é aberta e mostra o código gerado:
there.
//
#include "pch.h"
#include <iostream>
int main()
{
std::cout << "Hello World!\n";
}


file
Verificar se o novo aplicativo compila e executa

O modelo para um novo aplicativo de console do Windows cria um aplicativo simples "Olá, Mundo" em C++.
Neste ponto, você pode ver como o Visual Studio compila e executa os aplicativos que você cria diretamente no
IDE.
tecla para continuar. . ." para dar a oportunidade de ver a saída. Parabéns! Você criou seu primeiro
aplicativo de console "Olá, mundo!" no Visual Studio!
3. Pressione uma tecla para ignorar a janela do console e retornar ao Visual Studio.
Agora você tem as ferramentas para compilar e executar seu aplicativo após cada alteração para verificar se o
código ainda funciona conforme o esperado. Posteriormente, mostraremos como depurá-lo se ele não
funcionar bem.
Editar o código
Agora vamos examinar o código neste modelo em um aplicativo de calculadora.
1. No arquivo CalculatorTutorial.cpp, edite o código para corresponder a este exemplo:
there.
//
#include "pch.h"
#include <iostream>
int main()
{
<< endl;
return 0;
}

file
Noções básicas sobre o código:

As instruções #include permitem que você consulte a código localizado em outros arquivos. Às
vezes, você pode ver um nome de arquivo entre colchetes angulares ( <> ); outras vezes, está
entre aspas ("" ). Em geral, os colchetes angulares são usados ao fazer referência à biblioteca
padrão C++, enquanto as aspas são usadas para outros arquivos.
A linha #include "pch.h" (ou, no Visual Studio 2017 e versões anteriores, #include "stdafx.h" )
faz referência a algo conhecido como cabeçalho pré-compilado. Isso costuma ser usado por
programadores profissionais para melhorar os tempos de compilação, mas estão além do escopo
deste tutorial.
A linha using namespace std; informa ao compilador para esperar que coisas da Biblioteca Padrão
C++ sejam usadas nesse arquivo. Sem essa linha, cada palavra-chave da biblioteca precisaria ser
precedida por um std:: para indicar seu escopo. Por exemplo, sem essa linha, cada referência a
cout precisaria ser escrito como std::cout . A using instrução é adicionada para tornar o
código mais limpo.
A palavra-chave cout é usada para imprimir a saída padrão em C++. O << operador informa ao
compilador para enviar o que estiver à direita dele para a saída padrão.
A palavra-chave endl é como a tecla Enter; encerra a linha e move o cursor para a próxima linha. É
uma melhor prática para colocar um \n dentro da cadeia de caracteres (contido por "") para fazer
a mesma coisa, uma vez que endl sempre libera o buffer e pode prejudicar o desempenho do
programa, mas já que esse é um aplicativo muito pequeno, endl é usado em vez disso para
melhor legibilidade.
Todas as instruções C++ devem terminar com ponto e vírgula e todos os aplicativos C++ devem
conter uma função main() . Essa função é o que o programa é executado no início. Todo o código
deve estar acessível de main() para ser usado.
2. Para salvar o arquivo, insira Ctrl+S ou escolha o ícone Salvar ao lado da parte superior do IDE, o ícone
de disquete na barra de ferramentas na barra de menus.
3. Para executar o aplicativo, pressione CTRL+F5 ou vá para o menu Depurar e escolha Iniciar Sem
Depuração . Se você receber um pop-up com a mensagem Este projeto está desatualizado , você
poderá selecionar Não mostrar esta caixa de diálogo novamente e, em seguida, escolher Sim para
compilar seu aplicativo. Você deve ver uma janela do console em exibição com o texto especificado no
código.
4. Feche a janela do console ao terminar.
Adicionar código para fazer alguns cálculos matemáticos

É hora de adicionar alguma lógica de matemática.
Para adicionar uma classe de Calculadora
1. Vá para o menu Projeto e escolha Adicionar Classe . Na caixa de edição Nome de Classe , digite
Calculadora. Selecione OK . Dois novos arquivos são adicionados ao seu projeto. Para salvar todos os
arquivos alterados de uma vez, pressione Ctrl+Shift+S . É um atalho de teclado para Arquivo > Salvar
Tudo. Também há um botão de barra de ferramentas para Salvar Tudo , um ícone de dois disquetes,
encontrado ao lado do botão Salvar . Em geral, é uma boa prática executar Salvar Tudo com frequência,
para que você não perca nenhum arquivo ao salvar.
Uma classe é como um blueprint para um objeto que faz algo. Nesse caso, definimos uma calculadora e
como ela deve funcionar. O assistente Adicionar Classe usado acima criou arquivos .h e .cpp que têm o
mesmo nome que a classe. Você pode ver uma lista completa dos arquivos de projeto na Gerenciador
de Soluções, visível no lado do IDE. Se a janela não estiver visível, você poderá abri-la na barra de
menus: escolha Exibir > Gerenciador de Soluções .
Agora você deve ter três guias abertas no editor: CalculatorTutorial.cpp, Calculator.h e Calculator.cpp. Se
você fechar acidentalmente uma delas, poderá reabri-la clicando duas vezes na janela Gerenciador de
Soluções janela.
2. Em Calculator.h , remova as linhas Calculator(); e ~Calculator(); que foram geradas, já que você não
precisa delas aqui. Em seguida, adicione a seguinte linha de código para que o arquivo agora tenha esta
aparência:
#pragma once
class Calculator
{
public:
double Calculate(double x, char oper, double y);
};
A linha que você adicionou declara uma nova função chamada Calculate , que usaremos para
executar operações matemáticas para adição, subtração, multiplicação e divisão.
O código C++ é organizado em arquivos de cabeçalho (.h) e de origem (.cpp). Várias outras
extensões de arquivo têm suporte pelos vários compiladores, mas estes são os principais
conhecer. Funções e variáveis normalmente são declaradas, ou seja, recebem um nome e um tipo,
nos arquivos de cabeçalho, e implementadas ou recebem uma definição nos arquivos de origem.
Para acessar código definido em outro arquivo, você pode usar #include "filename.h" , em que
'filename.h' é o nome do arquivo que declara as variáveis ou funções que você deseja usar.
As duas linhas que você excluiu declararam um construtor e um destruidor para a classe. Para
uma classe simples como essa, o compilador as cria para você e seus usos estão além do escopo
deste tutorial.
É uma boa prática organizar seu código em arquivos diferentes com base no que ele faz, de modo
que seja fácil encontrar o código de que você precisa mais tarde. Em nosso caso, definimos a
classe Calculator separadamente do arquivo que contém a função main() , mas podemos
planejar fazer referência à classe Calculator em main() .
3. Você verá um rabisco verde aparecer sob Calculate . Ocorre porque ainda não definimos a função
Calculate no arquivo .cpp. Passe o mouse sobre a palavra, clique na lâmpada que aparece em pop-up e
escolha criar uma definição de 'Calculate' em Calculator.cpp . Um pop-up será exibido,
possibilitando uma espiada na alteração de código que foi feita em outro arquivo. O código foi
adicionado ao Calculator.cpp.
Atualmente, retorna apenas 0,0. Vamos mudar isso. Pressione Esc para fechar o pop-up.
4. Alterne para o arquivo Calculator.cpp na janela do editor. Remova as seções Calculator() e
~Calculator() (como fez no arquivo .h) e adicione o seguinte código a Calculate() :
#include "pch.h"
double Calculator::Calculate(double x, char oper, double y)

{
switch(oper)
{
case '+':
return x + y;
case '-':
return x - y;
case '*':
return x * y;
case '/':
return x / y;
default:
return 0.0;
}
}
A função Calculate consome um número, um operador e um segundo número e, em seguida,
executa a operação solicitada nos números.
A instrução de opção verifica que operador foi fornecido e somente executa o caso que
corresponde a essa operação. O padrão: caso é uma contingência se o usuário digita um operador
que não é aceito, de modo que o programa não seja interrompido. Em geral, é melhor manipular
uma entrada de usuário inválida de uma maneira mais elegante, mas isso está além do escopo
deste tutorial.
A double palavra-chave denota um tipo de número que dá suporte a decimais. Dessa forma, a
calculadora pode lidar com matemática decimal e de inteiros. A função é necessária para sempre
retornar esse número devido ao no início do código (isso indica o tipo de retorno da função), que
é o motivo pelo qual retornamos Calculate 0,0 mesmo no caso double padrão.
O arquivo .h declara a função protótipo, que informa ao compilador antecipadamente quais
parâmetros são necessários e que tipo de retorno esperar dele. O arquivo .cpp tem todos os
detalhes de implementação da função.
Se você compilar e executar o código novamente neste ponto, ele ainda será encerrado depois de perguntar
qual operação executar. Em seguida, você modificará a função main para fazer alguns cálculos.
Para chamar funções de membro da classe Calculadora
1. Agora vamos atualizar a função main em CalculatorTutorial.cpp:
there.
//
#include "pch.h"
#include <iostream>
int main()
{
double x = 0.0;
double y = 0.0;
char oper = '+';

<< endl;
Calculator c;
while (true)
{
}
return 0;
}
Uma vez que os programas C++ sempre começam com a função main() , precisamos chamar o
outro código daí, portanto, uma instrução #include é necessária.
Algumas variáveis iniciais x , y , oper e result são declaradas para armazenar o primeiro
número, o segundo número, o operador e o resultado final, respectivamente. É sempre uma boa
prática fornecer alguns valores iniciais para evitar um comportamento indefinido, o que é feito
aqui.
A linha Calculator c; declara um objeto chamado 'c' como uma instância da classe Calculator .
A classe em si é apenas o blueprint para como as calculadoras funcionam; o objeto é a calculadora
específica que faz os cálculos.
A instrução while (true) é um loop. O código dentro do loop continua sendo executado
repetidamente enquanto a condição em () se aplicar. Como a condição é simplesmente listada
como true , ela é sempre verdadeira, portanto, o loop é executado para sempre. Para fechar o
programa, o usuário deve fechar manualmente a janela do console. Caso contrário, o programa
sempre esperará a nova entrada.
A palavra-chave cin é usada para aceitar a entrada do usuário. Esse fluxo de entrada é inteligente
o suficiente para processar uma linha de texto inserida na janela do console e colocá-la dentro de
cada uma das variáveis listadas, em ordem, supondo que a entrada do usuário corresponda à
especificação necessária. Você pode modificar essa linha para aceitar diferentes tipos de entrada,
por exemplo, mais de dois números, embora a função Calculate() também precise ser atualizada
para lidar com isso.
A expressão c.Calculate(x, oper, y); chama a função Calculate definida anteriormente e
fornece os valores de entrada inseridos. A função retorna um número que é armazenado em
result .
Por fim, result é impresso no console para que o usuário veja o resultado do cálculo.
Compilar e testar o código novamente

Agora é hora de testar o programa novamente para verificar se que tudo está funcionando bem.
1. Pressione Ctrl+F5 para recompilar e iniciar o aplicativo.
2. Insira 5 + 5 e pressione Enter . Verifique se o resultado será 10.
Depurar o aplicativo
Uma vez que o usuário é livre para digitar qualquer coisa na janela do console, vamos garantir que a
calculadora lide com alguma entrada conforme o esperado. Em vez de executar o programa, vamos depurá-lo
para que seja possível inspecionar o que ele está fazendo em detalhes, passo a passo.
Para executar o aplicativo no depurador
1. Defina um ponto de interrupção na linha result = c.Calculate(x, oper, y); , logo após o usuário ter sido
solicitado a inserir a entrada. Para definir um ponto de interrupção, clique Para fazer isso, clique ao lado
da linha na barra vertical cinza ao longo da borda esquerda da janela do editor. Um ponto vermelho é
exibido.
Agora quando depuramos o programa, ele sempre pausa a execução nessa linha. Já temos uma ideia
superficial de que o programa funciona para casos simples. Como não queremos pausar a execução toda
vez, vamos tornar o ponto de interrupção condicional.
2. Clique com o botão direito do mouse no ponto vermelho que representa o ponto de interrupção e
escolha Condições . Na caixa de edição para a condição, insira (y == 0) && (oper == '/') . Escolha o
botão OK quando tiver terminado. A condição é salva automaticamente.
Agora vamos pausar a execução no ponto de interrupção especificamente se você tentar uma divisão por
0.
3. Para depurar o programa, pressione F5 ou escolha o botão da barra de ferramentas Depurador Local
do Windows que tem um ícone de seta verde. Em seu aplicativo de console, se você digitar algo como
"0-5", o programa se comportará normalmente e continuará em execução. No entanto, se você digitar
"10 / 0", ele fará uma pausa no ponto de interrupção. Você pode até mesmo colocar qualquer número de
espaços entre o operador e os números. cin é inteligente o suficiente para analisar a entrada de modo
adequado.
Janelas úteis no depurador

Sempre que você depura seu código, pode perceber que algumas novas janelas aparecem. Essas janelas podem
ajudar a sua experiência de depuração. Dê uma olhada na janela Autos . A janela Autos mostra os valores atuais
das variáveis usadas pelo menos três linhas antes e até a linha atual.
Para ver todas as variáveis dessa função, alterne para a janela Locais . Na verdade, você pode modificar os
valores dessas variáveis enquanto depura para ver que efeito elas teriam sobre o programa. Neste caso,
podemos deixá-las de lado.
Também é possível apenas focalizar variáveis no código em si para ver seus valores atuais em que a execução
está em pausa momento. Verifique se a janela do editor está em foco clicando nela primeiro.
Para continuar a depuração

1. A linha amarela à esquerda mostra o ponto atual de execução. A linha atual que chama Calculate , assim,
pressione F11 para Depurar a função. Você se encontrará no corpo da função Calculate . Atenção ao
Depurar ; se fizer isso muitas vezes, poderá perder muito tempo. Ela entra em qualquer código que você
usa na linha em que você está, incluindo funções de biblioteca padrão.
2. Agora que o ponto de execução está no início da função Calculate , pressione F10 para ir para a próxima
linha na execução do programa. F10 também é conhecido como Depuração Parcial . Você pode usar
Depuração Parcial para mover de uma linha para outra, sem aprofundar-se nos detalhes do que está
ocorrendo em cada parte da linha. Em geral, você deve usar Depuração Parcial em vez de Depurar , a
menos que queira aprofundar-se no código que está sendo chamado de outro lugar (como você fez para
alcançar o corpo de Calculate ).
3. Continue usando F10 para realizar a Depuração Parcial de cada linha até que você voltar para a função
main() no outro arquivo e pare na linha cout .
Parece que o programa está fazendo o que é esperado: ele usa o primeiro número e o divide pelo
segundo. Na linha cout , focalize a variável result ou dê uma olhada result na janela Autos . Você
verá que seu valor está listado como "inf", o que não parece correto, então vamos corrigi-lo. A linha
cout somente gera qualquer valor que esteja armazenado em result , portanto, quando você avança
mais uma linha usando F10 , a janela do console exibe:
Esse resultado acontece porque a divisão por zero é indefinida, portanto, o programa não tem uma
resposta numérica para a operação solicitada.
Para consertar o erro de "dividir por zero"
Vamos tratar da divisão por zero de modo mais simples para que um usuário possa entender o problema.
1. Faça as seguintes alterações a CalculatorTutorial.cpp. (Você pode deixar o programa em execução durante
a edição, graças a um recurso do depurador chamado Editar e Continuar ):
there.
//
#include "pch.h"
#include <iostream>
int main()
{
double x = 0.0;
double y = 0.0;
char oper = '+';

cout << "Please enter the operation to perform. Format: a+b | a-b | a*b | a/b" << endl;
Calculator c;
while (true)
{
if (oper == '/' && y == 0)
{
cout << "Division by 0 exception" << endl;
continue;
}
else
{
}
}
return 0;
}
2. Agora pressione F5 uma vez. A execução do programa continua até ele precisar pausar para pedir
entrada do usuário. Insira 10 / 0 novamente. Agora, é impressa uma mensagem mais útil. O usuário é
solicitado a fornecer mais entradas e o programa continua em execução normalmente.
NOTE
Quando você edita o código no modo de depuração, há um risco de o código se tornar obsoleto. Isso acontece
quando o depurador ainda está executando seu código antigo e não ainda o atualizou com suas alterações. O
depurador abre em pop-up uma caixa de diálogo para informá-lo quando isso acontece. Às vezes, pode ser
necessário pressionar F5 para atualizar o código que está sendo executado. Em particular, se você fizer uma
alteração dentro de uma função enquanto o ponto de execução está dentro daquela função, precisará sair da
função e voltar para ela para obter o código atualizado. Se isso não funcionar por alguma razão e você vir uma
mensagem de erro, você poderá interromper a depuração clicando no quadrado vermelho na barra de
ferramentas abaixo dos menus na parte superior do IDE e iniciar a depuração novamente inserindo F5 ou
escolhendo a seta " reproduzir" verde ao lado do botão Parar na barra de ferramentas.
Noções básicas sobre os atalhos de Executar e Depurar

F5 (ou Depurar > Iniciar Depuração ) iniciará uma sessão de depuração se uma ainda não
estiver ativa e executará o programa até atingir um ponto de interrupção ou o programa precisar
de entrada do usuário. Se nenhuma entrada do usuário for necessária e nenhum ponto de
interrupção estiver disponível para ser atingido, o programa será encerrado e a janela do console
fechará mesmo quando o programa for encerrado. Se você tiver algo parecido com um programa
"Olá, Mundo" para ser executado, use CTRL+F5 ou defina um ponto de interrupção antes de
inserir F5 para manter a janela aberta.
CTRL + F5 (ou Depurar > Iniciar sem Depuração ) executa o aplicativo sem entrar no modo
de depuração. Isso é um pouco mais rápido do que a depuração e a janela do console permaneça
aberta depois de o programa terminar a execução.
F10 (conhecido como Depuração Parcial ) permite que você itere pelo código linha por linha e
visualize como o código é executado e quais valores de variáveis estão em cada etapa de
execução.
F11 (conhecido como Depurar ) funciona da mesma forma que Depuração Parcial , exceto que
depura todas as funções chamadas na linha de execução. Por exemplo, se a linha que está sendo
executada chamar uma função, pressionar F11 moverá o ponteiro para o corpo da função, de
modo que você possa seguir o código da função que está em execução antes de voltar para a
linha em que começou. Pressionar F10 faz a depuração parcial da chamada de função e apenas se
move para a próxima linha; a chamada de função ainda acontece, mas o programa não pausa para
mostrar o você está fazendo.
Feche o aplicativo
Se ele ainda estiver em execução, feche a janela de console para o aplicativo de calculadora.
O aplicativo finalizado
Parabéns! Você concluiu o código para o aplicativo de calculadora e o compilou e depurou no Visual Studio.
Próximas etapas
Saiba mais sobre o Visual Studio para C++
Projetos C/C++ e sistemas de compilação no Visual
Studio
Você pode usar o Visual Studio para editar, compilar e criar qualquer base de código C++ com suporte total ao
IntelliSense sem a necessidade de converter esse código em um projeto do Visual Studio ou compilar com o
conjunto de ferramentas MSVC. Por exemplo, você pode editar um projeto CMake de plataforma cruzada no
Visual Studio em um computador Windows e compilá-lo para Linux usando o g + + em um computador Linux
remoto.
Compilação em C++
Criar um programa em C++ significa compilar o código-fonte de um ou mais arquivos e, em seguida, vincular
esses arquivos em um arquivo executável (. exe), uma biblioteca de carregamento dinâmico (. dll) ou uma
biblioteca estática (. lib).
A compilação básica do C++ envolve três etapas principais:
O pré-processador de C++ transforma todas as definições de #directives e macro em cada arquivo de
origem. Isso cria uma unidade de tradução.
O compilador C++ compila cada unidade de tradução em arquivos de objeto (. obj), aplicando quaisquer
opções de compilador definidas.
O vinculador mescla os arquivos de objeto em um único executável, aplicando as opções de vinculador que
foram definidas.
O conjunto de ferramentas MSVC

O compilador do Microsoft C++, o vinculador, as bibliotecas padrão e os utilitários relacionados compõem o
conjunto de ferramentas do compilador MSVC (também chamado de ferramentas ou "ferramentas de Build").
Eles estão incluídos no Visual Studio. Você também pode baixar e usar o conjunto de ferramentas como um
pacote autônomo gratuito das ferramentas de Build para o download do Visual Studio 2019.
Você pode criar programas simples invocando o compilador MSVC (cl.exe) diretamente da linha de comando. O
comando a seguir aceita um único arquivo de código-fonte e invoca cl.exe para criar um executável chamado
hello.exe:
cl /EHsc hello.cpp
Aqui, o compilador (cl.exe) invoca automaticamente o pré-processador do C++ e o vinculador para produzir o
arquivo de saída final. Para obter mais informações, consulte criando na linha de comando.
Compilar sistemas e projetos

A maioria dos programas do mundo real usa algum tipo de sistema de compilação para gerenciar
complexidades de compilação de vários arquivos de origem para várias configurações (debug vs. Release),
várias plataformas (x86, x64, ARM e assim por diante), etapas de compilação personalizadas e até mesmo vários
executáveis que devem ser compilados em uma determinada ordem. As configurações são feitas em um ou
mais arquivos de configuração de compilação, e o sistema de compilação aceita esse arquivo como entrada
antes de invocar o compilador. O conjunto de arquivos de código-fonte e arquivos de configuração de
compilação necessários para criar um arquivo executável é chamado de projeto.
A lista a seguir mostra várias opções para projetos do Visual Studio-C++:
Crie um projeto do Visual Studio usando o IDE do Visual Studio e configure-o usando páginas de
propriedades. Os projetos do Visual Studio produzem programas que são executados no Windows. Para
obter uma visão geral, consulte compilando e compilando na documentação do Visual Studio.
Abra uma pasta que contenha um arquivo de CMakeLists.txt. O suporte do CMake é integrado ao Visual
Studio. Você pode usar o IDE para editar, testar e depurar sem modificar os arquivos CMake de forma
alguma. Isso permite que você trabalhe no mesmo projeto CMake que outras pessoas que podem estar
usando editores diferentes. CMake é a abordagem recomendada para o desenvolvimento de plataforma
cruzada. Para obter mais informações, consulte projetos do cmake.
Abra uma pasta flexível de arquivos de origem sem arquivo de projeto. O Visual Studio usará a heurística
para criar os arquivos. Essa é uma maneira fácil de compilar e executar pequenos aplicativos de console.
Para obter mais informações, consulte abrir projetos de pasta.
Abra uma pasta que contenha um makefile ou qualquer outro arquivo de configuração do sistema de
compilação. Você pode configurar o Visual Studio para invocar qualquer comando de Build arbitrário
Adicionando arquivos JSON à pasta. Para obter mais informações, consulte abrir projetos de pasta.
Abra um Makefile do Windows no Visual Studio. Para obter mais informações, consulte referência de
NMAKE.
MSBuild da linha de comando

Você pode invocar o MSBuild na linha de comando passando-o um arquivo. vcxproj juntamente com as opções
de linha de comando. Essa abordagem requer uma boa compreensão do MSBuild e é recomendada somente
quando necessário. Para mais informações, consulte MSBuild.
Nesta seção
Projetos do Visual Studio
Como criar, configurar e criar projetos C++ no Visual Studio usando seu MSBuild (sistema de compilação
nativa).
Projetos do CMake
Como codificar, compilar e implantar projetos CMake no Visual Studio.
Abrir projetos de pasta
Como usar o Visual Studio para codificar, criar e implantar projetos C++ com base em qualquer sistema de
compilação arbitrário, ou sem nenhum sistema de compilação.
Builds de versão
Como criar e solucionar problemas de builds de versão otimizados para implantação para usuários finais.
Usar o conjunto de ferramentas MSVC da linha de comando
Discute como usar o compilador C/C++ e as ferramentas de compilação diretamente da linha de comando em
vez de usar o IDE do Visual Studio.
Criando DLLs no Visual Studio
Como criar, depurar e implantar DLLs C/C++ (bibliotecas compartilhadas) no Visual Studio.
Walkthrough: Criando e usando uma biblioteca estática
Como criar um arquivo binário . lib .
Criando aplicativos isolados C/C++ e assemblies lado a lado
Descreve o modelo de implantação de aplicativos para Windows Desktop, com base na ideia de aplicativos
isolados e assemblies lado a lado.
Configurar projetos C++ para destinos de 64 bits, x64
Como direcionar o hardware de 64 bits x64 com as ferramentas de Build do MSVC.
Configurar projetos C++ para processadores ARM
Como usar as ferramentas de Build do MSVC para direcionar o hardware ARM.
Otimizando seu código
Como otimizar seu código de várias maneiras, incluindo otimizações guiadas por programa.
Configurando programas para o Windows XP
Como direcionar o Windows XP com as ferramentas de Build do MSVC.
Referência de compilação do C/C++
Fornece links para artigos de referência sobre compilação de programa em C++, opções de compilador e
vinculador, e outras ferramentas de compilação.
Ler e entender o código C++ no Visual Studio
O editor de códigos e o IDE do Visual Studio fornecem muitos recursos de codificação. Alguns são exclusivos ao
C++ e outros são essencialmente os mesmos para todas as linguagens Visual Studio. Para obter mais
informações sobre as funcionalidades compartilhadas, confira Escrevendo um código no Editor de Códigos e de
Texto.
Colorização
O Visual Studio colore elementos de sintaxe para diferenciar entre tipos de símbolos, como palavras-chave de
linguagem, nomes de tipos, nomes de variáveis, parâmetros de função, literais de cadeia de caracteres e assim
por diante.
O código não utilizado (como o código em um #if 0) tem uma cor mais esmaecida.
Personalize as cores digitando "Fontes" em Início Rápido e, em seguida, escolhendo Fontes e Cores . Na caixa
de diálogo Fontes e Cores , role a página para baixo até as opções do C/C++ e, em seguida, escolha uma fonte
e/ou uma cor personalizada.
Estrutura de tópicos
Clique com o botão direito do mouse em qualquer lugar em um arquivo de código-fonte e escolha Estrutura
de Tópicos para recolher ou expandir blocos de código e/ou regiões personalizadas, a fim de facilitar a
navegação apenas pelo código de seu interesse. Para obter mais informações, consulte Estrutura de tópicos.
Quando você coloca o cursor na frente de uma chave, '{' ou '}', o editor realça seu equivalente correspondente.
Outras opções de delineamento estão localizadas em Editar > Delineamento no menu principal.
Números de linha
Você pode adicionar números de linha ao seu projeto indo para Ferramentas Opções Editor de Texto Todas as
Linguagens Geral ou pesquisando "número de linhas" com > > > > Início Rápido (Ctrl + Q) . Os números de
linha podem ser definidos para todas as linguagens ou para linguagens específicas, incluindo C++.
Rolar e aplicar zoom

Você pode ampliar ou reduzir a página no editor pressionando a tecla Ctrl e rolando a página com o botão de
rolagem do mouse. Também é possível aplicar zoom usando a configuração de zoom no canto inferior
esquerdo.
O Modo de Mapa da barra de rolagem permite que você role a página e navegue por um arquivo de código
rapidamente sem sair da localização atual. Clique em qualquer lugar no mapa de códigos para ir diretamente
para essa localização.
Para ativar o Modo de Mapa , digite "map" na caixa Início Rápido de pesquisa na barra de ferramentas
principal e escolha Usar o modo de mapa de rolagem . Para obter mais informações, confira Como
acompanhar o código personalizando a barra de rolagem.
Quando o Modo de Mapa estiver desativado, a barra de rolagem ainda realçará as alterações feitas no arquivo.
A cor verde indica as alterações salvas e a cor amarela indica as alterações não salvas.
Informações Rápidas e Informações de Parâmetro

Passe o mouse sobre qualquer variável, função ou outro símbolo para obter informações sobre ele, incluindo a
declaração e os comentários localizados logo antes dela.
A dica de ferramenta Informações Rápidas tem um link Pesquisar Online . Vá para Opções de
Ferramentas > > Exibição > C++ do Editor de Texto > para especificar o provedor de pesquisa.
Se houver um erro no código, passe o mouse sobre ele, e as Informações Rápidas exibirão a mensagem de
erro. Encontre também a mensagem de erro na janela Lista de Erros.
Se houver um erro no código, passe o mouse sobre ele, e as Informações Rápidas exibirão a mensagem de
erro. Encontre também a mensagem de erro na janela Lista de Erros .
Quando você chama uma função, a opção Informações de Parâmetro mostra os tipos de parâmetros e a
ordem na qual eles são esperados.
Inspecionar Definição
Passe o mouse sobre uma variável ou uma declaração da função, clique com o botão direito do mouse e, em
seguida, escolha Inspecionar Definição para ver uma exibição embutida de sua definição sem sair da
localização atual. Para obter mais informações, confira Inspecionar Definição (Alt+F12).
Ajuda F1
Posicione o cursor sobre qualquer tipo, palavra-chave ou função ou imediatamente após eles e pressione F1
para ir diretamente para o tópico de referência relevante em docs.microsoft.com. F1 também funciona em itens
da Lista de Erros e em muitas caixas de diálogo.
Exibição de Classe
O Modo de Exibição de Classe exibe um conjunto pesquisável de árvores de todos os símbolos de códigos e
suas hierarquias de pai/filho e escopo, organizadas por projeto. Configure o que o Modo de Exibição de
Classe exibe em Configurações do Modo de Exibição de Classe (clique no ícone da caixa de engrenagem
na parte superior da janela).
Gerar grafo de arquivos de inclusão

Clique com o botão direito do mouse em um arquivo de código no projeto e escolha Gerar grafo de arquivos
de inclusão para ver um grafo de quais arquivos são incluídos por outros arquivos.
Exibir Hierarquia de Chamada

Clique com o botão direito do mouse em qualquer chamada de função e exiba uma lista recursiva de todas as
funções chamadas por ela e de todas as funções que a chamam. Cada função na lista pode ser expandida da
mesma maneira. Para obter mais informações, confira Hierarquia de chamada.
Consulte Também
Editar e refatorar o código (C++)
Navegar pela base de código C++ no Visual Studio
Colaborar com o Live Share para C++
Visão geral de programação do Windows no C++
Há várias categorias amplas de aplicativos do Windows que você pode criar com o C++. Cada uma tem seu
próprio modelo de programação e conjunto de bibliotecas específicas do Windows, mas a biblioteca c++
Standard e bibliotecas de C++ de terceiros podem ser usadas em qualquer uma delas.
Esta seção discute como usar o Visual Studio e as bibliotecas de wrapper MFC/ATL para criar programas do
Windows. Para obter a documentação sobre a própria plataforma Windows, consulte a documentação do
Windows.
Aplicativos de linha de comando (console)

Os aplicativos de console do C++ são executados a partir da linha de comando em uma janela de console e
podem exibir apenas a saída de texto. Para obter mais informações, consulte criar uma calculadora de console
em C++.
Aplicativos cliente de desktop nativos

Um aplicativo cliente de desktop nativo é um aplicativo em janelas c ou C++ que usa as APIs nativas do
Windows c ou as APIs de Component Object Model (com) originais para acessar o sistema operacional. Essas
APIs são escritas em grande parte em C. Há mais de uma maneira de criar um aplicativo de área de trabalho
nativo: você pode programar usando as APIs do Win32 diretamente, usando um loop de mensagem em estilo C
que processa eventos do sistema operacional. Ou, você pode programar usando o MFC (MFC), uma biblioteca
C++ levemente orientada a objeto que encapsula o Win32. Nenhuma abordagem é considerada "moderna" em
comparação com a Plataforma Universal do Windows (UWP), mas ambas ainda têm suporte total e têm milhões
de linhas de código em execução no mundo hoje. Um aplicativo Win32 que é executado em uma janela requer
que o desenvolvedor trabalhe explicitamente com mensagens do Windows dentro de uma função de
procedimento do Windows. Apesar do nome, um aplicativo Win32 pode ser compilado como um binário de 32
bits (x86) ou 64 bits (x64). No IDE do Visual Studio, os termos x86 e Win32 são sinônimos.
Para começar a usar a programação tradicional do Windows C++, consulte Introdução ao Win32 e ao C++.
Depois de obter alguma compreensão do Win32, será mais fácil aprender sobre os aplicativos da área de
trabalho do MFC. Para ver um exemplo de um aplicativo de área de trabalho C++ tradicional que usa gráficos
sofisticados, consulte Olá: Desenvolvendo aplicativos C++ para Windows.
C++ ou .NET?
Em geral, a programação do .NET em C# é menos complexa, menos propensa a erros e tem uma API mais
moderna orientada a objeto do que Win32 ou MFC. Na maioria dos casos, seu desempenho é mais do que
adequado. O .NET apresenta o Windows Presentation Foundation (WPF) para gráficos avançados e você pode
consumir o Win32 e a API de Windows Runtime moderna. Como regra geral, recomendamos o uso do C++
para aplicativos da área de trabalho quando você precisar:
controle preciso sobre o uso de memória
a economia econômica no consumo de energia
uso da GPU para computação geral
acesso ao DirectX
uso intenso de bibliotecas C++ padrão
Também é possível combinar a potência e a eficiência do C++ com a programação do .NET. Você pode criar uma
interface do usuário em C# e usar c++/CLI para permitir que o aplicativo consuma bibliotecas nativas do C++.
Para obter mais informações, consulte Programação do .NET com C++/CLI.
Componentes COM
O Component Object Model (COM) é uma especificação que permite que programas escritos em linguagens
diferentes se comuniquem entre si. Muitos componentes do Windows são implementados como objetos COM e
seguem regras COM padrão para criação de objeto, descoberta de interface e destruição de objeto. Usar objetos
COM de aplicativos da área de trabalho do C++ é relativamente simples, mas escrever seu próprio objeto COM
é mais avançado. O Active Template Library (ATL) fornece macros e funções auxiliares que simplificam o
desenvolvimento COM. Para obter mais informações, consulte Componentes da área de trabalho COM da ATL.
Aplicativos da Plataforma Universal do Windows

O Plataforma Universal do Windows (UWP) é a API moderna do Windows. Os aplicativos UWP são executados
em qualquer dispositivo Windows 10, usam XAML para a interface do usuário e são totalmente habilitados para
toque. Para obter mais informações sobre a UWP, consulte o que é um aplicativo UWP (plataforma universal do
Windows)? e guia para aplicativos universais do Windows.
O suporte original a C++ para UWP consistiu em (1) C++/CX, um dialeto de C++ com extensões de sintaxe ou
(2) a biblioteca de Windows Runtime (WRL), que é baseada em C++ e COM padrão. O C++/CX e o WRL ainda
têm suporte. Para novos projetos, recomendamos o c++/WinRT, que é totalmente baseado no c++ padrão e
fornece um desempenho mais rápido.
Ponte de Desktop
No Windows 10, você pode empacotar seu aplicativo de área de trabalho existente ou objeto COM como um
aplicativo UWP e adicionar recursos UWP, como toque, ou chamar APIs do conjunto de API do Windows
moderno. Você também pode adicionar um aplicativo UWP a uma solução de desktop no Visual Studio e
empacotá-los juntos em um único pacote e usar APIs do Windows para se comunicar entre eles.
O Visual Studio 2017 versão 15,4 e posterior permite que você crie um projeto de pacote de aplicativos do
Windows para simplificar bastante o trabalho de empacotamento de seu aplicativo de área de trabalho
existente. Algumas restrições se aplicam às chamadas de registro ou APIs que seu aplicativo de desktop pode
usar. No entanto, em muitos casos, você pode criar caminhos de código alternativos para obter uma
funcionalidade semelhante durante a execução em um pacote de aplicativo. Para saber mais, veja Ponte de
Desktop.
Jogos
Os jogos do DirectX podem ser executados no PC ou no Xbox. Para obter mais informações, consulte elementos
gráficos do DirectX e jogos.
Clientes de banco de dados SQL Server

Para acessar bancos de dados SQL Server de código nativo, use ODBC ou OLE DB. Para obter mais informações,
consulte SQL Server Native Client.
Drivers de dispositivos Windows

Os drivers são componentes de nível baixo que tornam os dados de dispositivos de hardware acessíveis a
aplicativos e outros componentes do sistema operacional. Para obter mais informações, consulte Windows
Driver Kit (WDK).
Serviços Windows
Um serviço do Windows é um programa que pode ser executado em segundo plano com pouca ou nenhuma
interação do usuário. Esses programas são chamados de daemons em sistemas UNIX. Para obter mais
informações, consulte Serviços.
SDKs, bibliotecas e arquivos de header

Visual Studio inclui a CRT (Biblioteca de Runtime C), a Biblioteca Padrão C++ e outras bibliotecas específicas da
Microsoft. A maioria das pastas de inclusão que contêm arquivos de header para essas bibliotecas está
localizada no diretório de instalação Visual Studio na pasta \VC. Os arquivos de header do Windows e do CRT
são encontrados na pasta SDK do Windows instalação.
O gerenciador de pacotes vcpkg permite instalar convenientemente centenas de bibliotecas de software livre de
terceiros para Windows. Para obter mais informações, consulte vcpkg.
As bibliotecas da Microsoft incluem:
Microsoft Foundation Classes (MFC): uma estrutura orientada por objeto para criação de programas
tradicionais do Windows (especialmente aplicativos empresariais) que têm interfaces de usuário
avançadas que apresentam botões, caixas de listagem, modos de exibição de árvore e outros controles.
Para obter mais informações, consulte Aplicativos da área de trabalho MFC.
Active Template Library (ATL): uma biblioteca auxiliar potente para criação de componentes COM. Para
obter mais informações, consulte Componentes da área de trabalho COM da ATL.
C++ AMP (C++ Accelerated Massive Parallelism): uma biblioteca que permite trabalho computacional
geral de alto desempenho na GPU. Para obter mais informações, consulte C++ AMP (C++ Accelerated
Massive Parallelism).
Runtime de Simultaneidade: uma biblioteca que simplifica o trabalho da programação paralela e
assíncrona para dispositivos de vários e muitos núcleos. Para obter mais informações, consulte Runtime
de Simultaneidade.
Muitos cenários de programação do Windows também exigem o Windows SDK, que inclui os arquivos de
cabeçalho que permitem acesso aos componentes do sistema operacional Windows. Por padrão, Visual Studio o
SDK do Windows como um componente da carga de trabalho da Área de Trabalho do C++, que permite o
desenvolvimento de aplicativos Universais do Windows. Para desenvolver aplicativos UWP, você precisa da
Windows 10 do SDK do Windows. Para obter informações, consulte Windows 10 SDK. (Para obter mais
informações sobre os SDKs do Windows para versões anteriores do Windows, consulte o arquivo SDK do
Windows ).
Arquivos de Programas (x86)\Windows Kits é o local padrão para todas as versões do SDK do Windows
que você instalou.
Outras plataformas, como Xbox e Azure têm seus próprios SDKs que talvez você precise instalar. Para obter mais
informações, consulte Centro de desenvolvedores do DirectX e o Centro de desenvolvedores do Azure.
Ferramentas de desenvolvimento
O Visual Studio inclui um depurador potente para código nativo, ferramentas de análise estática, ferramentas de
depuração gráfica, um editor de código com recursos completos, suporte para testes de unidade e muitos
outros utilitários e ferramentas. Para obter mais informações, consulte Get started developing with Visual
Studioe Overview of C++ development in Visual Studio.
Nesta seção
T ÍT ULO DESC RIÇ Ã O
Passo a passo: criando um programa C++ padrão Crie um aplicativo de console do Windows.
Passo a passo: criando aplicativos da área de trabalho do Crie um aplicativo nativo da área de trabalho do Windows.
Windows (C++)
Assistente de Área de Trabalho do Windows Use o assistente para criar novos projetos do Windows.
ATL (Active Template Library) Use a biblioteca do ATL para criar componentes COM em
C++.
MFC (Microsoft Foundation Classes) Use o MFC para criar aplicativos grandes ou pequenos do
Windows com caixas de diálogo e controles
Classes compartilhadas ATL e MFC Use classes como CString que são compartilhadas em ATL e
MFC.
Acesso a dados OLE DB e ODBC
Texto e cadeias de caracteres Vários tipos de cadeia de caracteres no Windows.
Recursos para criar um jogo usando o DirectX
Como: usar o SDK do Windows 10 em um aplicativo de área SDK do Windows

de trabalho do Windows
Trabalhando com arquivos de recurso Como adicionar imagens, ícones, tabelas de cadeia de
caracteres e outros recursos a um aplicativo de área de
trabalho.
Recursos para criar um jogo usando DirectX (C++) Links para conteúdo para criar jogos em C++.
Como: usar o SDK do Windows 10 em um aplicativo de área Contém etapas para configurar seu projeto para criar
de trabalho do Windows usando o SDK do Windows 10.
Como implantar aplicativos da área de trabalho nativos Implante aplicativos nativos no Windows.
Artigos relacionados
C++ no Visual Studio Tópico pai para conteúdo do Visual C++ Developer.
Desenvolvimento do .NET com C++/CLI Crie wrappers para bibliotecas C++ nativas que permitem a
comunicação com aplicativos e componentes .NET.
Extensões de componente para .NET e UWP Referência para elementos de sintaxe compartilhados por
C++/CX e C++/CLI.
Aplicativos universais do Windows (C++) Grave aplicativos UWP usando C++/CX ou WRL (biblioteca
de modelos do Windows Runtime).
Atributos C++ para COM e .NET Atributos não padrão para programação somente do
Windows usando .NET ou COM.
Aplicativos universais do Windows (C++)
O Plataforma Universal do Windows (UWP) é a interface de programação moderna para o Windows. Com o
UWP, você escreve um aplicativo ou componente uma vez e o implanta em qualquer dispositivo Windows 10.
Você pode escrever um componente em C++ e os aplicativos escritos em qualquer outra linguagem compatível
com UWP podem usá-lo.
A maior parte da documentação do UWP está na árvore de conteúdo do Windows na documentação plataforma
universal do Windows. Lá, você encontrará tutoriais de início, bem como documentação de referência.
Para novos aplicativos e componentes UWP, recomendamos que você use C++/WinRT, uma nova projeção de
linguagem c++ 17 padrão para APIs de Windows Runtime. O C++/WinRT está disponível no SDK do Windows
10 da versão 1803 em diante. O C++/WinRT é implementado inteiramente em arquivos de cabeçalho e foi
projetado para fornecer a você acesso de primeira classe à API moderna do Windows. Diferentemente da
implementação do C++/CX, o C++/WinRT não usa sintaxe não padrão nem extensões de linguagem da
Microsoft, e aproveita totalmente o compilador C++ para criar uma saída altamente otimizada. Para obter mais
informações, consulte introdução ao C++/WinRT.
Você pode usar o conversor de aplicativo de ponte de área de trabalho para empacotar seu aplicativo de área de
trabalho existente para implantação por meio do Microsoft Store. Para obter mais informações, consulte Using
Visual C++ Runtime in Centennial Project and Desktop Bridge.
Aplicativos UWP que usam C++/CX

Referência de linguagem do C++/CX
Descreve o conjunto de extensões que simplificam o consumo de C++ de Windows Runtime de APIs e habilitam
o tratamento de erros com base em exceções.
Criando aplicativos e bibliotecas (C++/CX)
Descreve como criar DLLs e bibliotecas estáticas que podem ser acessadas de um aplicativo ou componente
C++/CX.
Tutorial: criar um aplicativo "Olá, mundo" UWP em C++/CX
Uma explicação que apresenta os conceitos básicos do desenvolvimento de aplicativos UWP em C++/CX.
Criando componentes de Windows Runtime em C++/CX
Descreve como criar DLLs que outros aplicativos e componentes UWP podem consumir.
Programação de jogos UWP
Descreve como usar o DirectX e C++/CX para criar jogos.
Aplicativos UWP que usam a Windows Runtime WRL (biblioteca de

modelos C++)
A biblioteca de modelos do Windows Runtime C++ fornece as interfaces COM de baixo nível pelas quais o
código ISO C++ pode acessar o Windows Runtime em um ambiente sem exceções. Na maioria dos casos,
recomendamos que você use C++/WinRT ou C++/CX em vez da biblioteca de modelos do Windows Runtime
C++ para desenvolvimento de aplicativos UWP. Para obter informações sobre a Windows Runtime biblioteca de
modelos C++, consulte Windows Runtime C++ Template Library (WRL).
Veja também
Visão geral da programação do Windows em C++
Desenvolvimento de jogos com C++
Quando você cria um jogo do Windows 10, tem a oportunidade de alcançar milhões de jogadores em todo
mundo no celular, computador e Xbox One. Com o Xbox no Windows, o Xbox Live, multijogadores entre
dispositivos, uma incrível comunidade de jogos e os novos recursos avançados como a UWP (Plataforma
Universal do Windows) e o DirectX 12, os jogos do Windows 10 emocionam jogadores de todas as idades e
gêneros. A nova UWP (Plataforma Universal do Windows) oferece compatibilidade para seu jogo entre
dispositivos Windows 10 com uma API comum para celular, computador e Xbox One, juntamente com
ferramentas e opções para ajustar seu jogo a cada experiência do dispositivo.
O desenvolvimento de jogos está documentado no Centro de Desenvolvimento do Windows.
Por padrão, os projetos CLR criados com o Visual Studio 2015 de destino .NET Framework 4.5.2. Você pode
direcionar .NET Framework 4,6 ao criar um novo projeto. Na caixa de diálogo novo projeto , altere a estrutura
de destino na lista suspensa na parte superior da caixa de diálogo. Para alterar a estrutura de destino de um
projeto existente, feche o projeto, edite o arquivo de projeto ( .vcxproj ) e altere o valor da versão do
Framework de destino para 4,6. As alterações entrarão em vigor na próxima vez que você abrir o projeto.
No Visual Studio 2017, o .NET Framework de destino padrão é 4.6.1. O seletor de versão do Framework está na
parte inferior da caixa de diálogo novo projeto .
Instalar o suporte a C++/CLI no Visual Studio 2017

O c++/CLI em si não é instalado por padrão quando você instala uma carga de trabalho do Visual Studio C++.
Para instalar o componente após a instalação do Visual Studio, abra o Instalador do Visual Studio. Escolha o
botão Modificar ao lado da versão instalada do Visual Studio. Selecione a guia componentes instalados .
Role para baixo até a seção compiladores, ferramentas de compilação e tempos de execução e selecione
supor te a C++/CLI . Escolha Modificar para atualizar o Visual Studio.
No Visual Studio 2019, a estrutura de destino padrão para projetos do .NET Core é 5,0. Para projetos do .NET
Framework, o padrão é 4.7.2. O seletor de versão .NET Framework está na página Configurar o novo projeto
da caixa de diálogo criar um novo projeto .
Instalar o suporte a C++/CLI no Visual Studio 2019

O c++/CLI em si não é instalado por padrão quando você instala uma carga de trabalho do Visual Studio C++.
Para instalar o componente após a instalação do Visual Studio, abra o Instalador do Visual Studio. Escolha o
botão Modificar ao lado da versão instalada do Visual Studio. Selecione a guia componentes instalados .
Role para baixo até a seção compiladores, ferramentas de compilação e tempos de execução e selecione
o supor te a C++/CLI mais recente para o componente ferramentas de Build do v142 . Escolha
Modificar para atualizar o Visual Studio.
Nesta seção
Tarefas do C++/CLI
Interoperabilidade .NET e nativa
Código puro e verificável (C++/CLI)
Expressões regulares (C++/CLI)
Manipulação de arquivos e e/s (C++/CLI)
Operações de gráficos (C++/CLI)
Operações do Windows (C++/CLI)
Acesso a dados usando ADO.NET (C++/CLI)
Interoperabilidade com outras linguagens .NET (C++/CLI)
Serialização (C++/CLI)
Tipos gerenciados (C++/CLI)
Reflexão (C++/CLI)
Assemblies de nome forte (assinatura de assembly) (C++/CLI)
Classe de depuração (C++/CLI)
Referência de biblioteca STL/CLR
Biblioteca de suporte do C++
Exceções em C++/CLI
Conversão boxing (C++/CLI)
Confira também
Interoperabilidade .NET e nativa
Nuvem e programação da Web no Visual C++
No C++ há várias opções para conectar-se com a Web e com a nuvem.
Serviços REST e SDKs do Microsoft Azure

Biblioteca de Clientes do Armazenamento do Microsoft Azure para C++
A Biblioteca de Clientes do Armazenamento do Azure para C++ oferece uma API abrangente para
trabalhar com o armazenamento do Azure, incluindo, entre outras, as seguintes capacidades:
Criar, ler, excluir e listar contêineres de blobs, tabelas e filas.
Criar, ler, excluir, listar e copiar blobs, além de ler e escrever intervalos de blobs.
Inserir, excluir, substituir, mesclar e consultar entidades em uma tabela do Azure.
Enfileirar e desenfileirar mensagens em uma fila do Azure.
Listar lentamente contêineres, blobs, tabelas e filas e consultar lentamente entidades
O ANSI C99 SDKs do Hub IoT do Azure para a Internet das Coisas permite que os aplicativos de IoT sejam
executados no dispositivo ou no back-end.
OneDrive e SharePoint no Microsoft Graph
A API do OneDrive fornece um conjunto de serviços HTTP para conectar seu aplicativo a arquivos e
pastas no Microsoft 365 e no SharePoint Server 2016.
APIs de rede do Windows e de multiplataforma

C++ REST SDK (codinome "Casablanca")
Fornece uma API moderna, multiplataforma e assíncrona para interagir com serviços REST.
Realize chamadas REST com relação a qualquer servidor HTTP, com suporte interno para análise e
serialização de documento JSON
É compatível com OAuth 1 e 2, incluindo um ouvinte de redirecionamento local
Realize conexões WebSockets com relação a serviços remotos
Uma API de tarefa totalmente assíncrona baseada em PPL, incluindo um pool de thread interno
É compatível com Área de Trabalho do Windows (7+), Windows Server (2012+), Plataforma Universal do
Windows, Linux, OSX, Android e iOS.
Windows::Web::Http::HttpClient
Uma classe de cliente HTTP do Windows Runtime modelada na classe .NET Framework do mesmo nome
no namespace System.Web. HttpClient é completamente compatível com upload e download
assíncronos por HTTP e com os filtros de pipeline que permitem a inserção de manipuladores HTTP
personalizados no pipeline. O SDK do Windows inclui os filtros de exemplo para redes limitadas,
autenticação OAuth e mais. Para aplicativos que direcionam apenas a Plataforma Universal do Windows,
é recomendável que você use a classe Windows::Web:HttpClient .
Interface IXMLHTTPRequest2
Oferece uma internet COM nativa que pode ser usada em aplicativos do Windows Runtime ou de área de
trabalho do Windows para se conectar à Internet por HTTP e emitir comandos GET, PUT e outros
comandos HTTP. Para obter mais informações, consulte Walkthrough: conectando usando tarefas e
solicitações HTTP XML.
WinInet (Windows Internet)
A API do Windows que pode ser usada em aplicativos de área de trabalho do Windows para se conectar à
Internet.
Veja também
Central de Desenvolvedores do Microsoft Azure C e C++
Redes e serviços Web (UWP)
Guia de atualização e portabilidade do Microsoft
C++
Este artigo fornece um guia para atualizar o código do Microsoft C++ para a versão mais recente do Visual
Studio. Para projetos criados no Visual Studio 2010 até 2017, basta abrir o projeto no Visual Studio 2019. Você
pode atualizar um projeto do Visual Studio 2008 ou anterior em duas etapas. Use o Visual Studio 2010 para
converter o projeto para o formato MSBuild primeiro. Em seguida, abra o projeto no Visual Studio 2019. Para
obter instruções completas, consulte Atualizando projetos C++ de versões anteriores do Visual Studio.
Os conjuntos de ferramentas no Visual Studio 2015, Visual Studio 2017 e Visual Studio 2019 são compatíveis
com binários. Agora você pode atualizar para uma versão mais recente do compilador sem precisar atualizar
suas dependências de biblioteca. Para obter mais informações, consulte compatibilidade binária de C++ 2015-
2019.
Ao atualizar projetos que usam bibliotecas de software livre ou que devem ser executados em várias
plataformas, recomendamos migrar para um projeto baseado em CMake. Para obter mais informações, consulte
projetos do cmake no Visual Studio
Motivos para atualizar o código C++

Se um aplicativo herdado estiver em execução satisfatoriamente, em um ambiente seguro e não estiver em
desenvolvimento ativo, pode não haver muito incentivo para atualizá-lo. No entanto, considere uma atualização
nesses casos: seu aplicativo requer manutenção contínua. Ou você está fazendo um novo desenvolvimento de
recursos ou fazendo melhorias de desempenho ou segurança. Uma atualização traz estes benefícios:
O mesmo código pode ser executado mais rapidamente, pois aprimoramos as otimizações do
compilador.
Os recursos modernos do C++ e as práticas de programação eliminam muitas causas comuns dos bugs
e geram um código que é muito mais fácil de manter do que os idiomas do estilo C mais antigos.
Os tempos de compilação são mais rápidos, devido às melhorias de desempenho no compilador e no
vinculador.
Melhor conformidade com os padrões. A opção de compilador /permissive- ajuda a identificar o código
que não está em conformidade com o padrão C++ atual. O novo pré-processador também dá suporte à
conformidade de código.
Melhor segurança em tempo de execução, incluindo recursos mais seguros da biblioteca de tempo de
execução C . E, os recursos do compilador, como verificação de proteção e corrigir os limpezas (novo no
Visual Studio 2019 versão 16,4).
Multidirecionamento versus atualização

Talvez atualizar sua base de código para um novo conjunto de ferramentas não é uma opção para você. Você
ainda pode usar o Visual Studio mais recente para criar e editar projetos que usam conjuntos de ferramentas e
bibliotecas mais antigos. No Visual Studio 2019, você pode aproveitar os recursos como:
ferramentas de análise estática modernas, incluindo os verificadores de Diretrizes Principais do C++ e
Clang, para ajudar a identificar possíveis problemas no código-fonte.
a formatação automática de acordo com a sua escolha de estilos modernos pode ajudar a tornar o
código herdado muito mais legível.
Para obter mais informações, consulte Usar a multiplataforma nativa no Visual Studio para compilar projetos
antigos.
Nesta seção
Atualizando projetos C++ de versões anteriores do Visual Como atualizar sua base de código para o Visual Studio
Studio 2019 e v142 do compilador.
Ferramentas IDE para atualizar o código C++ Recursos de IDE úteis que ajudam no processo de
atualização.
Compatibilidade binária de C++ 2015-2019 Consuma bibliotecas v140 e v141 no estado em que se
encontram de projetos v142.
Usar multiplataforma nativa no Visual Studio para compilar Use o Visual Studio 2019 com compiladores e bibliotecas
projetos antigos mais antigos.
Histórico de alterações de 2003 a 2015 do Visual C++ Uma lista de todas as alterações nas bibliotecas do Microsoft
C++ e ferramentas de compilação do Visual Studio 2003 até
2015 que podem exigir alterações no seu código.
O que há de novo no Visual C++ de 2003 até 2015 Todas as informações de "novidades" do Microsoft C++ do
Visual Studio 2003 por meio do Visual Studio 2015.
Portabilidade e atualização: exemplos e estudos de caso Nessa seção, portamos e atualizamos vários exemplos e
aplicativos e discutimos as experiências e os resultados. Esses
artigos oferecem uma noção do que está envolvido no
processo de portabilidade e atualização. Durante o processo,
discutimos a respeito de dicas e truques para a atualização e
mostramos como erros específicos foram corrigidos.
Portabilidade para a Plataforma Universal do Windows Contém informações sobre como fazer portabilidade de
código para o Windows 10
Introdução ao Visual C++ para usuários do UNIX Fornece informações para usuários do UNIX novatos no
Visual C++ e que desejam tornar-se produtivos com ele.
Como executar programas do Linux no Windows Discute as opções para migrar aplicativos UNIX para o
Windows.
Veja também
Novidades do compilador C++ no Visual Studio
Aprimoramentos de conformidade do C++ no Visual Studio
Este artigo contém informações sobre ferramentas e práticas de segurança. Elas não tornam os aplicativos
imunes a ataques, mas diminuem a probabilidade de ataques bem-sucedidos.
Recursos de segurança do Visual C++

Esses recursos de segurança são incorporados ao compilador e vinculador do Microsoft C++:
/guard (Habilitar a proteção de fluxo de controle)
Faz com que o compilador analise o fluxo de controle para destinos de chamada indireta em tempo de
compilação e, em seguida, insira o código para verificar os destinos em tempo de execução.
/GS (Verificação de segurança do buffer)
Instrui o compilador a inserir o código de detecção de saturação em funções que estão em risco de serem
exploradas. Quando uma saturação é detectada, a execução é interrompida. Por padrão, esta opção está ativada.
/SAFESEH (A imagem tem manipuladores de exceção segura)
Instrui o vinculador a incluir na imagem de saída uma tabela que contém o endereço de cada manipulador de
exceção. Em tempo de execução, o sistema operacional usa essa tabela para garantir que apenas os
manipuladores de exceção legítimos sejam executados. Isso ajuda a impedir a execução de manipuladores de
exceção introduzidos por um ataque mal-intencionado em tempo de execução. Por padrão, essa opção é
desativada.
/NXCOMPAT , /NXCOMPAT (Compatível com a prevenção de execução de dados) essas opções de compilador e
vinculador habilitam a compatibilidade de DEP (prevenção de execução de dados). A DEP protege a CPU contra
a execução de páginas sem código.
/analyze (Análise de código)
Essa opção do compilador ativa a análise de código que relata problemas potenciais de segurança, como
excesso de buffer, memória não inicializada, remoção de referência do ponteiro nulo e vazamentos de memória.
Por padrão, essa opção é desativada. Para obter mais informações, consulte análise de código para visão geral
do C/C++.
/DYNAMICBASE (Usar randomização de layout de espaço de endereço)
Essa opção do vinculador habilita a criação de uma imagem executável que pode ser carregada em locais
diferentes na memória no início da execução. Essa opção também torna o local da pilha na memória muito
menos previsível.
CRT de segurança aprimorada

A biblioteca em runtime C (CRT) foi aumentada para incluir versões seguras das funções que oferecem risco de
segurança — por exemplo, a função de cópia de cadeia de caracteres de strcpy não verificada. Como as
versões anteriores e não seguras dessas funções estão preteridas, elas causam avisos de tempo de compilação.
É recomendável usar as versões seguras dessas funções de CRT em vez de suprimir os avisos de compilação.
Para obter mais informações, consulte Recursos de segurança no CRT.
Biblioteca de SafeInt
A biblioteca SafeInt ajuda a evitar estouros inteiros e outros erros exploráveis que podem ocorrer quando o
aplicativo executa operações matemáticas. A SafeInt biblioteca inclui a classe SafeInt, a classe
SafeIntExceptione várias funções SafeInt.
A classe de SafeInt protege contra explorações de estouro de inteiro e de divisão por zero. Você pode usá-la
para tratar comparações entre valores de tipos diferentes. Ele fornece duas políticas de tratamento de erros. A
política padrão é que a classe SafeInt lance uma exceção da classe SafeIntException para relatar por que uma
operação matemática não pode ser concluída. A segunda política é que a classe SafeInt interrompa a execução
do programa. Você também pode definir uma política personalizada.
Cada função de SafeInt protege uma operação matemática contra um erro explorável. Você pode usar dois
tipos diferentes de parâmetros sem convertê-los no mesmo tipo. Para proteger várias operações matemáticas,
use a classe SafeInt .
Iteradores verificados
Um iterador verificado impõe limites do contêiner. Por padrão, quando um iterador verificado está fora dos
limites, ele gera uma exceção e finaliza a execução do programa. Um iterador verificado fornece outros níveis de
resposta que dependem de valores que são atribuídos a definições de pré-processador, como
_SECURE_SCL_THROWS e _ITERATOR_DEBUG_LEVEL . Por exemplo, em _ITERATOR_DEBUG_LEVEL=2 , um iterador
verificado fornece verificações de exatidão abrangentes no modo de depuração, que são disponibilizadas
usando declarações. Para obter mais informações, consulte iteradores marcados e _ITERATOR_DEBUG_LEVEL .
Análise de código para código gerenciado

A análise de código para código gerenciado, também conhecida como FxCop, verifica a conformidade dos
assemblies de acordo com as diretrizes de design do .NET Framework. O FxCop analisa o código e os
metadados de cada assembly para verificar se há falhas nestas áreas:
Design de biblioteca
Localização
Convenções de nomenclatura
Desempenho
Segurança
Verificador de aplicativo do Windows

O Application Verifier (AppVerifier) pode ajudá-lo a identificar possíveis problemas de compatibilidade,
estabilidade e segurança de aplicativos.
O AppVerifier monitora como um aplicativo usa o sistema operacional. Ele inspeciona o sistema de arquivos, o
Registro, a memória e as APIs enquanto o aplicativo está em execução, e recomenda correções do código-fonte
dos problemas que ele descobre.
Também é possível usar o AppVerifier para:
Testar possíveis erros de compatibilidade do aplicativo causados por erros comuns de programação.
Examinar um aplicativo por problemas relacionados à memória.
Identificar possíveis problemas de segurança em um aplicativo.
Contas de usuário do Windows

O uso de contas de usuário do Windows que pertencem ao grupo Administradores expõe os desenvolvedores e
— por extensão — os clientes a riscos de segurança. Para obter mais informações, consulte executando como
um membro do grupo usuários e como o UAC (controle de conta de usuário) afeta seu aplicativo.
Diretrizes para canais laterais de execução especulativa

Para obter informações sobre como facilitar e mitigar contra vulnerabilidades de hardware de canal lateral de
execução especulativa em software C++, consulte diretrizes para desenvolvedores de c++ para canais laterais
de execução especulativa.
Veja também
System.Security
Security
Como o UAC (controle de conta de usuário) afeta seu aplicativo
Executando como um membro do grupo de
usuários
Este tópico explica como a configuração de contas de usuário do Windows como membro do grupo Usuários
(em vez do grupo Administradores) aumenta a segurança reduzindo as chances de contaminação com código
mal-intencionado.
Riscos à segurança
A execução como administrador torna o sistema vulnerável a vários tipos de ataque de segurança, como
"cavalos de Troia" e "estouro de buffer". Uma simples visita a um site da Internet como administrador pode ser
danoso ao sistema, pois o código mal-intencionado que é baixado de um site da Internet pode atacar o
computador. Se ele for bem-sucedido, herdará as suas permissões de administrador e poderá executar ações
como excluir todos os arquivos, reformatar o disco rígido e criar novas contas de usuário com acesso
administrativo.
Grupos de usuários não administradores

As contas de usuário do Windows que os desenvolvedores normalmente usam devem ser adicionadas aos
grupos Usuários ou Usuários Avançados. Os desenvolvedores também devem ser adicionados ao grupo
Depuração. Ser um membro do grupo Usuários permite que você execute tarefas rotineiras, inclusive a
execução de programas e o acesso a sites da Internet, sem expor o computador a riscos desnecessários. Como
membro do grupo Usuários Avançados, você também pode executar tarefas como instalação de aplicativos,
instalação de impressoras e a maioria das operações do Painel de Controle. Se você precisa executar tarefas
administrativas, como atualizar o sistema operacional ou configurar parâmetros de sistema, faça logon em uma
conta de administrador apenas pelo tempo necessário para executar a tarefa administrativa. Como alternativa, o
comando runas do Windows pode ser usado para iniciar aplicativos específicos com acesso administrativo.
Exposição dos clientes a riscos de segurança

Não fazer parte do grupo Administradores é particularmente importante para desenvolvedores porque, além
de proteger os computadores de desenvolvimento, impede que os desenvolvedores escrevam
inadvertidamente um código que exija que os clientes ingressem no grupo Administradores para executar os
aplicativos que você desenvolve. Se código que requer acesso de administrador é introduzido durante o
desenvolvimento, ele falhará em runtime, alertando para o fato de que o aplicativo exige agora que os clientes
executem como administradores.
Código que exige privilégios de administrador

Alguns códigos exigem acesso de administrador para serem executados. Se possível, devem ser estudadas
alternativas a esse tipo de código. Exemplos de operações de código que requerem acesso de administrador
são:
Gravação em áreas protegidas do sistema de arquivos, como os diretórios Windows ou Arquivos de
Programas
Gravação em áreas protegidas do Registro, como HKEY_LOCAL_MACHINE
Instalação de assemblies no Cache de Assembly Global (GAC)
Em geral, essas ações devem ser limitadas aos programas de instalação de aplicativos. Isso permite que os
usuários utilizem o status de administrador somente temporariamente.
Depuração
Você pode depurar todos os aplicativos que iniciar no Visual Studio (nativos e não gerenciados) como não
administrador tornando-se parte do grupo Depuração. Isso inclui a capacidade de anexar a um aplicativo em
execução usando o comando Anexar ao Processo. No entanto, é necessário fazer parte do grupo Administrador
para depurar aplicativos nativos ou gerenciados iniciados por um usuário diferente.
Veja também
Como o Controle de Conta de Usuário (UAC) afeta
o aplicativo
O UAC (Controle de Conta de Usuário) é um recurso do Windows Vista no qual as contas de usuário têm
privilégios limitados. Você pode encontrar informações detalhadas sobre o UAC nestes sites:
Práticas recomendadas e diretrizes para aplicativos em um ambiente com privilégios mínimos
Criando projetos após a habilitação do UAC

Se você criar um projeto do Visual Studio C++ no Windows Vista com o UAC desabilitado e habilitar o UAC
posteriormente, deverá limpar e recriar o projeto para que ele funcione corretamente.
Aplicativos que exigem privilégios de administrador

Por padrão, o Visual C++ inserir um fragmento UAC no manifesto de um aplicativo com um nível de execução
de asInvoker . Se o aplicativo requer privilégios administrativos para ser executado corretamente (por exemplo,
se ele altera o nó HKLM do Registro ou se grava nas áreas protegidas do disco, como o diretório do Windows),
modifique seu aplicativo.
A primeira opção é modificar o fragmento UAC do manifesto para alterar o nível de execução para
requireAdministrator. O aplicativo solicitará que o usuário forneça as credenciais administrativas para que seja
executado. Para obter informações sobre como fazer isso, consulte /MANIFESTUAC (Insemite informações do
UAC no manifesto).
A segunda opção é não inserir um fragmento do UAC no manifesto especificando a opção /MANIFESTUAC:NO do
vinculador. Nesse caso, o aplicativo será executado virtualizado. Todas as alterações feitas no Registro ou no
sistema de arquivos não persistirão depois que o aplicativo for encerrado.
Este fluxograma descreve como o aplicativo será executado, caso o UAC esteja habilitado e caso o aplicativo
tenha um manifesto do UAC:
Confira também
Diretrizes para desenvolvedores do C++ para
canais laterais de execução especulativa
Este artigo contém orientações para os desenvolvedores auxiliarem na identificação e mitigação de

vulnerabilidades de hardware de canal lateral de execução especulativa em software C++. Essas
vulnerabilidades podem divulgar informações confidenciais entre limites de confiança e podem afetar o
software que é executado em processadores que dão suporte à execução especulativa de instruções e de uso
fora de ordem. Essa classe de vulnerabilidades foi descrita pela primeira vez em janeiro de 2018, e em segundo
plano e orientações adicionais podem ser encontradas no comunicado de segurança da Microsoft.
As diretrizes fornecidas por este artigo estão relacionadas às classes de vulnerabilidades representadas por:
1. CVE-2017-5753, também conhecido como Spectre Variant 1. Essa classe de vulnerabilidade de hardware
está relacionada a canais laterais que podem surgir devido à execução especulativa que ocorre como
resultado de uma previsão incorreta da ramificação condicional. O compilador do Microsoft C++ no
Visual Studio 2017 (a partir da versão 15.5.5) inclui suporte para o /Qspectre comutador que fornece
uma mitigação em tempo de compilação para um conjunto limitado de padrões de codificação
potencialmente vulneráveis relacionados ao CVE-2017-5753. A /Qspectre opção também está
disponível no Visual Studio 2015 atualização 3 a KB 4338871. A documentação do /Qspectre sinalizador
fornece mais informações sobre seus efeitos e uso.
2. CVE-2018-3639, também conhecido como bypass do armazenamento especulativo (SSB). Essa classe de
vulnerabilidade de hardware está relacionada a canais laterais que podem surgir devido à execução
especulativa de uma carga antecipada de um armazenamento dependente como resultado de uma
previsão incorreta de acesso à memória.
Uma introdução acessível às vulnerabilidades do canal lateral de execução especulativa pode ser encontrada na
apresentação intitulada o caso de Spectre e Meltdown por uma das equipes de pesquisa que descobriram esses
problemas.
O que são vulnerabilidades de hardware de canal do lado de

execução especulativa?
As CPUs modernas fornecem níveis mais altos de desempenho, fazendo uso de uma execução especulativa e
fora de ordem de instruções. Por exemplo, isso geralmente é feito prevendo o destino de branches (condicional
e indireto) que permite que a CPU comece a executar instruções de forma especulativa no destino da
ramificação prevista, evitando assim uma parada até que o destino da ramificação real seja resolvido. Caso a
CPU descubra posteriormente que ocorreu um erro de previsão, todo o estado da máquina que foi computada
especulativamente é Descartado. Isso garante que não haja efeitos visíveis de forma arquitetônica da
especulação incorreta.
Embora a execução especulativa não afete o estado de arquitetura visível, ela pode deixar rastreamentos
residuais no estado de não-arquitetura, como os vários caches usados pela CPU. São esses rastreamentos
residuais de execução especulativa que podem dar às vulnerabilidades do canal de aumento. Para entender
melhor isso, considere o fragmento de código a seguir, que fornece um exemplo de CVE-2017-5753 (bypass de
verificação de limites):
// A pointer to a shared memory region of size 1MB (256 * 4096)
unsigned char *shared_buffer;
unsigned char ReadByte(unsigned char *buffer, unsigned int buffer_size, unsigned int untrusted_index) {
if (untrusted_index < buffer_size) {
unsigned char value = buffer[untrusted_index];
return shared_buffer[value * 4096];
}
}
Neste exemplo, ReadByte é fornecido um buffer, um tamanho de buffer e um índice nesse buffer. O parâmetro
de índice, conforme especificado por untrusted_index , é fornecido por um contexto menos privilegiado, como
um processo não administrativo. Se untrusted_index for menor que buffer_size , o caractere nesse índice será
lido buffer e usado para indexar em uma região compartilhada de memória referenciada por shared_buffer .
Do ponto de vista da arquitetura, essa sequência de código é perfeitamente segura, pois é garantido que
untrusted_index será sempre menor que buffer_size . No entanto, na presença de execução especulativa, é
possível que a CPU faça uma previsão incorreta da ramificação condicional e execute o corpo da instrução If
mesmo quando untrusted_index for maior ou igual a buffer_size . Como consequência disso, a CPU pode,
especulativamente, ler um byte de além dos limites de buffer (que poderia ser um segredo) e, em seguida,
usar esse valor de byte para computar o endereço de uma carga subsequente por meio do shared_buffer .
Embora a CPU eventualmente detecte esse erro de previsão, os efeitos colaterais podem ser deixados no cache
da CPU que revela informações sobre o valor de byte que foi lido dos limites de buffer . Esses efeitos colaterais
podem ser detectados por um contexto menos privilegiado em execução no sistema, investigando a rapidez
com que cada linha de cache shared_buffer é acessada. As etapas que podem ser executadas para fazer isso
são:
1. Invocar ReadByte várias vezes com untrusted_index menos de buffer_size . O contexto de ataque
pode fazer com que o contexto da vítima invoque ReadByte (por exemplo, via RPC), de modo que o
Predictor da ramificação seja treinado para não ser levado como untrusted_index é menor que
buffer_size .
2. Libere todas as linhas de shared_buffer cache no . O contexto de ataque deve liberar todas as linhas
de cache na região compartilhada da memória referenciada por shared_buffer . Como a região de
memória é compartilhada, isso é simples e pode ser feito usando intrínsecos, como _mm_clflush .
3. Invocar ReadByte com untrusted_index ser maior buffer_size que . O contexto de ataque faz com
que o contexto da vítima seja invocado ReadByte , de modo que ele prevê incorretamente que a
ramificação não será executada. Isso faz com que o processador execute especulativamente o corpo do
bloco If com untrusted_index um maior que buffer_size , o que leva a uma leitura fora dos limites de
buffer . Consequentemente, shared_buffer é indexado usando um valor potencialmente secreto que foi
lido fora dos limites, fazendo com que a respectiva linha de cache seja carregada pela CPU.
4. Leia cada linha de cache shared_buffer para ver qual é acessado mais rapidamente . O contexto
de ataque pode ler cada linha de cache no shared_buffer e detectar a linha de cache que carrega
significativamente mais rápido do que as outras. Essa é a linha de cache que provavelmente foi
apresentada pela etapa 3. Como há uma relação de 1:1 entre o valor de byte e a linha de cache neste
exemplo, isso permite que o invasor inferir o valor real do byte que foi lido fora dos limites.
As etapas acima fornecem um exemplo de como usar uma técnica conhecida como liberação + recarga em
conjunto com a exploração de uma instância de CVE-2017-5753.
Quais cenários de software podem ser afetados?

O desenvolvimento de software seguro usando um processo como o SDL ( ciclo de vida de desenvolvimento da
segurança ) normalmente exige que os desenvolvedores identifiquem os limites de confiança que existem em
seu aplicativo. Existe um limite de confiança em locais onde um aplicativo pode interagir com os dados
fornecidos por um contexto menos confiável, como outro processo no sistema ou um processo de modo de
usuário não administrativo no caso de um driver de dispositivo em modo kernel. A nova classe de
vulnerabilidades envolvendo canais do lado de execução especulativa é relevante para muitos dos limites de
confiança em modelos de segurança de software existentes que isolam o código e os dados em um dispositivo.
A tabela a seguir fornece um resumo dos modelos de segurança de software em que os desenvolvedores
podem precisar se preocupar com essas vulnerabilidades que ocorrem:
L IM IT E DE C O N F IA N Ç A DESC RIÇ Ã O
Limite de máquina virtual Os aplicativos que isolam cargas de trabalho em máquinas

virtuais separadas que recebem dados não confiáveis de
outra máquina virtual podem estar em risco.
Limite de kernel Um driver de dispositivo de modo kernel que recebe dados

não confiáveis de um processo de modo de usuário não
administrativo pode estar em risco.
Limite de processo Um aplicativo que recebe dados não confiáveis de outro

processo em execução no sistema local, como por meio de
uma RPC (chamada de procedimento remoto), memória
compartilhada ou outros mecanismos de IPC (comunicação
de Inter-Process) podem estar em risco.
Limite de enclave Um aplicativo que é executado em um enclave seguro (como

o Intel SGX) que recebe dados não confiáveis de fora do
enclave pode estar em risco.
Limite de idioma Um aplicativo que interpreta ou JIT (just-in-time) compila e

executa código não confiável escrito em uma linguagem de
nível superior pode estar em risco.
Os aplicativos que têm a superfície de ataque exposta a qualquer um dos limites de confiança acima devem
revisar o código na superfície de ataque para identificar e atenuar possíveis instâncias de vulnerabilidades de
canal lateral de execução especulativa. Deve-se observar que os limites de confiança expostos a superfícies de
ataque remoto, como protocolos de rede remota, não foram demonstrados como risco de vulnerabilidades de
canal lateral de execução especulativa.
Padrões de codificação potencialmente vulneráveis

As vulnerabilidades do canal lateral de execução especulativa podem surgir como consequência de vários
padrões de codificação. Esta seção descreve os padrões de codificação potencialmente vulneráveis e fornece
exemplos para cada um, mas deve ser reconhecido que as variações nesses temas podem existir. Dessa forma,
os desenvolvedores são aconselhados a usar esses padrões como exemplos e não como uma lista completa de
todos os padrões de codificação potencialmente vulneráveis. As mesmas classes de vulnerabilidades de
segurança de memória que podem existir no software hoje também podem existir juntamente com caminhos
especulativos e fora de ordem de execução, incluindo, mas não se limitando a estouros de buffer, acessos de
matriz fora de limites, uso de memória não inicializado, confusão de tipo e assim por diante. Os mesmos
primitivos que os invasores podem usar para explorar vulnerabilidades de segurança de memória ao longo dos
caminhos de arquitetura também podem se aplicar a caminhos especulares.
Em geral, os canais laterais de execução especulativa relacionados à previsão de incorretação de ramificação
condicional podem surgir quando uma expressão condicional opera nos dados que podem ser controlados ou
influenciados por um contexto menos confiável. Por exemplo, isso pode incluir expressões condicionais usadas
if nas for instruções,, while , switch ou ternário. Para cada uma dessas instruções, o compilador pode
gerar uma ramificação condicional que a CPU pode então prever o destino da ramificação em tempo de
execução.
Para cada exemplo, um comentário com a frase "barreira de ESPECULAção" é inserido onde um desenvolvedor
pode introduzir uma barreira como uma mitigação. Isso é discutido mais detalhadamente na seção sobre
mitigações.
Carga fora dos limites especulativos

Essa categoria de padrões de codificação envolve uma previsão incorreta da ramificação condicional que leva a
um acesso restrito à memória.
Carga fora dos limites da matriz alimentando uma carga
Esse padrão de codificação é o padrão de codificação vulnerável originalmente descrito para CVE-2017-5753
(delimite de verificação de limites). A seção de plano de fundo deste artigo explica esse padrão em detalhes.

// SPECULATION BARRIER
}
}
Da mesma forma, uma carga fora dos limites da matriz pode ocorrer em conjunto com um loop que exceda sua
condição de encerramento devido a uma previsão incorreta. Neste exemplo, a ramificação condicional associada
à x < buffer_size expressão pode prever incorretamente e executar de forma especulativa o corpo do for
loop quando x é maior ou igual a buffer_size , resultando, assim, em uma carga de fora dos limites
especulativo.

unsigned char ReadBytes(unsigned char *buffer, unsigned int buffer_size) {

for (unsigned int x = 0; x < buffer_size; x++) {
unsigned char value = buffer[x];
}
}
Carga fora de limites de matriz alimentando uma ramificação indireta

Esse padrão de codificação envolve o caso em que uma previsão de incorretação de ramificação condicional
pode levar a um acesso fora de limites a uma matriz de ponteiros de função que, em seguida, leva a uma
ramificação indireta para o endereço de destino que foi lido fora dos limites. O trecho a seguir fornece um
exemplo que demonstra isso.
Neste exemplo, um identificador de mensagem não confiável é fornecido para DispatchMessage por meio do
untrusted_message_id parâmetro. Se untrusted_message_id for menor que MAX_MESSAGE_ID , ele será usado para
indexar em uma matriz de ponteiros de função e Branch para o destino de ramificação correspondente. Esse
código é seguro em termos de segurança, mas se a CPU previr incorretamente a ramificação condicional, isso
poderá resultar na DispatchTable indexação por untrusted_message_id quando seu valor for maior ou igual a
MAX_MESSAGE_ID , o que leva a um acesso fora dos limites. Isso pode resultar na execução especulativa de um
endereço de destino de ramificação que é derivado além dos limites da matriz, o que pode levar à divulgação de
informações dependendo do código executado de forma especulativa.
#define MAX_MESSAGE_ID 16
typedef void (*MESSAGE_ROUTINE)(unsigned char *buffer, unsigned int buffer_size);
const MESSAGE_ROUTINE DispatchTable[MAX_MESSAGE_ID];
void DispatchMessage(unsigned int untrusted_message_id, unsigned char *buffer, unsigned int buffer_size) {
if (untrusted_message_id < MAX_MESSAGE_ID) {
DispatchTable[untrusted_message_id](buffer, buffer_size);
}
}
Assim como no caso de uma carga fora dos limites da matriz alimentar outra carga, essa condição também
pode surgir em conjunto com um loop que exceda sua condição de encerramento devido a uma previsão
incorreta.
Armazenamento fora de limites de matriz alimentando uma ramificação indireta
Enquanto o exemplo anterior mostrou como uma carga fora de limites restritos pode influenciar um destino de
ramificação indireta, também é possível para um armazenamento fora de limites para modificar um destino de
ramificação indireta, como um ponteiro de função ou um endereço de retorno. Isso pode potencialmente levar à
execução especulativa de um endereço especificado pelo invasor.
Neste exemplo, um índice não confiável é passado pelo untrusted_index parâmetro. Se untrusted_index for
menor que a contagem de elementos da pointers matriz (256 elementos), o valor de ponteiro fornecido em
ptr será gravado na pointers matriz. Esse código é seguro em termos de segurança, mas se a CPU previr
incorretamente a ramificação condicional, isso poderá resultar na ptr escrita especulativa dos limites da matriz
alocada na pilha pointers . Isso pode levar à corrupção especulativa do endereço de retorno para WriteSlot .
Se um invasor puder controlar o valor de ptr , ele poderá causar a execução especulativa de um endereço
arbitrário quando WriteSlot retornar ao longo do caminho especulativo.
unsigned char WriteSlot(unsigned int untrusted_index, void *ptr) {

void *pointers[256];
if (untrusted_index < 256) {
pointers[untrusted_index] = ptr;
}
}
Da mesma forma, se uma variável local de ponteiro de função tiver func sido alocada na pilha, poderá ser
possível modificar especulativamente o endereço que func se refere quando a previsão de ramificação
condicional ocorrer. Isso pode resultar na execução especulativa de um endereço arbitrário quando o ponteiro
de função é chamado por meio de.
unsigned char WriteSlot(unsigned int untrusted_index, void *ptr) {
void *pointers[256];
void (*func)() = &callback;
if (untrusted_index < 256) {
pointers[untrusted_index] = ptr;
}
func();
}
Deve-se observar que esses dois exemplos envolvem a modificação especulativa de ponteiros de ramificação
indiretos alocados para pilha. É possível que a modificação especulativa também possa ocorrer para variáveis
globais, memória alocada para heap e até mesmo memória somente leitura em algumas CPUs. Para a memória
alocada para pilha, o compilador do Microsoft C++ já usa etapas para tornar mais difícil modificar de forma
especulativa os destinos de ramificação indiretos alocados na pilha, como reordenar variáveis locais, de forma
que os buffers sejam colocados adjacentes a um cookie de segurança como parte do /GS recurso de segurança
do compilador.
Confusão de tipo especulativo

Essa categoria lida com padrões de codificação que podem dar a elevação a uma confusão de tipo especulativo.
Isso ocorre quando a memória é acessada usando um tipo incorreto ao longo de um caminho não-arquitetônico
durante a execução especulativa. O desvio de ramificação condicional e o bypass de armazenamento
especulativo podem potencialmente levar a uma confusão de tipo especulativo.
Para bypass de armazenamento especulativo, isso pode ocorrer em cenários em que um compilador reutiliza
um local de pilha para variáveis de vários tipos. Isso ocorre porque o armazenamento arquitetônico de uma
variável do tipo A pode ser ignorado, permitindo assim que a carga do tipo seja A executada
especulativamente antes de a variável ser atribuída. Se a variável armazenada anteriormente for de um tipo
diferente, isso poderá criar as condições para uma confusão de tipo especulativo.
Para um erro de previsão de ramificação condicional, o trecho de código a seguir será usado para descrever
diferentes condições que a confusão de tipo especulativa pode dar ao aumento.
enum TypeName {
Type1,
Type2
};
class CBaseType {
public:
CBaseType(TypeName type) : type(type) {}
TypeName type;
};
class CType1 : public CBaseType {

public:
CType1() : CBaseType(Type1) {}
char field1[256];
unsigned char field2;
};
class CType2 : public CBaseType {

public:
CType2() : CBaseType(Type2) {}
void (*dispatch_routine)();
unsigned char field2;
};

unsigned char ProcessType(CBaseType *obj)

{
if (obj->type == Type1) {
CType1 *obj1 = static_cast<CType1 *>(obj);
unsigned char value = obj1->field2;

}
else if (obj->type == Type2) {
CType2 *obj2 = static_cast<CType2 *>(obj);
obj2->dispatch_routine();
return obj2->field2;
}
}
Confusão de tipo especulativo que leva a uma carga fora de limites

Esse padrão de codificação envolve o caso em que uma confusão de tipo especulativo pode resultar em um
acesso de campo de tipo confuso ou incorreto, onde o valor carregado alimenta um endereço de carregamento
subsequente. Isso é semelhante ao padrão de codificação da matriz fora de limites, mas é manifestado por meio
de uma sequência de codificação alternativa, conforme mostrado acima. Neste exemplo, um contexto de ataque
pode fazer com que o contexto da vítima seja executado ProcessType várias vezes com um objeto do tipo
CType1 (o type campo é igual a Type1 ). Isso terá o efeito de treinar a ramificação condicional para que a
primeira if instrução não seja realizada. O contexto de ataque pode fazer com que o contexto da vítima seja
executado ProcessType com um objeto do tipo CType2 . Isso pode resultar em uma confusão de tipo
especulativo se a ramificação condicional da primeira if instrução previr incorretamente e executar o corpo da
if instrução, convertendo, assim, um objeto do tipo CType2 para CType1 . Como CType2 é menor que
CType1 , o acesso de memória para CType1::field2 resultará em uma carga de dados restrito fora dos limites
que pode ser secreta. Esse valor é usado em uma carga a partir da shared_buffer qual o pode criar efeitos
colaterais observáveis, como com o exemplo de limite fora de limites de matriz descrito anteriormente.
Confusão de tipo especulativo que leva a uma ramificação indireta
Esse padrão de codificação envolve o caso em que uma confusão de tipo especulativo pode resultar em uma
ramificação indireta não segura durante a execução especulativa. Neste exemplo, um contexto de ataque pode
fazer com que o contexto da vítima seja executado ProcessType várias vezes com um objeto do tipo CType2 (o
type campo é igual a Type2 ). Isso terá o efeito de treinar a ramificação condicional para a primeira if
instrução a ser executada e a else if instrução não ser executada. O contexto de ataque pode fazer com que o
contexto da vítima seja executado ProcessType com um objeto do tipo CType1 . Isso pode resultar em uma
confusão de tipo especulativo se a ramificação condicional da primeira if instrução for executada e a else if
instrução prever não for realizada, executando o corpo do else if e convertendo um objeto do tipo CType1
para CType2 . Como o CType2::dispatch_routine campo se sobrepõe à char matriz CType1::field1 , isso pode
resultar em uma ramificação indireta especulativa para um destino de ramificação não intencional. Se o
contexto de ataque puder controlar os valores de bytes na CType1::field1 matriz, eles poderão controlar o
endereço de destino da ramificação.
Uso não inicializado especulativo

Essa categoria de padrões de codificação envolve cenários em que a execução especulativa pode acessar
memória não inicializada e usá-la para alimentar uma carga subsequente ou uma ramificação indireta. Para que
esses padrões de codificação sejam exploráveis, um invasor precisa ser capaz de controlar ou influenciar de
acordo com o conteúdo da memória usado sem ser inicializado pelo contexto em que está sendo usado.
Uso especulativo não inicializado levando a uma carga fora dos limites
Um uso especulativo não inicializado pode potencialmente levar a uma carga fora do limite usando um valor
controlado pelo invasor. No exemplo a seguir, o valor de index é atribuído trusted_index em todos os
caminhos arquitetônicos e trusted_index é considerado menor ou igual a buffer_size . No entanto,
dependendo do código produzido pelo compilador, é possível que um bypass de armazenamento especulativo
possa ocorrer, permitindo que o carregamento buffer[index] e as expressões dependentes sejam executados à
frente da atribuição index . Se isso ocorrer, um valor não inicializado para index será usado como o
deslocamento no buffer qual o pode permitir que um invasor Leia informações confidenciais fora de limites e
transmita isso por meio de um canal lateral por meio da carga dependente de shared_buffer .

void InitializeIndex(unsigned int trusted_index, unsigned int *index) {

*index = trusted_index;
}
unsigned char ReadByte(unsigned char *buffer, unsigned int buffer_size, unsigned int trusted_index) {
unsigned int index;
InitializeIndex(trusted_index, &index); // not inlined
unsigned char value = buffer[index];
}
Uso especulativo não inicializado levando a uma ramificação indireta

Um uso especulativo não inicializado pode potencialmente levar a uma ramificação indireta em que o destino
da ramificação é controlado por um invasor. No exemplo a seguir, routine é atribuído a um
DefaultMessageRoutine1 ou DefaultMessageRoutine dependendo do valor de mode . No caminho arquitetônico,
isso resultará routine sempre sendo inicializado à frente da ramificação indireta. No entanto, dependendo do
código produzido pelo compilador, pode ocorrer um bypass de armazenamento especulativo que permite que a
ramificação indireta routine seja executada especulativamente à frente da atribuição routine . Se isso ocorrer,
um invasor poderá ser capaz de executar especulativamente a partir de um endereço arbitrário, supondo que o
invasor possa influenciar ou controlar o valor não inicializado de routine .
#define MAX_MESSAGE_ID 16
typedef void (*MESSAGE_ROUTINE)(unsigned char *buffer, unsigned int buffer_size);
const MESSAGE_ROUTINE DispatchTable[MAX_MESSAGE_ID];

extern unsigned int mode;
void InitializeRoutine(MESSAGE_ROUTINE *routine) {

if (mode == 1) {
*routine = &DefaultMessageRoutine1;
}
else {
*routine = &DefaultMessageRoutine;
}
}
void DispatchMessage(unsigned int untrusted_message_id, unsigned char *buffer, unsigned int buffer_size) {
MESSAGE_ROUTINE routine;
InitializeRoutine(&routine); // not inlined
routine(buffer, buffer_size);
}
Opções de mitigação
As vulnerabilidades do canal lateral de execução especulativa podem ser atenuadas fazendo alterações no
código-fonte. Essas alterações podem envolver a mitigação de instâncias específicas de uma vulnerabilidade,
como adicionar uma barreira de especulação ou fazer alterações no design de um aplicativo para tornar as
informações confidenciais inacessíveis à execução especulativa.
Barreira de especulação via instrumentação manual
Uma barreira de especulação pode ser inserida manualmente por um desenvolvedor para impedir que a
execução especulativa continue em um caminho de não-arquitetura. Por exemplo, um desenvolvedor pode
inserir uma barreira de especulação antes de um padrão de codificação perigoso no corpo de um bloco
condicional, seja no início do bloco (após a ramificação condicional) ou antes da primeira carga que for
preocupante. Isso impedirá que uma previsão de ramificação condicional execute o código perigoso em um
caminho que não seja de arquitetura ao serializar a execução. A sequência de barreira de especulação difere pela
arquitetura de hardware, conforme descrito pela tabela a seguir:
B A RREIRA DE ESP EC UL A Ç Ã O B A RREIRA DE ESP EC UL A Ç Ã O

A RQ UIT ET URA IN T RÍN SEC A PA RA C VE- 2017- 5753 IN T RÍN SEC A PA RA C VE- 2018- 3639
x86/x64 _mm_lfence () _mm_lfence ()
ARM não disponível atualmente __dsb (0)
ARM64 não disponível atualmente __dsb (0)
Por exemplo, o seguinte padrão de código pode ser mitigado usando o _mm_lfence intrínseco, conforme
mostrado abaixo.
_mm_lfence();
}
}
Barreira de especulação por meio de instrumentação de tempo de compilador

O compilador do Microsoft C++ no Visual Studio 2017 (a partir da versão 15.5.5) inclui suporte para o
/Qspectre comutador que insere automaticamente uma barreira de especulação para um conjunto limitado de
padrões de codificação potencialmente vulneráveis relacionados ao CVE-2017-5753. A documentação do
/Qspectre sinalizador fornece mais informações sobre seus efeitos e uso. É importante observar que esse
sinalizador não cobre todos os padrões de codificação potencialmente vulneráveis e, como tal, os
desenvolvedores não devem confiar nele como uma mitigação abrangente para essa classe de vulnerabilidades.
Mascarando índices de matriz
Nos casos em que pode ocorrer uma carga de limite restrito fora de limites, o índice de matriz pode ser
rigidamente limitado no caminho de arquitetura e fora da arquitetura, adicionando lógica para associar
explicitamente o índice de matriz. Por exemplo, se uma matriz puder ser alocada para um tamanho que esteja
alinhado a uma potência de dois, uma máscara simples poderá ser introduzida. Isso é ilustrado no exemplo
abaixo, onde supõe-se que buffer_size está alinhado a uma potência de dois. Isso garante que
untrusted_index é sempre menor que buffer_size , mesmo se ocorrer uma previsão incorreta da ramificação
condicional e se for untrusted_index passado com um valor maior ou igual a buffer_size .
Deve-se observar que a máscara de índice executada aqui pode estar sujeita ao bypass de armazenamento
especulativo, dependendo do código gerado pelo compilador.

untrusted_index &= (buffer_size - 1);
}
}
Removendo informações confidenciais da memória

Outra técnica que pode ser usada para mitigar vulnerabilidades de canal lateral de execução especulativa é
remover informações confidenciais da memória. Os desenvolvedores de software podem procurar
oportunidades para refatorar seus aplicativos de modo que as informações confidenciais não sejam acessíveis
durante a execução especulativa. Isso pode ser feito Refatorando o design de um aplicativo para isolar
informações confidenciais em processos separados. Por exemplo, um aplicativo de navegador da Web pode
tentar isolar os dados associados a cada origem da Web em processos separados, evitando assim que um
processo seja capaz de acessar dados entre origens por meio de execução especulativa.
Veja também
Diretrizes para atenuar as vulnerabilidades de canal lateral de execução especulativa
Atenuando vulnerabilidades de hardware de canal lateral de execução especulativa
Referência de bibliotecas padrão e da linguagem
C/C++
Esta seção da documentação contém o conteúdo de referência para a implementação da Microsoft das
linguagens ISO Standard C e C++. A referência de linguagem inclui documentação para o pré-processador,
intrínsecos do compilador e linguagens de assembly com suporte.
Você também encontrará documentação para a biblioteca de tempo de execução C, a biblioteca padrão C++ e
várias outras bibliotecas disponíveis com o compilador C/C++ da Microsoft (MSVC) aqui.
Referência de linguagem
Linguagem C
Conteúdo de referência para a implementação da Microsoft da linguagem C.
Linguagem C++
Conteúdo de referência para a implementação da Microsoft da linguagem C++.
Pré-processador de C/C++
Conteúdo de referência para o pré-processador usado por C e C++.
Descreve as funções intrínsecas que estão disponíveis no Microsoft C e C++ para arquiteturas x86, ARM,
ARM64 e x64.
Assembler embutido
Explica como usar o assembler embutido do Visual C/C++ com processadores x86.
Referência do ARM Assembler
Fornece material de referência para o Microsoft ARM assembler (ARMASM) e ferramentas relacionadas.
Referência do Microsoft Macro Assembler
Fornece material de referência para o Microsoft Macro Assembler (MASM).
Referência de bibliotecas
Bibliotecas padrão
Biblioteca de tempo de execução C
A referência para a implementação da Microsoft da biblioteca de tempo de execução C (CRT), às vezes chamada
de CRT universal.
Biblioteca padrão do C++
A referência para a implementação da Microsoft da biblioteca padrão C++.
Bibliotecas para aplicativos do Windows
MFC/ATL
Documentação para as bibliotecas de classes MFC (MFC) e Active Template Library (ATL).
Bibliotecas adicionais
C++ AMP (C++ Accelerated Massive Parallelism)
Classes que permitem o uso de processadores gráficos modernos para programação de uso geral.
Tempo de Execução de Simultaneidade
Classes que simplificam a gravação de programas que usam paralelismo de dados ou paralelismo de tarefas.
OpenMP
Referência para a implementação da API de OpenMP da Microsoft.
Biblioteca SafeInt
Uma biblioteca portátil que pode ser usada com MSVC, GCC ou clang para ajudar a evitar estouros inteiros.
Bibliotecas de acesso a dados Bibliotecas para dar suporte ao acesso a dados usando ATL ou MFC e serviços
herdados, como OLE DB e ODBC.
Windows Runtime (WinRT) com C++
O C++/WinRT é uma linguagem C++17 moderna e inteiramente padrão para APIs do Windows Runtime
(WinRT), implementada como uma biblioteca com base em arquivo e cabeçalho.
Windows Runtime WRL (biblioteca de modelos C++)
Uma biblioteca de modelos herdada para a Windows Runtime, substituída por C++/WinRT.
Idiomas
Linguagem C
Linguagem C++
Pré-processador de C/C++
Intrínsecos do compilador e linguagem do assembly
A referência da linguagem C descreve a linguagem de programação C como implementada em Microsoft C. A

organização do manual baseia-se no padrão ANSI C (às vezes conhecido como C89) com material adicional
sobre as extensões da Microsoft para o padrão ANSI C.
Organização da referência da linguagem C
Para material de referência adicional sobre C++ e o pré-processador, consulte:
Referência do pré-processador
As opções do compilador e do vinculador estão documentadas na Referência de compilação C/C++.
Veja também
Essa referência explica a linguagem de programação C++, conforme implementada no compilador do Microsoft
C++. A organização se baseia no manual de referência do C++ anotado por Margaret Ellis e Bjarne Stroustrup e
no padrão ISO/ISO C++ (c/IEC FDIS 14882). As implementações específicas da Microsoft de recursos da
linguagem C++ são incluídas.
Para obter uma visão geral das práticas de programação C++ modernas, consulte Bem-vindo de volta ao C++.
Consulte as tabelas a seguir para localizar rapidamente uma palavra-chave ou um operador:
Palavras-chave do C++
Operadores do C++
Nesta seção
Convenções léxicas
Elementos lexicais fundamentais de um programa C++: tokens, comentários, operadores, palavras-chave,
pontuadores, literais. Além disso, conversão de arquivo, precedência/associatividade de operadores.
Conceitos básicos
Escopo, vínculo, inicialização e encerramento do programa, classes de armazenamento e tipos.
Tipos internos Os tipos fundamentais que são criados no compilador C++ e seus intervalos de valor.
Conversões padrão
Conversões de tipo entre tipos internos. Além disso, conversões aritméticas e conversões entre ponteiro,
referência e tipos de ponteiro a membro.
Declarações e definições Declarando e Definindo variáveis, tipos e funções.
Operadores, precedência e capacidade de associação
Os operadores em C++.
Expressões
Tipos de expressões, semântica de expressões, tópicos de referência sobre operadores, conversão e operadores
de conversão, informações de tipo de tempo de execução.
Expressões lambda
Uma técnica de programação que define implicitamente uma classe de objeto de função e constrói um objeto
de função desse tipo de classe.
Instruções
Expressão, nulo, composto, seleção, iteração, salto e instruções de declaração.
Classes e structs
Introdução a classes, estruturas e uniões. Além disso, funções de membro, funções de membro especiais,
membros de dados, campos de bits, this ponteiros, classes aninhadas.
Uniões
Tipos definidos pelo usuário em que todos os membros compartilham o mesmo local de memória.
Classes derivadas
Herança única e múltipla, virtual funções, várias classes base, classes abstratas , regras de escopo. Além
disso, __super as __interface palavras-chave e.
Controle de acesso de membros
Controlando o acesso a membros de classe: public , private ,e protected palavras-chave. Funções e classes
amigas.
Sobrecarga
Operadores sobrecarregados, regras para sobrecarga de operador.
Tratamento de Exceção
Tratamento de exceções C++, SEH (manipulação de exceção estruturada), palavras-chave usadas na escrita de
instruções de tratamento de exceções.
Asserção e User-Supplied mensagens
#error a diretiva, a static_assert palavra-chave, a assert macro.
Modelos
Especificações de modelo, modelos de função, modelos de classe, typename palavra-chave, modelos vs. macros,
modelos e ponteiros inteligentes.
Manipulação de eventos
Eventos de declaração e manipuladores de eventos.
Modificadores específicos da Microsoft
Modificadores específicos do Microsoft C++. Endereçamento de memória, convenções de chamada, naked
funções, atributos de classe de armazenamento estendido ( __declspec ), __w64 .
Assembler embutido
Usando linguagem de assembly e C++ em __asm blocos.
Suporte a COM do compilador
Uma referência a classes específicas da Microsoft e funções globais usadas para oferecer suporte a tipos COM.
Extensões da Microsoft
Extensões da Microsoft para C++.
Comportamento não padrão
Informações sobre o comportamento não padrão do compilador do Microsoft C++.
Bem-vindo outra vez ao C++
Uma visão geral das práticas de programação C++ modernas para escrever programas seguros, corretos e
eficientes.
Seções relacionadas
Extensões de componentes para plataformas de runtime
Material de referência sobre como usar o compilador do Microsoft C++ para o .NET de destino.
Referência de build C/C++
Opções do compilador, opções de vinculador e outras ferramentas de compilação.
Referência de pré-processador do C/C++
Material de referência sobre pragmas, diretivas de pré-processador, macros predefinidas e o pré-processador.
Bibliotecas do Visual C++
Uma lista de links para as páginas de início de referência para as várias bibliotecas do Microsoft C++.
Veja também
A referência do pré-processador do C/c++ explica o pré-processador conforme ele é implementado no

Microsoft C/c++. O pré-processador executa operações preliminares em arquivos do C e C++ antes de serem
passados para o compilador. É possível usar o pré-processador para compilar o código condicionalmente, inserir
arquivos, especificar mensagens de erro de tempo de compilação e aplicar regras de máquina específicas para
seções de código.
No Visual Studio 2019, a opção de compilador /Zc: pré-processador fornece um pré-processamento totalmente
compatível e um pré-processador C17. Esse é o padrão quando você usa o sinalizador do compilador /std:c11
ou /std:c17 .
Nesta seção
Pré-processador
Fornece uma visão geral dos pré-processadores de conformidade tradicionais e novos.
Diretivas de pré-processador
Descreve as políticas, normalmente usadas para tornar os programas de origem fáceis de alterar e de compilar
em ambientes de execução diferentes.
Operadores de pré-processador
Discute os quatro operadores específicos de pré-processadores usados no contexto da política #define .
Macros predefinidas
Discute macros predefinidas conforme especificado pelos padrões C e C++ e pelo Microsoft C++.
Pragmas
Discute pragmas, que proporcionam uma maneira para que cada compilador ofereça recursos específicos de
máquinas e sistemas operacionais enquanto mantém a compatibilidade geral com as linguagens C e C++.
Fornece o material de referência para a implementação da Microsoft da linguagem C++.
Fornece o material de referência para a implementação da Microsoft da linguagem C.
Referência de Build do C/C++
Fornece links para tópicos que discutem opções de compilador e de vinculador.
Projetos do Visual Studio – C++
Descreve a interface do usuário no Visual Studio que permite especificar os diretórios que o sistema do projeto
procurará para localizar arquivos para o seu projeto do C++.
Intrínsecos do compilador e linguagem assembly
Esta seção da documentação contém informações sobre os intrínsecos do compilador e a linguagem do

assembly.
Intrínsecos do compilador Descreve as funções intrínsecas que estão disponíveis no

Microsoft C e C++ para arquiteturas x86, ARMe x64.
Assembler embutido Explica como usar o assembler embutido do Visual C/C++

com processadores x86.
Referência do ARM Assembler Fornece material de referência do assembler Microsoft ARM

(armasm) e ferramentas relacionadas.
Referência do Microsoft Macro Assembler Fornece material de referência do assembler Microsoft

Macro (masm).
C++ no Visual Studio O artigo de nível superior para a documentação do Visual

C++.
A maioria das funções está contidas em bibliotecas, mas algumas funções são internas (ou seja, intrínsecas) para
o compilador. Elas são chamadas de funções intrínsecas ou intrínsecos.
Comentários
Se uma função for um intrínseco, o código para essa função será inserido geralmente embutido, evitando a
sobrecarga de uma chamada de função e permitindo que instruções de máquina altamente eficientes sejam
emitidas para a função. Um intrínseco geralmente é mais rápido do que o assembly embutido equivalente,
porque o otimizador tem conhecimento interno de quantos intrínsecos se comportam, algumas otimizações
que podem estar disponíveis não estarão disponíveis quando o assembly embutido for usado. Além disso, o
otimizador pode expandir o intrínseco diferentemente, alinhar buffers de forma diferente ou fazer outros ajustes
dependendo do contexto e dos argumentos da chamada.
O uso de intrínsecos afeta a portabilidade do código, pois os intrínsecos que estão disponíveis no Visual C++
podem não estar disponíveis se o código for compilado com outros compiladores, e alguns intrínsecos que
podem estar disponíveis para algumas arquiteturas de destino não estarão disponíveis para todas as
arquiteturas. No entanto, intrínsecos são geralmente mais portáteis do que o assembly embutido. Os intrínsecos
são necessários em arquiteturas de 64 bits em que não há suporte para assembly embutido.
Alguns intrínsecos, como __assume e __ReadWriteBarrier , fornecem informações para o compilador, o que
afeta o comportamento do otimizador.
Alguns intrínsecos estão disponíveis apenas como intrínsecos e outros estão disponíveis nas implementações
de intrínsecos e função. Você pode instruir o compilador para usar a implementação intrínseca em uma das
duas maneiras, dependendo se quer habilitar apenas as funções específicas ou todos os intrínsecos. A primeira
maneira é usar a #pragma intrinsic( lista intrínseca-function-name ) . O pragma pode ser usado para
especificar um único intrínseco ou vários intrínsecos separados por vírgulas. A segunda é usar a opção de
compilador /Oi (gerar funções intrínsecas) , o que torna todos os intrínsecos em uma determinada plataforma
disponíveis. Em /Oi , use #pragma function( intrínseco-function-name-list ) para forçar uma chamada de
função a ser usada em vez de uma intrínseca. Se a documentação de uma determinada nota intrínseca que a
rotina só está disponível como intrínseca, a implementação intrínseca é usada independentemente de /Oi ou
#pragma intrinsic ser especificado. Em todos os casos, /Oi ou #pragma intrinsic permite, mas não força, o
otimizador a usar o intrínseco. O otimizador ainda pode chamar a função.
Algumas funções de biblioteca de C/C++ padrão estão disponíveis em implementações intrínsecas em algumas
arquiteturas. Ao chamar uma função CRT, a implementação intrínseca será usada se /Oi for especificado na
linha de comando.
Um arquivo de cabeçalho, <intrin.h> , está disponível que declara protótipos para as funções intrínsecas
comuns. Os intrínsecos específicos do fabricante estão disponíveis nos <immintrin.h> <ammintrin.h> arquivos
de cabeçalho e. Além disso, determinados cabeçalhos Windows declaram funções que mapeiam para um
compilador intrínseco.
As seções a seguir listam todos os intrínsecos que estão disponíveis em várias arquiteturas. Para obter mais
informações sobre como os intrínsecos funcionam no seu processador de destino específico, consulte a
documentação de referência do fabricante.
Intrínsecos ARM
Intrínsecos do ARM64
Lista de intrínsecos x86
Lista de intrínsecos x64 (amd64)
Intrínsecos disponíveis em todas as arquiteturas
Listagem alfabética de funções intrínsecas
Veja também
Referência do ARM Assembler
Palavras-chave
Referência da biblioteca de tempo de execução C
Referência do assembler ARM
Os artigos nesta seção da documentação fornecem material de referência para o Microsoft ARM assembler
(armasm) e ferramentas relacionadas.
Referência de Command-Line do assembler ARM Descreve as opções de linha de comando do armasm.
Mensagens de diagnóstico do ARM Assembler Descreve as mensagens de aviso e de erro do armasm

normalmente encontradas.
Diretivas do ARM Assembler Descreve as diretivas ARM que são diferentes no armasm.
Manual de referência da arquitetura ARM no site do Escolha o manual relevante para sua arquitetura ARM. Cada
desenvolvedor ARM. contém seções de referência sobre ARM, Thumb, NEON e
VFP, além de informações adicionais sobre a linguagem de
montagem do ARM.
Guia do usuário do ARM Compiler armasm no site do Escolha uma versão recente para encontrar informações
desenvolvedor ARM. atualizadas sobre a linguagem do assembly ARM.
Obser vação: O assembler "armasm" que é mencionado no
site do desenvolvedor do ARM não é o Microsoft armasm
Assembler que está incluído no Visual Studio e está
documentado nesta seção.
Veja também
Intrínsecos do ARM
Intrínsecos do ARM64
Assembler embutido
Específico da Microsoft
A linguagem de assembly serve para muitas finalidades, como melhorar a velocidade do programa, reduzir as
necessidades de memória e controlar o hardware. É possível usar o assembler embutido para inserir instruções
da linguagem de assembly incorporada diretamente em seus programas de código-fonte C e C++, sem etapas
adicionais de assembly e vinculação. O assembler embutido é integrado ao compilador e, portanto, não é
necessário um assembler separado, como o MASM (Microsoft Macro Assembler).
NOTE
Os programas com código assembler embutido não são totalmente portáteis para outras plataformas de hardware. Se
seu projeto visa portabilidade, evite usar o assembler embutido.
Não há suporte para o assembly embutido nos processadores ARM e x64. Os tópicos a seguir explicam como
usar o assembler embutido do Visual C/C++ com processadores x86:
Visão geral do assembler embutido
Vantagens do assembly embutido
__asm
Usando o idioma do assembly em blocos de __asm
Usando C ou C++ em blocos de __asm
Usando e preservando os registros no assembly embutido
Saltando para rótulos no assembly embutido
Chamando funções de C no assembly embutido
Chamando funções C++ em assembly embutido
Definindo blocos de __asm como macros C
Otimizando assembly embutido
FINAL específico da Microsoft
Veja também
Intrínsecos do compilador e linguagem do assembly
O MASM (Microsoft Macro Assembler) oferece várias vantagens sobre o assembly embutido. O MASM contém
uma linguagem macro que tem recursos como loop, aritmética e processamento de cadeias de caracteres de
texto. O MASM também oferece maior controle sobre o hardware, porque ele é compatível com conjuntos de
instrução de processadores 386, 486 e Pentium. Usando o MASM, também é possível reduzir o tempo e a
sobrecarga de memória.
Nesta seção
Opção de linha de comando ML e ML64
Descreve as opções de linha de comando ML.exe e ML64.exe.
Mensagens de erro de ML
Descreve mensagens e avisos de erro fatais e não fatais do ML.exe.
Referência de diretivas
Fornece links para artigos que abordam o uso de diretivas no MASM.
Referência de símbolos
Fornece links para artigos que abordam o uso de símbolos no MASM.
Referência de operadores
Fornece links para artigos que abordam o uso de operadores no MASM.
Manuais de programação do fabricante do processador
Fornece links para sites que podem conter informações de programação sobre processadores que a Microsoft
não fabrica nem vende ou com os quais ela não é compatível.
MASM para x64 (ml64.exe)
Informações sobre como criar arquivos de saída para x64.
MASM BNF Grammar
Descrição formal de BNF de MASM para x64.
Fornece links para diferentes áreas da documentação do Visual Studio e do Visual C++.
Veja também
x86Intrinsics
Intrínsecos x64 (amd64)
Extensões de componentes para .NET e UWP
O padrão C++ permite que os fornecedores de compiladores forneçam extensões não padrão para a
linguagem. A Microsoft fornece extensões para ajudar você a conectar o código C++ nativo ao código
executado no .NET Framework ou na Plataforma Universal do Windows (UWP). As extensões .NET são chamadas
de C++/CLI e geram um código que é executado no ambiente de execução gerenciado pelo .NET, chamado de
Common Language Runtime (CLR). As extensões da UWP são chamadas de C++ /CX e geram um código de
máquina nativo.
NOTE
Para novos aplicativos, recomendamos o uso de C++/WinRT em vez de C++/CX. C++/WinRT é uma nova projeção de
linguagem padrão C++17 para APIs do Windows Runtime. Continuaremos a dar suporte a C++/CX e WRL, mas
recomendamos que os novos aplicativos usem o C++/WinRT. Para obter mais informações, consulte C++/WinRT.
Dois runtimes, um conjunto de extensões

A C++/CLI amplia o padrão ISO/ANSI de C++ e é definida sob o padrão Ecma C++/CLI. Saiba mais em
Programação do .NET C++/CLI (Visual C++).
As extensões C++/CX são um subconjunto de C++/CLI. Embora a sintaxe da extensão seja idêntica na maioria
dos casos, o código gerado depende de você especificar a opção de compilador /ZW para o UWP de destino ou
a opção /clr para o .NET de destino. Essas opções são definidas automaticamente quando você usa o Visual
Studio para criar um projeto.
Palavras-chave do tipo de dados

As extensões de linguagem incluem palavras-chave agregadas, que consistem em dois tokens separados por
espaço em branco. Os tokens podem ter um significado quando são usados separadamente e outro significado
quando são usados juntos. Por exemplo, a palavra "ref" é um identificador comum e a palavra "class" é uma
palavra-chave que declara uma classe nativa. Mas quando essas palavras são combinadas para formar ref
class , a palavra-chave agregada resultante declara uma entidade que é conhecida como classe de runtime.
As extensões também incluem palavras-chave contextuais. Uma palavra-chave é tratada como contextual
dependendo do tipo de instrução que a contém e de seu posicionamento nessa instrução. Por exemplo, o token
"propriedade" pode ser um identificador ou pode declarar um tipo especial de membro de classe pública.
A tabela a seguir lista palavras-chave na extensão de linguagem C++.
PA L AVRA - C H AVE C O N T EXT UA L F IN A L IDA DE REF ERÊN C IA
ref class Não Declara uma classe. Classes e structs
ref struct
value class Não Declara uma classe de valor. Classes e structs
estrutura de valor
Classe de interface Não Declara uma interface. Classe de interface
interface struct
Classe enum Não Declara uma enumeração. Classe enum
enum struct
property Sim Declara uma propriedade. property
delegate Sim Declara um delegado. delegate (C++/CLI e

C++/CX)
event Sim Declara um evento. event
Especificadores de Substituição
Você pode usar as seguintes palavras-chave para qualificar o comportamento de substituição para derivação.
Embora a new palavra-chave não seja uma extensão do C++, ela é listada aqui porque pode ser usada em um
contexto adicional. Alguns especificadores também são válidos para programação nativa. Para obter mais
informações, consulte como: declarar especificadores de substituição em compilações nativas (C++/CLI).
resume Sim Indica que as funções ou resume

classes são abstratas.
new Não Indica que uma função não novo (novo slot em vtable)
é uma substituição de uma
versão de classe base.
override Sim Indica que um método deve override

ser uma substituição de
uma versão de classe base.
sealed Sim Impede que classes sejam sealed

usadas como classes base.
Palavras-chave para genéricos

As seguintes palavras-chave foram adicionadas para serem compatíveis com tipos genéricos. Para obter mais
informações, consulte Genéricos.
PA L AVRA - C H AVE C O N T EXT UA L F IN A L IDA DE
genérica Não Declara um tipo genérico.
where Sim Especifica as restrições aplicadas a um

parâmetro de tipo genérico.
Palavras-chave diversas
As seguintes palavras-chave foram adicionadas às extensões C++.
disso Sim Indica o comportamento de Tratamento de Exceção

tratamento de exceção
padrão.
for each, in Não Enumera elementos de uma for each, in

coleção.
gcnew Não Aloca os tipos no heap ref new, gcnew

coletado do lixo. Use em
vez de new e delete .
ref new Sim Aloca um tipo do Windows ref new, gcnew

Runtime. Use em vez de
new e delete .
initonly Sim Indica que um membro só InitOnly (C++/CLI)

pode ser inicializado na
declaração ou em um
construtor estático.
literal Sim Cria uma variável literal. literal
nullptr Não Indica que um identificador nullptr

ou ponteiro não aponta
para um objeto.
Construções de modelo
As seguintes construções de linguagem são implementadas como modelos, em vez de como palavras-chave. Se
você especificar a opção de compilador /ZW , eles serão definidos no namespace lang . Se você especificar a
opção de compilador /clr , eles serão definidos no namespace cli .
PA L AVRA - C H AVE F IN A L IDA DE REF ERÊN C IA
array Declara uma matriz. matrizes
interior_ptr (Somente CLR) Aponta para dados em interior_ptr (C++/CLI)

um tipo de referência.
pin_ptr (Apenas CLR) Aponta para os tipos de pin_ptr (C++/CLI)

referência do CLR para suprimir
temporariamente o sistema de coleta
de lixo.
safe_cast Determina e executa o método de safe_cast

conversão ideal para um tipo de
runtime.
typeid (Somente CLR) Recupera um objeto identificação

System.Type que descreve o tipo ou
objeto fornecido.
Declaradores
Os seguintes declaradores de tipo instruem o runtime a gerenciar automaticamente o tempo de vida e a
exclusão de objetos alocados.
O P ERA DO R F IN A L IDA DE REF ERÊN C IA
^ Declara um identificador para um Identificador para operador de objeto

objeto; ou seja, um ponteiro para um (^)
objeto do Windows Runtime ou do
CLR que é automaticamente excluído
quando não puder mais ser usado.
% Declara uma referência de Operador de referência de

companhamento; ou seja, uma rastreamento
referência a um objeto do Windows
Runtime ou do CLR que é
automaticamente excluído quando não
puder mais ser usado.
Construções adicionais e tópicos relacionados

Esta seção lista construções de programação adicionais e tópicos que pertencem ao CLR.
TÓ P IC O DESC RIÇ Ã O
__identifier (C++/CLI) (Windows Runtime e CLR) Permite o uso de palavras-chave

como identificadores.
Listas de argumentos variáveis (...) (C++/CLI) (Windows Runtime e CLR) Permite que uma função obtenha
um número variável de argumentos.
.NET Framework equivalentes a tipos nativos C++ (C++/CLI) Lista os tipos de CLR que são usados no lugar dos tipos
integrais de C++.
AppDomain __declspec privacidade __declspec modificador que exige que variáveis estáticas e
globais existam por AppDomain.
Conversões de Estilo C-Style com /clr (C++/CLI) Descreve como as conversões C-Style são interpretadas.
Convenção de chamada __clrcall Indica a convenção de chamada compatível com CLR.
__cplusplus_cli Macros predefinidas
Atributos personalizados Descreve como definir seus próprios atributos CLR.
Tratamento de Exceção Fornece uma visão geral do tratamento de exceção.
Substituições explícitas Demonstra como as funções de membro podem substituir

membros arbitrários.
Assemblies Friend (C++) Discute como um assembly de cliente pode acessar todos os
tipos em um componente de assembly.
TÓ P IC O DESC RIÇ Ã O
Conversão boxing Demonstra as condições nas quais os tipos de valores são

convertidos.
Suporte do compilador para características de tipo Discute como detectar características de tipos em tempo de
compilação.
pragmas gerenciados e não gerenciados Demonstra como funções gerenciadas e não gerenciadas
podem coexistir no mesmo módulo.
processo __declspec do privacidade __declspec modificador que exige que variáveis estáticas e
globais existam por processo.
Reflexão (C++/CLI) Demonstra a versão para CLR das informações de tipo em

tempo de execução.
Cadeia de caracteres Discute a conversão do compilador de literais de cadeia de

caracteres para String.
Encaminhamento de tipos (C++/CLI) Permite o movimento de um tipo em um assembly de

remessa para outro assembly para que o código do cliente
não precise ser recompilado.
Atributos definidos pelo usuário Demonstra atributos definidos pelo usuário.
#using diretiva Importa assemblies externos.
Documentação XML Explica a documentação de código baseada em XML usando

/doc (Processar comentários da documentação) (C/C++)
Veja também
Programação .NET com C++/CLI (Visual C++)
Interoperabilidade entre nativo e .NET
Atributos C++ para COM e .NET
A Microsoft define um conjunto de atributos C++ que simplificam a programação COM e .NET Framework
desenvolvimento de common language runtime. Quando você inclui atributos em seus arquivos de origem, o
compilador trabalha com DLLs do provedor para inserir código ou modificar o código nos arquivos de objeto
gerados. Esses atributos auxiliam na criação de arquivos .idl, interfaces, bibliotecas de tipos e outros elementos
COM. No IDE (ambiente de desenvolvimento integrado), os atributos são suportados pelos assistentes e pelo
janela Propriedades.
Embora os atributos eliminem algumas das codificações detalhadas necessárias para escrever objetos COM,
você precisa de uma experiência em conceitos básicos do COM para melhor usá-los.
NOTE
Se você estiver procurando atributos padrão do C++, consulte Atributos.
Finalidade de atributos
Os atributos estendem o C++ em direções não possíveis no momento sem quebrar a estrutura clássica da
linguagem. Os atributos permitem que provedores (DLLs separadas) estendam a funcionalidade de linguagem
dinamicamente. O objetivo principal dos atributos é simplificar a adoção de componentes COM, além de
aumentar o nível de produtividade do desenvolvedor do componente. Os atributos podem ser aplicados a
praticamente qualquer constructo do C++, como classes, membros de dados ou funções membro. Veja a seguir
um destaque dos benefícios fornecidos por essa nova tecnologia:
Expõe uma convenção de chamada familiar e simples.
Usa o código inserido, que, ao contrário das macros, é reconhecido pelo depurador.
Permite derivação fácil de classes base sem detalhes de implementação onerosos.
Substitui a grande quantidade de código IDL exigida por um componente COM por alguns atributos
concisos.
Por exemplo, para implementar um simples sink de eventos para uma classe ATL genérica, você pode aplicar o
atributo event_receiver a uma classe específica, como CMyReceiver . Em event_receiver seguida, o atributo é
compilado pelo compilador do Microsoft C++, que insere o código adequado no arquivo de objeto.
[event_receiver(com)]
class CMyReceiver
{
void handler1(int i) { ... }
void handler2(int i, float j) { ... }
}
Em seguida, você pode configurar os métodos e manipular eventos (usando a função CMyReceiver handler1
handler2 intrínseca __hook) de uma origem do evento, que você pode criar usando event_source .
Mecânica básica de atributos

Há três maneiras de inserir atributos em seu projeto. Primeiro, você pode inseri-los manualmente em seu
código-fonte. Em segundo lugar, você pode inseri-los usando a grade de propriedades de um objeto em seu
projeto. Por fim, você pode inseri-los usando os vários assistentes. Para obter mais informações sobre como
usar a janela Propriedades e os vários assistentes, consulte projetos Visual Studio – C++.
Como antes, quando o projeto é compilado, o compilador analisará cada arquivo de origem C++, produzindo
um arquivo de objeto. No entanto, quando o compilador encontra um atributo, ele é analisado e verificado
sintaticamente. Em seguida, o compilador chama dinamicamente um provedor de atributos para inserir código
ou fazer outras modificações no tempo de compilação. A implementação do provedor difere dependendo do
tipo de atributo. Por exemplo, atributos relacionados à ATL são implementados por Atlprov.dll.
A figura a seguir demonstra a relação entre o compilador e o provedor de atributo.
NOTE
O uso do atributo não altera o conteúdo do arquivo de origem. A única vez que o código de atributo gerado fica visível é
durante as sessões de depuração. Além disso, para cada arquivo de origem no projeto, você pode gerar um arquivo de
texto que exibe os resultados da substituição de atributo. Para obter mais informações sobre esse procedimento, consulte
/Fx (Mesclar código injetado) e Depurando código injetado.
Como a maioria dos constructos do C++, os atributos têm um conjunto de características que definem seu uso
adequado. Isso é conhecido como o contexto do atributo e é abordado na tabela de contexto de atributo para
cada tópico de referência de atributo. Por exemplo, o atributo coclass só pode ser aplicado a uma classe ou
estrutura existente, em vez do atributo cpp_quote, que pode ser inserido em qualquer lugar dentro de um
arquivo de origem C++.
Compilando um programa atribuído

Depois de colocar Visual C++ atributos em seu código-fonte, talvez você queira que o compilador do Microsoft
C++ produza uma biblioteca de tipos e um arquivo .idl para você. As opções do linker a seguir ajudam você a
criar arquivos .tlb e .idl:
/IDLOUT
/IGNOREIDL
/MIDL
/TLBOUT
Alguns projetos contêm vários arquivos .idl independentes. Eles são usados para produzir dois ou mais arquivos
.tlb e, opcionalmente, a viniá-los ao bloco de recursos. Atualmente, não há suporte para esse cenário Visual
C++.
Além disso, o Visual C++ linker de saída de todas as informações de atributo relacionadas a IDL em um único
arquivo MIDL. Não haverá nenhuma maneira de gerar duas bibliotecas de tipos de um único projeto.
Contextos de atributo
Os atributos do C++ podem ser descritos usando quatro campos básicos: o destino ao qual eles podem ser
aplicados ( Aplica-se a ), se eles são reabilíveis ou não ( Replicação ), a presença necessária de outros atributos
(Atributos Necessários ) e incompatibilidades com outros atributos (Atributos Inválidos ). Esses campos são
listados em uma tabela que acompanha o tópico de referência de cada atributo. Cada um desses campos é
descrito abaixo.
Aplica-se A
Este campo descreve os diferentes elementos da linguagem C++ que são destinos legais para o atributo
especificado. Por exemplo, se um atributo especificar "classe" no campo Aplica-se a, isso indica que o atributo só
pode ser aplicado a uma classe C++ legal. Se o atributo for aplicado a uma função de membro de uma classe,
um erro de sintaxe resultará.
Para obter mais informações, consulte Atributos por uso.
Repetível
Esse campo informa se o atributo pode ser aplicado repetidamente ao mesmo destino. A maioria dos atributos
não pode ser repetida.
Atributos necessários.
Esse campo lista outros atributos que precisam estar presentes (ou seja, aplicados ao mesmo destino) para que
o atributo especificado funcione corretamente. É incomum que um atributo tenha entradas para esse campo.
Atributos inválidos
Esse campo lista outros atributos incompatíveis com o atributo especificado. É incomum que um atributo tenha
entradas para esse campo.
Nesta seção
Perguntas frequentes sobre programação de atributo
Atributos por grupo
Atributos por uso
Referência alfabética de atributos
Bibliotecas
O Visual Studio inclui as bibliotecas a seguir quando você instala uma ou mais cargas de trabalho do C++. Para
obter informações sobre como instalar bibliotecas de terceiros, consulte vcpkg.
Bibliotecas padrão
Biblioteca Padrão do C++
Biblioteca SafeInt
OpenMP
Bibliotecas para aplicativos do Windows

MFC/ATL
Bibliotecas paralelas
Bibliotecas de acesso a dados
Referência da biblioteca de tempo de execução da
Microsoft C (CRT)
A biblioteca de tempo de execução da Microsoft fornece rotinas para a programação do sistema operacional
Microsoft Windows. Essas rotinas automatizam muitas tarefas comuns de programação que não são fornecidas
pelas linguagens C e C++.
Programas de exemplo estão incluídos nos tópicos de referência individuais para a maioria das rotinas na
biblioteca.
Nesta seção
Rotinas de tempo de execução C universal por categoria
Fornece links para a biblioteca de tempo de execução por categoria.
Variáveis globais e tipos padrão
Fornece links para as variáveis globais e tipos padrão fornecidos pela biblioteca de tempo de execução.
Constantes globais
Fornece links para as constantes globais definidas pela biblioteca de tempo de execução.
Estado global
Descreve o escopo do estado global na biblioteca de tempo de execução C.
Mapeamentos de texto genérico
Fornece links para os mapeamentos de texto genérico definidos em Tchar.h.
Referência de função alfabética
Fornece links para as funções da biblioteca de tempo de execução C, organizadas em ordem alfabética.
Visões gerais da família de funções
Fornece links para as funções da biblioteca de tempo de execução C, organizadas por família de funções.
Cadeias de caracteres de idioma e país/região
Descreve como usar a setlocale função para definir o idioma e cadeias de caracteres de país/região.
Arquivos de biblioteca de tempo de execução C (CRT) e C++ Standard (STL) .lib
Lista de .lib arquivos que compõem as bibliotecas de tempo de execução C e suas opções de compilador e
diretivas de pré-processador associadas.
Rotinas de depuração
Fornece links para as versões de depuração das rotinas da biblioteca de tempo de execução.
Verificação de erros em tempo de execução
Fornece links para funções que dão suporte a verificações de erro em tempo de execução.
Comportamento da biblioteca de tempo de execução de DLLs e Visual C++
Discute o código de inicialização e o ponto de entrada usado para uma DLL.
Pura
Fornece links para usar o depurador do Visual Studio para corrigir erros de lógica em seu aplicativo ou
procedimentos armazenados.
Referência da Biblioteca Padrão C++
É possível chamar um programa do C++ em um grande número de funções por meio dessa implementação em
conformidade da Biblioteca Padrão C++. Essas funções executam serviços como entrada e saída e fornecem
implementações eficientes de operações usadas com frequência.
Para obter mais informações sobre como vincular com o arquivo de tempo de execução do Visual C++
apropriado .lib , consulte .lib arquivos de biblioteca de tempo de execução C (CRT) e C++ standard library
(STL).
Nesta seção
Visão geral da biblioteca padrão do C++
Fornece uma visão geral da implementação da Microsoft da Biblioteca Padrão C++.
iostream Çã
Fornece uma visão geral da iostream programação.
Referência de arquivos de cabeçalho
Fornece links para tópicos de referência sobre os arquivos de cabeçalho da biblioteca padrão do C++, com
exemplos de código.
Biblioteca de SafeInt
SafeInt é uma biblioteca portátil que pode ser usada com MSVC, GCC ou Clang para ajudar a evitar estouros de
inteiros que podem ocorrer quando o aplicativo realiza operações matemáticas. A versão mais recente desta
biblioteca está localizada em https://github.com/dcleblanc/SafeInt .
Nesta seção
SEÇ Ã O DESC RIÇ Ã O
Classe SafeInt Essa classe protege contra estouros de inteiros.
Funções (SafeInt) Funções que podem ser usadas sem a criação de um objeto
SafeInt .
Classe SafeIntException Uma classe de exceções relacionadas à classe SafeInt .
Referência da linguagem C++ Referência e conteúdo conceitual para a linguagem C++.

Classe SafeInt
Estende as primitivas de inteiro para ajudar a evitar o estouro de inteiro e permite comparar diferentes tipos de
inteiros.
NOTE
A versão mais recente da biblioteca SafeInt está localizada em https://github.com/dcleblanc/SafeInt . Para usar a biblioteca
SafeInt, clone o repositório e #include "SafeInt.hpp"
Sintaxe
template<typename T, typename E = _SAFEINT_DEFAULT_ERROR_POLICY>
class SafeInt;
Parâmetros
T
O tipo de inteiro ou parâmetro booliano que SafeInt substitui.
E
Um tipo de dados enumerados que define a política de tratamento de erro.
U
O tipo de inteiro ou parâmetro booliano para o operando secundário.
RHS
[in] Um parâmetro de entrada que representa o valor no lado direito do operador em várias funções
independentes.
Encontrei
independentes.
bits
independentes.
Membros
Construtores públicos
NAME DESC RIÇ Ã O
SafeInt::SafeInt Construtor padrão.
Operadores de atribuição
NAME SIN TA XE
= template<typename U>
SafeInt<T,E>& operator= (const U& rhs)
= SafeInt<T,E>& operator= (const T& rhs) throw()
= template<typename U>
SafeInt<T,E>& operator= (const SafeInt<U, E>& rhs)
= SafeInt<T,E>& operator= (const SafeInt<T,E>& rhs)

throw()
Operadores de conversão
NAME SIN TA XE
bool operator bool() throw()
char operator char() const
signed char operator signed char() const
unsigned char operator unsigned char() const
__int16 operator __int16() const
unsigned __int16 operator unsigned __int16() const
long operator long() const
unsigned long operator unsigned long() const
wchar_t operator wchar_t() const
Operadores de comparação
NAME SIN TA XE
< template<typename U>
bool operator< (U rhs) const throw()
< bool operator< (SafeInt<T,E> rhs) const throw()

NAME SIN TA XE
>= template<typename U>
bool operator>= (U rhs) const throw()
>= Bool operator>= (SafeInt<T,E> rhs) const throw()
> template<typename U>
bool operator> (U rhs) const throw()
> Bool operator> (SafeInt<T,E> rhs) const throw()
<= template<typename U>
bool operator<= (U rhs) const throw()
<= bool operator<= (SafeInt<T,E> rhs) const throw()
== template<typename U>
bool operator== (U rhs) const throw()
== bool operator== (bool rhs) const throw()
== bool operator== (SafeInt<T,E> rhs) const throw()
!= template<typename U>
bool operator!= (U rhs) const throw()
!= bool operator!= (bool b) const throw()
!= bool operator!= (SafeInt<T,E> rhs) const throw()
Operadores aritméticos
NAME SIN TA XE
+ const SafeInt<T,E>& operator+ () const throw()
- SafeInt<T,E> operator- () const
++ SafeInt<T,E>& operator++ ()
-- SafeInt<T,E>& operator-- ()
% template<typename U>
SafeInt<T,E> operator% (U rhs) const
% SafeInt<T,E> operator% (SafeInt<T,E> rhs) const

NAME SIN TA XE
%= template<typename U>
SafeInt<T,E>& operator%= (U rhs)
%= template<typename U>
SafeInt<T,E>& operator%= (SafeInt<U, E> rhs)
* template<typename U>
SafeInt<T,E> operator* (U rhs) const
* SafeInt<T,E> operator* (SafeInt<T,E> rhs) const
*= SafeInt<T,E>& operator*= (SafeInt<T,E> rhs)
*= template<typename U>
SafeInt<T,E>& operator*= (U rhs)
*= template<typename U>
SafeInt<T,E>& operator*= (SafeInt<U, E> rhs)
/ template<typename U>
SafeInt<T,E> operator/ (U rhs) const
/ SafeInt<T,E> operator/ (SafeInt<T,E> rhs ) const
/= SafeInt<T,E>& operator/= (SafeInt<T,E> i)
/= template<typename U>
SafeInt<T,E>& operator/= (U i)
/= template<typename U>
SafeInt<T,E>& operator/= (SafeInt<U, E> i)
+ SafeInt<T,E> operator+ (SafeInt<T,E> rhs) const
+ template<typename U>
SafeInt<T,E> operator+ (U rhs) const
+= SafeInt<T,E>& operator+= (SafeInt<T,E> rhs)
+= template<typename U>
SafeInt<T,E>& operator+= (U rhs)

NAME SIN TA XE
+= template<typename U>
SafeInt<T,E>& operator+= (SafeInt<U, E> rhs)
- template<typename U>
SafeInt<T,E> operator- (U rhs) const
- SafeInt<T,E> operator- (SafeInt<T,E> rhs) const
-= SafeInt<T,E>& operator-= (SafeInt<T,E> rhs)
-= template<typename U>
SafeInt<T,E>& operator-= (U rhs)
-= template<typename U>
SafeInt<T,E>& operator-= (SafeInt<U, E> rhs)
Operadores lógicos
NAME SIN TA XE
! bool operator !() const throw()
~ SafeInt<T,E> operator~ () const throw()
<< template<typename U>
SafeInt<T,E> operator<< (U bits) const throw()
<< template<typename U>
SafeInt<T,E> operator<< (SafeInt<U, E> bits) const

throw()
<<= template<typename U>
SafeInt<T,E>& operator<<= (U bits) throw()
<<= template<typename U>
SafeInt<T,E>& operator<<= (SafeInt<U, E> bits)

throw()
>> template<typename U>
SafeInt<T,E> operator>> (U bits) const throw()

NAME SIN TA XE
>> template<typename U>
SafeInt<T,E> operator>> (SafeInt<U, E> bits) const

throw()
>>= template<typename U>
SafeInt<T,E>& operator>>= (U bits) throw()
>>= template<typename U>
SafeInt<T,E>& operator>>= (SafeInt<U, E> bits)

throw()
& SafeInt<T,E> operator& (SafeInt<T,E> rhs) const

throw()
& template<typename U>
SafeInt<T,E> operator& (U rhs) const throw()
&= SafeInt<T,E>& operator&= (SafeInt<T,E> rhs) throw()
&= template<typename U>
SafeInt<T,E>& operator&= (U rhs) throw()
&= template<typename U>
SafeInt<T,E>& operator&= (SafeInt<U, E> rhs)

throw()
^ SafeInt<T,E> operator^ (SafeInt<T,E> rhs) const

throw()
^ template<typename U>
SafeInt<T,E> operator^ (U rhs) const throw()
^= SafeInt<T,E>& operator^= (SafeInt<T,E> rhs) throw()
^= template<typename U>
SafeInt<T,E>& operator^= (U rhs) throw()
^= template<typename U>
SafeInt<T,E>& operator^= (SafeInt<U, E> rhs)

throw()
| SafeInt<T,E> operator| (SafeInt<T,E> rhs)

const throw()
NAME SIN TA XE
| template<typename U>
SafeInt<T,E> operator| (U rhs) const throw()
|= SafeInt<T,E>& operator|= (SafeInt<T,E> rhs)

throw()
|= template<typename U>
SafeInt<T,E>& operator|= (U rhs) throw()
|= template<typename U>
SafeInt<T,E>& operator|= (SafeInt<U, E> rhs)

throw()
Comentários
A classe SafeInt protege contra o estouro de inteiros em operações matemáticas. Por exemplo, considere
adicionar dois inteiros de 8 bits: um tem o valor 200, o outro, 100. A operação matemática correta seria 200 +
100 = 300. No entanto, devido ao limite de inteiros de 8 bits, o bit superior será perdido, e o compilador
retornará como resultado 44 (300 - 28). Qualquer operação que depender dessa equação matemática gerará um
comportamento inesperado.
A classe SafeInt verifica se um estouro aritmético ocorreu ou se o código tenta dividir por zero. Em ambos os
casos, a classe chama o manipulador de erro para avisar o programa sobre o possível problema.
Essa classe também permite comparar dois tipos diferentes de inteiros, desde que sejam objetos SafeInt .
Normalmente, quando você faz uma comparação, primeiro você deve converter os números para serem do
mesmo tipo. Converter um número em outro tipo geralmente requer verificações para garantir que não haja
perda de dados.
A tabela Operadores neste tópico mostra os operadores matemáticos e de comparação compatíveis com a
classe SafeInt . A maioria dos operadores matemáticos retorna um objeto SafeInt do tipo T .
Operações de comparação entre um SafeInt e um tipo integral podem ser executadas em qualquer direção.
Por exemplo, SafeInt<int>(x) < y e y> SafeInt<int>(x) são válidos e retornarão o mesmo resultado.
Muitos operadores binários não oferecem suporte ao uso de dois SafeInt tipos diferentes. Um exemplo disso é
o operador & . SafeInt<T, E> & int tem suporte, mas SafeInt<T, E> & SafeInt<U, E> não é. No último
exemplo, o compilador não sabe o tipo de parâmetro a ser retornado. Uma solução para esse problema é
converter o segundo parâmetro de volta no tipo base. Usando os mesmos parâmetros, isso pode ser feito com
SafeInt<T, E> & (U)SafeInt<U, E> .
NOTE
Para qualquer operação bit a bit, os dois parâmetros diferentes devem ter o mesmo tamanho. Se os tamanhos forem
diferentes, o compilador lançará uma exceção ASSERT. Não é garantido que os resultados dessa operação sejam precisos.
Para resolver esse problema, converta o parâmetro menor até que ele tenha o mesmo tamanho que o parâmetro maior.
Para operadores de deslocamento, a mudança para mais bits do que existe para o tipo de modelo lançará uma
exceção ASSERT. Isso não terá efeito no modo de liberação. A combinação de dois tipos de parâmetros SafeInt é
possível para os operadores shift porque o tipo de retorno é o mesmo do tipo original. O número no lado
direito do operador indica apenas o número de bits a serem alterados.
Quando você faz uma comparação lógica com um objeto SafeInt, a comparação é estritamente aritmética. Por
exemplo, considere estas expressões:
SafeInt<uint>((uint)~0) > -1
((uint)~0) > -1
A primeira instrução é resolvida como true , mas a segunda instrução é resolvida para false . A negação bit a
bit de 0 é 0xFFFFFFFF. Na segunda instrução, o operador de comparação padrão compara 0xFFFFFFFF a
0xFFFFFFFF e os considera iguais. O operador de comparação da classe SafeInt percebe que o segundo
parâmetro é negativo, enquanto o primeiro não tem sinal. Portanto, apesar de a representação de bits ser
idêntica, o operador lógico SafeInt percebe que o inteiro sem sinal é maior que -1.
Tenha cuidado ao usar a classe SafeInt junto com o operador ternário ?: . Considere a seguinte linha de
código.
Int x = flag ? SafeInt<unsigned int>(y) : -1;
O compilador converte isso no seguinte:
Int x = flag ? SafeInt<unsigned int>(y) : SafeInt<unsigned int>(-1);
Se flag for false , o compilador lançará uma exceção em vez de atribuir o valor de-1 a x . Portanto, para
evitar esse comportamento, o código correto a ser usado é a seguinte linha.
Int x = flag ? (int) SafeInt<unsigned int>(y) : -1;
T e U podem receber um tipo booliano, um tipo caractere ou um tipo inteiro. Os tipos inteiros podem ser
assinados ou não assinados e ter qualquer tamanho de 8 a 64 bits.
NOTE
Embora a classe SafeInt aceite qualquer tipo inteiro, seu desempenho de execução é melhor com tipos sem sinal.
E é o mecanismo de tratamento de erro usado por SafeInt . Dois mecanismos de tratamento de erro são
fornecidos com a biblioteca SafeInt. A política padrão é SafeIntErrorPolicy_SafeIntException , que gera uma
exceção SafeIntException Class quando ocorre um erro. A outra política é SafeIntErrorPolicy_InvalidParameter ,
que interromperá o programa se ocorrer um erro.
Existem duas opções para personalizar a política de erro. A primeira opção é definir o parâmetro E quando
você cria um SafeInt . Use essa opção quando quiser alterar a política de tratamento de erro para apenas um
SafeInt . A outra opção é definir _SAFEINT_DEFAULT_ERROR_POLICY como sua classe personalizada de
tratamento de erro antes de incluir a biblioteca SafeInt . Use essa opção quando quiser mudar a política de
tratamento de erros padrão para todas as instâncias da classe SafeInt no seu código.
NOTE
Uma classe personalizada que manipula erros da biblioteca SafeInt não deve retornar o controle para o código que
chamou o manipulador de erros. Depois que o manipulador de erro é chamado, o resultado da SafeInt operação não
pode ser confiável.
Hierarquia de herança
SafeInt
Requisitos
Cabeçalho: SafeInt. HPP
NOTE
A versão mais recente desta biblioteca está localizada em https://github.com/dcleblanc/SafeInt . Clone a biblioteca e inclua
SafeInt. HPP para usar a biblioteca SafeInt. Prefira que este repositório GitHub SafeInt. h. é uma versão moderna do
<SafeInt. h> que inclui um pequeno número de correções de bugs, usa recursos modernos do C++ resultando em um
código mais eficiente e é portátil para qualquer plataforma que use compiladores gcc, Clang ou Intel.
Exemplo
#include "SafeInt.hpp" // set path to your clone of the SafeInt GitHub repo
(https://github.com/dcleblanc/SafeInt)
int main()
{
int divisor = 3;
int dividend = 6;
int result;
bool success = SafeDivide(dividend, divisor, result); // result = 2

success = SafeDivide(dividend, 0, result); // expect fail. result isn't modified.
}
Namespace: nenhum
SafeInt:: SafeInt
Constrói um objeto SafeInt .
SafeInt() throw
SafeInt (const T& i) throw ()
SafeInt (bool b) throw ()
template <typename U>

SafeInt (const SafeInt <U, E>& u)
I template <typename U>

SafeInt (const U& i)
Parâmetros
i
[in] O valor do novo objeto SafeInt . Este deve ser um parâmetro do tipo T ou U, dependendo do construtor.
b
[in] O valor booliano do novo objeto SafeInt .
u
[in] Um SafeInt do tipo U. O novo objeto SafeInt terá o mesmo valor que u, mas será do tipo T.
U O tipo de dados armazenados no SafeInt . Isso pode ser um tipo booliano, caractere ou inteiro. Se for um
tipo inteiro, ele poderá ser assinado ou não assinado e ficar entre 8 e 64 bits.
Comentários
O parâmetro de entrada para o construtor, i ou u, deve ser um tipo booliano, caractere ou inteiro. Se for outro
tipo de parâmetro, a SafeInt classe chamará static_assert para indicar um parâmetro de entrada inválido.
Os construtores que usam o tipo modelo U convertem automaticamente o parâmetro de entrada no tipo
especificado por T . A classe SafeInt converte os dados sem perda de dados. Ele informa ao manipulador de
erros E se ele não pode converter os dados para tipo T sem perda de dados.
Se você criar um SafeInt de um parâmetro booliano, precisará inicializar o valor imediatamente. Você não
pode construir um SafeInt usando o código SafeInt<bool> sb; . Isso gerará um erro de compilação.
Funções (SafeInt)
A biblioteca SafeInt fornece várias funções que você pode usar sem criar uma instância da classe SafeInt. Se
quiser proteger uma única operação matemática contra estouros de inteiro, você pode usar essas funções. Se
quiser proteger várias operações matemáticas, você deve criar objetos SafeInt . É mais eficiente criar SafeInt
objetos do que usar essas funções várias vezes.
Essas funções permitem comparar ou realizar operações matemáticas em dois tipos diferentes de parâmetros
sem antes precisar convertê-los no mesmo tipo.
Cada uma dessas funções tem dois tipos de modelo: T e U . Cada um desses tipos pode ser um tipo booliano,
caractere ou integral. Tipos integrais podem ser assinados ou não assinados e ter qualquer tamanho de 8 a 64
bits.
NOTE
A versão mais recente desta biblioteca está localizada em https://github.com/dcleblanc/SafeInt .
Nesta seção
F UN Ç Ã O DESC RIÇ Ã O
SafeAdd Adiciona dois números e protege contra estouros.
SafeCast Converte um tipo de parâmetro em outro tipo.
SafeDivide Divide dois números e protege contra a divisão por zero.
SafeEquals, SafeGreaterThan, SafeGreaterThanEquals, Compara dois números. Essas funções permitem comparar
SafeLessThan, SafeLessThanEquals, SafeNotEquals dois tipos diferentes de números sem alterar seus tipos.
SafeModulus Realiza a operação de módulo em dois números.
SafeMultiply Multiplica dois números juntos e protege contra estouros.
SafeSubtract Subtrai dois números e protege contra estouros.
SafeInt A classe SafeInt .
SafeIntException A classe de exceção específica da biblioteca SafeInt.
SafeAdd
Adiciona dois números de uma maneira que protege contra estouros.
template<typename T, typename U>

inline bool SafeAdd (
T t,
U u,
T& result
) throw ();
Parâmetros
t
[in] O primeiro número a adicionar. Deve ser do tipo T.
u
[in] O segundo número a adicionar. Deve ser do tipo U.
result
[out] O parâmetro em que SafeAdd armazena o resultado.
Valor Retornado
true Se nenhum erro ocorrer; false se ocorrer um erro.
SafeCast
Converte um tipo de número em outro tipo.

inline bool SafeCast (
const T From,
U& To
);
Parâmetros
De
[in] O número de origem para converter. Deve ser do tipo T .
Para
[out] Uma referência ao novo tipo de número. Deve ser do tipo U .
Valor Retornado
SafeDivide
Divide dois números de uma maneira que protege contra a divisão por zero.

inline bool SafeDivide (
T t,
U u,
T& result
) throw ();
Parâmetros
t
[in] O dividendo. Deve ser do tipo T.
u
[in] O divisor. Deve ser do tipo U.
result
[out] O parâmetro em que SafeDivide armazena o resultado.
Valor Retornado
SafeEquals
Compara dois números para determinar se eles são iguais.

inline bool SafeEquals (
const T t,
const U u
) throw ();
Parâmetros
t
[in] O primeiro número para comparar. Deve ser do tipo T.
u
[in] O segundo número para comparar. Deve ser do tipo U.
Valor Retornado
true Se t e u forem iguais; caso contrário false .
Comentários
O método aprimora == porque SafeEquals permite comparar dois tipos diferentes de números.
SafeGreaterThan
Compara dois números.

inline bool SafeGreaterThan (
const T t,
const U u
) throw ();
Parâmetros
t
[in] O primeiro número para comparar. Deve ser do tipo T .
u
[in] O segundo número para comparar. Deve ser do tipo U .
Valor Retornado
true Se t for maior que u; caso contrário false .
Comentários
SafeGreaterThan estende o operador de comparação regular, permitindo que você compare dois tipos
diferentes de números.
SafeGreaterThanEquals
template <typename T, typename U>

inline bool SafeGreaterThanEquals (
const T t,
const U u
) throw ();
Parâmetros
t
u
Valor Retornado
true Se t for maior ou igual a u; caso contrário false .
Comentários
SafeGreaterThanEquals aprimora o operador de comparação padrão porque permite comparar dois tipos
SafeLessThan
Determina se um número é menor que outro.

inline bool SafeLessThan (
const T t,
const U u
) throw ();
Parâmetros
t
[in] O primeiro número. Deve ser do tipo T .
u
no O segundo número. Deve ser do tipo U .
Valor Retornado
true Se t for menor que u; caso contrário false .
Comentários
Esse método aprimora o operador de comparação padrão porque SafeLessThan permite comparar dois tipos
SafeLessThanEquals
template <typename T, typename U>
inline bool SafeLessThanEquals (
const T t,
const U u
) throw ();
Parâmetros
t
u
Valor Retornado
true Se t for menor ou igual a u; caso contrário false .
Comentários
SafeLessThanEquals estende o operador de comparação regular, permitindo que você compare dois tipos
SafeModulus
Realiza a operação de módulo em dois números.

inline bool SafeModulus (
const T t,
const U u,
T& result
) throw ();
Parâmetros
t
[in] O divisor. Deve ser do tipo T .
u
[in] O dividendo. Deve ser do tipo U .
result
[out] O parâmetro em que SafeModulus armazena o resultado.
Valor Retornado
SafeMultiply
Multiplica dois números juntos de uma forma que protege contra estouros.

inline bool SafeMultiply (
T t,
U u,
T& result
) throw ();
Parâmetros
t
[in] O primeiro número para multiplicar. Deve ser do tipo T .
u
[in] O segundo número para multiplicar. Deve ser do tipo U .
result
[out] O parâmetro em que SafeMultiply armazena o resultado.
Valor Retornado
SafeNotEquals
Determina se dois números não são iguais.

inline bool SafeNotEquals (
const T t,
const U u
) throw ();
Parâmetros
t
u
Valor Retornado
true Se t e u não forem iguais; caso contrário false .
Comentários
O método aprimora != porque SafeNotEquals permite comparar dois tipos diferentes de números.
SafeSubtract
Subtrai dois números de uma maneira que protege contra estouros.

inline bool SafeSubtract (
T t,
U u,
T& result
) throw ();
Parâmetros
t
[in] O primeiro número na subtração. Deve ser do tipo T .
u
[in] O número para subtrair de t. Deve ser do tipo U .
result
[out] O parâmetro em que SafeSubtract armazena o resultado.
Valor Retornado
Classe SafeIntException
A classe SafeInt usa SafeIntException para identificar por que uma operação matemática não pode ser
concluída.
NOTE
A versão mais recente desta biblioteca está localizada em https://github.com/dcleblanc/SafeInt .
Sintaxe
class SafeIntException;
Membros
Construtores públicos
NAME DESC RIÇ Ã O
SafeIntException:: SafeIntException Cria um objeto SafeIntException .
Comentários
A classe SafeInt é a única que usa a classe SafeIntException .
Hierarquia de herança
SafeIntException
Requisitos
Cabeçalho: safeint.h
Namespace: msl::utilities
SafeIntException:: SafeIntException
Cria um objeto SafeIntException .
SafeIntException();
SafeIntException(
SafeIntError code
);
Parâmetros
code
[in] Um valor de dados enumerados que descreve o erro ocorrido.
Comentários
Os valores possíveis para code estão definidos no arquivo Safeint.h. Para praticidade, os valores possíveis
também aparecem nesta lista.
SafeIntNoError
SafeIntArithmeticOverflow
SafeIntDivideByZero
MFC e ATL
O MFC (MFC) fornece um wrapper C++ orientado a objeto no Win32 para o desenvolvimento rápido de
aplicativos de desktop nativos. A Active Template Library (ATL) é uma biblioteca de wrapper que simplifica o
desenvolvimento COM e é usada extensivamente para a criação de controles ActiveX.
Você pode criar programas MFC ou ATL com o Visual Studio Community Edition ou superior. As Express Editions
não dão suporte a MFC ou ATL.
No Visual Studio 2015, Visual C++ é um componente opcional, e os componentes MFC e ATL são
subcomponentes opcionais em Visual C++. Se você não selecionar esses componentes ao instalar o Visual
Studio pela primeira vez, será solicitado a instalá-los na primeira tentativa de criar ou abrir um projeto MFC ou
ATL.
No Visual Studio 2017 e posterior, o MFC e o ATL são subcomponentes opcionais no desenvolvimento de
desktop com carga de trabalho do C++ no programa de instalador do Visual Studio. Você pode instalar o
suporte ATL sem MFC ou MFC combinado e suporte ATL (o MFC depende da ATL). Para obter mais informações
sobre cargas de trabalho e componentes, consulte instalar o Visual Studio.
Aplicativos de área de trabalho do MFC MFC fornecer um wrapper fino orientado a objeto sobre o
Win32 para permitir o rápido desenvolvimento de aplicativos
de GUI em C++.
Componentes de área de trabalho COM da ATL A ATL fornece modelos de classe e outras construções de
uso para simplificar a criação de objetos COM em C++.
Classes compartilhadas ATL/MFC Referências para classe CStringT e outras classes que são
compartilhadas por MFC e ATL.
Trabalhando com arquivos de recurso O editor de recursos permite que você edite recursos de
interface do usuário, como cadeias de caracteres, imagens e
caixas de diálogo.
C++ no Visual Studio Tópico pai para toda a documentação do C++.

Programação em paralelo no Visual C++
O Visual C++ fornece as seguintes tecnologias para ajudá-lo a criar programas multithread e paralelos que
aproveitam vários núcleos e usam a GPU para programação de uso geral.
Auto-paralelização e vetorização automática Otimizações de compilador que aceleram o código.
Runtime de Simultaneidade Classes que simplificam a gravação de programas que usam

paralelismo de dados ou paralelismo de tarefas.
C++ AMP (C++ Accelerated Massive Parallelism) Classes que permitem o uso de processadores gráficos
modernos para programação de uso geral.
Suporte multithread para código anterior (Visual C++) Tecnologias mais antigas que podem ser úteis em aplicativos
mais antigos. Para novos aplicativos, use o Tempo de
Execução de Simultaneidade ou o C++ AMP.
OpenMP A implementação da API de OpenMP da Microsoft.
C++ no Visual Studio Esta seção da documentação contém informações sobre a

maioria dos recursos do Visual C++.
Acesso a dados no Visual C++
Praticamente todos os produtos de banco de dados, SQL e NoSQL, fornecem uma interface para aplicativos
nativos do C++. A interface padrão do setor é ODBC, que dá suporte para todos os principais produtos de
Banco de Dados SQL e para muitos produtos NoSQL. Para produtos que não são da Microsoft, consulte o
fornecedor para obter mais informações. Bibliotecas de terceiros com vários termos de licença também estão
disponíveis.
Desde 2011, a Microsoft tem se alinhado com o ODBC como o padrão para aplicativos nativos para se conectar
a bancos de dados do Microsoft SQL Server, tanto localmente quanto na nuvem. Para obter mais informações,
consulte Programação de acesso a dados (MFC/ATL). As bibliotecas C++/CLI podem usar os drivers ODBC
nativos ou ADO.NET. Para obter mais informações, consulte acesso a dados usando ADO.net (C++/CLI) e
acessando dados no Visual Studio.
Nesta seção
Programação de acesso a dados (MFC/ATL)
Descreve programação de acesso a dados herdados com Visual C++, em que a melhor maneira é usar uma das
bibliotecas de classe, como a classe biblioteca ATL (Active Template Library) ou a biblioteca MFC (Microsoft
Foundation Class), que simplificam o trabalho com as APIs do banco de dados.
Conectividade aberta de banco de dados (ODBC)
A biblioteca MFC (Microsoft Foundation Classes) fornece classes para programar com ODBC (Conectividade
Aberta de Banco de Dados).
Programação de OLE DB
Uma interface principalmente herdada que ainda é necessária em alguns cenários, especialmente quando você
está programando com relação a servidores vinculados.
Tópicos Relacionados
Conectar-se ao Banco de Dados SQL usando C e C++
Conecte-se ao Banco de Dados SQL do Azure de aplicativos C ou C++.
Biblioteca de Clientes do Armazenamento do Microsoft Azure para C++
O Armazenamento do Azure é uma solução de armazenamento em nuvem para aplicativos modernos que
dependem de durabilidade, disponibilidade e escalabilidade para atender às necessidades dos clientes. Conecte-
se ao Armazenamento do Azure pelo C++ usando a Biblioteca de Cliente do Armazenamento do Azure para
C++.
ODBC Driver for SQL Server
O driver ODBC mais recente fornece um eficiente acesso a dados para o Microsoft SQL Server e para o Banco
de Dados SQL do Microsoft Azure para aplicativos baseados em C/C++. Ele dá suporte para recursos, incluindo
o Always Encrypted, o Azure Active Directory e os Grupos de Disponibilidade AlwaysOn. Também está
disponível para MacOS e Linux.
Driver do OLE DB para SQL Server
O driver OLE DB mais recente é uma API (interface de programação de aplicativo) de acesso a dados autônoma
que é compatível com Microsoft SQL Server e ao Banco de Dados SQL do Microsoft Azure.
Central de Desenvolvedores do Microsoft Azure C e C++
O Azure facilita o build de aplicativos do C++, com maior flexibilidade, escalabilidade e confiabilidade usando
ferramentas que você adora.
Como usar o armazenamento de BLOBs do C++
O Armazenamento de Blobs do Azure é um serviço que armazena dados não estruturados na nuvem como
objetos/blobs. O Armazenamento de Blobs pode conter qualquer tipo de texto ou de dados binários, como um
documento, um arquivo de mídia ou um instalador de aplicativo. O Armazenamento de Blobs também é
chamado de armazenamento de objeto.
Referência do programador ODBC
A interface ODBC é projetada para uso com a linguagem de programação C. O uso da interface ODBC abrange
três áreas: instruções SQL, chamadas da função ODBC e programação em C.
Veja também

Apostila C++

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila C++

Enviado por

Direitos autorais:

Formatos disponíveis

Contents

Microsoft C/C++ no Visual Studio

Microsoft Visual C++ (MSVC) refere-se às bibliotecas e ferramentas de desenvolvimento de linguagem de

Instalar o Visual Studio e atualizar de versões anteriores

Aprender sobre o C++

Ferramentas de desenvolvimento do C++

Escrever aplicativos em C++

Bibliotecas do C++ no Visual Studio

Bibliotecas C++ de software livre de terceiros

Adicionar ao controle do código-fonte

Criar interfaces do usuário com designers

Adicionar e editar recursos

Build (compilar e vincular)

Implantar aplicativos concluídos

O que há de novo para C++ no Visual Studio versão 16,9

Atualização das mensagens de erro para intercalação de memória de sombra e falha de

O que há de novo para C++ no Visual Studio versão 16,8

O que há de novo para C++ no Visual Studio versão 16,7

O que há de novo para C++ no Visual Studio versão 16,6

O que há de novo para C++ no Visual Studio versão 16,5

O que há de novo para C++ no Visual Studio versão 16,4

O que há de novo para C++ no Visual Studio versão 16,3

P0487R1: Resolvendo operator>>(basic_istream&, CharT*)

O que há de novo para C++ no Visual Studio versão 16,1

O que há de novo para C++ no Visual Studio versão 16,0

compilador Visual Studio de 2017 de C++

a /experimental:preprocessor opção de compilador habilita o novo pré-processador de MSVC experimental

Biblioteca padrão C++

Melhorias de diagnóstico secundárias basic_string _ITERATOR_DEBUG_LEVEL != 0 . Quando uma verificação

Os contêineres da biblioteca padrão agora fixam o max_size() ao numeric_limits<difference_type>::max()

Para obter mais informações, consulte Conformidade da linguagem C/C++ da Microsoft.

Suporte a algoritmos paralelos não é mais experimental

Ainda outro conjunto de correções de compatibilidade de pesquisa de nome

Visual Studio IDE do C++ 2017

REC URSO M EL H O RIA DE DESEM P EN H O

Alterar assinatura 4.5x

Localizar Todas as Referências 4.7x

Adicionada a capacidade de filtrar por tipo os itens da Lista de Membros.

Projetos não MSBuild com Abrir Pasta

Suporte a CMake através do Open Folder

Suporte adicionado para o gerador Ninja do CMake.

Suporte adicionado para importação de caches de CMake existentes.

Desenvolvimento da área de trabalho do Windows

Desenvolvimento de Linux com C++

Desenvolvimento de jogos com C++

Desenvolvimento móvel com C++ para Android e iOS

Aplicativos universais do Windows

Novas opções para C++ na UWP (Plataforma Universal do Windows)

Foi adicionado um modelo de projeto do Projeto de Empacotamento de Aplicativo do Windows , que

O conjunto de ferramentas da plataforma Clang/C2

Análise de código C++

Adicionada compatibilidade com regras relacionadas ao gerenciamento de recursos.

Teste de unidade no Visual Studio 2017

Suporte adicionado para suporte Boost.Test à biblioteca dinâmica.

Diagnóstico de gráficos do Visual Studio

C++ no Visual Studio

Guia de atualização e portabilidade do C++

Erros e avisos de ferramentas e compiladores do C/C++

Linguagem de assembly e intrínsecores do compilador C/C++

visão geral do C/C++ no Visual Studio

Referência de pré-processador C/C++

Projetos C/C++ e sistemas de compilação

Referência da STL (biblioteca padrão do C++)

Linux com C++ no Visual Studio