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-nos 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, leia sobre o que faz um bom relatório. Descrevemos como gerar uma reprodução para o tipo de problema que você encontrou e como enviar o relatório para a equipe do 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
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.
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
C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\c1.dll: Version 19.14.26428.1
C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\c1xx.dll: Version 19.14.26428.1
C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\c2.dll: Version 19.14.26428.1
C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\link.exe: Version 14.14.26428.1
C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\VC\Tools\MSVC\14.14.26428\bin\HostX86\x86\mspdb140.dll: Version 14.14.26428.1
C:\Program Files (x86)\Microsoft Visual 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. Isso é importante porque o problema que você encontrou pode existir somente ao criar 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
Localize o arquivo CL.command.1.tlog e abra-o. Por padrão, esse arquivo fica localizado na pasta Documentos em \Visual Studio versão\Projects\SolutionName\ProjectName\Configuration\ProjectName.tlog\CL.command.1.tlog, ou em sua pasta Usuário, em \Source\Repos\SolutionName\ProjectName\Configuration\ProjectName.tlog\CL.command.1.tlog. Ele pode estar em um local diferente se você usar outro sistema de compilação ou se tiver alterado o local padrão do seu projeto.
Dentro desse arquivo, encontre os nomes dos arquivos de código-fonte, seguidos dos argumentos da linha de comando usados para compilá-los, cada um em linhas separadas.
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 que você encontrou. 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 verificar 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. O ideal é incorporá-la na própria instrução de saída, por exemplo, printf("This should be 5: %d\n", actual_result);. Se o programa falhar ou travar, mencione isso também.
Acrescente quaisquer outros detalhes que possam nos ajudar a diagnosticar o problema encontrado, como quaisquer soluções alternativas que você tenha 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. Isso demonstra de forma reprodutível o problema que você encontrou, daí 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, se não fosse pelo problema encontrado. 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 é:
Mínimo. 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;eprintf("%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. Os problemas que você pode encontrar em versões mais antigas do conjunto de ferramentas geralmente são corrigidos em versões mais recentes. 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 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 diferentes níveis de implementação de padrões C++ e assim por diante). Se 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 Wandbox e Compiler Explorer.
Observação
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'
Please choose the Technical Support command on the Visual C++
Help menu, or open the Technical Support help file for more information
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. O arquivo compiler\utc\src\p2\main.c é mencionado com frequência, mas esse detalhe pode ser ignorado.
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.
Please choose the Technical Support command on the Visual C++
Help menu, or open the Technical Support help file for more information
INTERNAL COMPILER ERROR in
'C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\BIN\cl.exe'
Please choose the Technical Support command on the Visual C++
Help menu, or open the Technical Support help file for more information
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 emite Erro das Ferramentas do Vinculador LNK1000.
Observação
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ê acredita que o problema encontrado resulta em uma geração de código inadequada, trate seu relatório da mesma forma como um crash 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.
Abaixo estão as instruções para gerar os vários tipos de reproduções a serem usados 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 insere os cabeçalhos incluídos para remover as dependências de outros arquivos de origem e de cabeçalho. A opção também resolve macros, condicionais #ifdef e outros comandos de pré-processador que podem depender de seu ambiente local.
Observação
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
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.
Abra o Prompt de Comando do Desenvolvedor correspondente à arquitetura de versão e à configuração do Visual Studio usada para compilar o projeto.
Mude para o diretório que contém seu projeto de reprodução.
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 um arquivo de código-fonte C++/CX ou estiver usando o recurso Módulos C++, serão necessárias mais algumas etapas. Para obter mais informações, veja as seguintes abaixo.
Depois de gerar o arquivo pré-processado, é uma boa ideia certificar-se de que o problema ainda se reproduz quando você compila o arquivo pré-processado.
Para confirmar que o arquivo pré-processado ainda reproduz o erro
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 em 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.
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
Crie um arquivo de origem pré-processado conforme descrito no arquivo Para pré-processar um arquivo de código-fonte.
Pesquise o arquivo nomedoarquivo.i gerado para diretivas #using.
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,
Crie um diretório para o arquivo pré-processado e copie-o para o novo diretório.
Copie os arquivos .winmd da lista #using para o novo diretório.
Crie um arquivo vccorlib.h vazio no novo diretório.
Edite o arquivo pré-processado para remover todas as diretivas #using para mscorlib.dll.
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
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.
Abra o Prompt de Comando do Desenvolvedor correspondente à arquitetura de versão e à configuração do Visual Studio usada para compilar o projeto.
Mude para o diretório que contém seu projeto de reprodução.
Na janela do console de prompt de comando do desenvolvedor, insira o comando cl /P arguments filename.cpp. Os argumentos são os argumentos capturados acima e filename.cpp é o nome do arquivo de origem que consome o módulo.
Altere para o diretório que contém o projeto de reprodução que criou a interface do módulo (a saída .ifc).
Capture os argumentos de linha de comando usados para criar sua interface de módulo.
Na janela do console de prompt de comando do desenvolvedor, insira o comando cl /P arguments modulename.ixx. Os argumentos são os argumentos capturados acima e modulename.ixx é o nome do arquivo que cria a interface de módulo.
Depois de gerar os arquivos pré-processados, é uma boa ideia certificar-se de que o problema ainda se reproduz quando você usa o arquivo pré-processado.
Para confirmar que o arquivo pré-processado ainda reproduz o erro
Na janela do console de prompt de comando do desenvolvedor, volte para o diretório que contém seu projeto de reprodução.
Digite o comando cl arguments /TP nomedoarquivo.i como acima, para compilar o arquivo pré-processado como se fosse um arquivo de origem em C++.
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 vinculação é o conteúdo gerado pelo vinculador de um diretório, especificado pela variável de ambiente link_repro ou como um argumento à opção do 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 aqueles necessários como entrada do vinculador para que o problema possa ser reproduzido. Uma reprodução de vinculação pode ser criada com facilidade 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 vinculação usando a variável de ambiente link_repro
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.
Abra o Prompt de Comando do Desenvolvedor correspondente à arquitetura de versão e à configuração do Visual Studio usada para compilar o projeto.
Na janela do console de prompt de comando do desenvolvedor, mude para o diretório que contém seu projeto de reprodução.
Digite mkdir linkrepro para criar um diretório chamado linkrepro para a reprodução de vinculação. Você pode usar um nome diferente para capturar outra reprodução de vinculação.
Digite o comando set link_repro=linkrepro para definir a variável de ambiente link_repro para o diretório que você criou. Se a compilação for executada a partir de um diretório diferente, o que geralmente ocorre em projetos mais complexos, defina link_repro como o caminho completo para o diretório de reprodução de vinculação.
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 Microsoft 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.
Compile seu projeto de reprodução e confirme se o problema esperado ocorreu.
Feche o Visual Studio se você o usou para executar a compilação.
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 compactando todo o diretório linkrepro em um arquivo .zip ou semelhante e anexe-o ao seu relatório.
A opção do vinculador /LINKREPRO tem o mesmo efeito que a variável de ambiente link_repro. É possível usar a opção /LINKREPROTARGET para especificar o nome a ser filtrado para a reprodução de vinculação gerada. Para usar /LINKREPROTARGET, também é necessário especificar a opção do vinculador /OUT.
Para gerar uma reprodução de vinculação usando a opção /LINKREPRO
Criar um diretório para manter a reprodução de vinculação. Referiremos ao caminho de diretório completo que você criar como caminho de diretório. Use aspas duplas ao redor do caminho se ele incluir espaços.
Adicione o comando /LINKREPRO:directory-path à linha de comando do vinculador. No Microsoft Visual Studio, abra a caixa de diálogo Páginas de Propriedades do seu projeto. Selecione a página de propriedades Propriedades da Configuração>Vinculador>Linha de Comando. Em seguida, insira a opção /LINKREPRO:directory-path na caixa Opções Adicionais. Escolha OK para salvar suas alterações.
Compile seu projeto de reprodução e confirme se o problema esperado ocorreu.
Por fim, empacote a reprodução compactando todo o diretório da reprodução de vinculação directory-path em um arquivo .zip ou semelhante e anexe-o ao seu relatório.
Outras reproduções
Se não for possível reduzir o problema a um único arquivo de origem ou reprodução pré-processada, e o problema não exigir uma reprodução de vinculação, poderemos investigar um projeto do IDE. Todas as diretrizes sobre como criar uma boa reprodução ainda se aplicam: o código deve ser mínimo e independente. 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 a ferramenta para relatar um problema interna do Microsoft Visual Studio ou a página Visual Studio Developer Community. 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.
Observação
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. É exibido 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á-la na barra de menus em Ajuda>Enviar Comentários>Relatar um Problema.
Ao escolher relatar um problema, pesquise primeiro na Comunidade de Desenvolvedores para tentar encontrar problemas semelhantes. Caso seu problema já tenha sido relatado antes, vote no relatório e adicione comentários com mais especificações. 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 da Developer Community sobre Microsoft Visual Studio, Visual Studio para Mac, .NET, C++, Azure DevOps e 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 em que entrar, você deverá concordar em conceder ao aplicativo da Visual Studio Developer Community acesso ao seu perfil.
Para problemas com o compilador, vinculador e outras ferramentas e bibliotecas do C++, primeiro pesquise na página Developer Community C++. Se você pesquisar seu problema e ele ainda não tiver sido relatado, 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.
Dica
As informações no relatório inicial da Visual Studio Developer Community serão sempre públicas. Se isso for uma preocupação, consulte a próxima seção sobre Relatórios e privacidade.
Dica
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. Essa é a melhor opção, devido aos recursos de captura de tela e à capacidade de registrar as ações da interface do usuário que levam ao problema encontrado. Esses tipos de erros também podem ser pesquisados no site da Developer Community do Microsoft Visual Studio. Para saber mais, 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 particular 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
No relatório que você criou, escolha Adicionar comentário para criar sua descrição privada do problema.
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 cartaz original para limitar a visibilidade aos funcionários da Microsoft e a você mesmo.
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 no GitHub diretamente de uma página de conteúdo, o que permite interagir de maneira mais rica 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ê precisa criar uma conta no GitHub se ainda não tiver 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 nossa entrada de blog Sistema de Comentários.
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.