Como relatar um problema com o conjunto de ferramentas ou documentação do Microsoft C++

Se você encontrar problemas no compilador Microsoft C++ (MSVC), no vinculador ou em outras ferramentas e bibliotecas, queremos 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 C++

A melhor maneira de nos informar sobre um problema é enviar-nos um relatório que inclua uma descrição do problema descoberto. Ele deve ter todos os detalhes sobre como você constrói seu programa. E deve incluir um de reprodução, um caso de teste completo que podemos usar para reproduzir o problema em nossas próprias máquinas. Essas informações nos permitem verificar rapidamente se o problema existe em nosso código e não é local para seu ambiente. Ele nos ajuda a determinar se ele afeta outras versões do compilador e a diagnosticar sua 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 encontrado e como enviar seu relatório para a equipe de produto. Seus 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 o seu relatório

É importante criar um relatório de alta qualidade, porque é difícil para nós reproduzir o problema encontrado sem informações completas. Quanto melhor for o seu relatório, mais eficazmente poderemos recriar e diagnosticar o problema.

No mínimo, o relatório deve conter:

• As informações da versão completa do conjunto de ferramentas que você está usando.

• A linha de comando completa de cl.exe usada para criar o seu código.

• Uma descrição detalhada do problema encontrado.

• Um repro: 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 de que precisamos e onde você pode encontrá-las, e como criar um bom repro.

A versão do conjunto de ferramentas

Precisamos das informações da versão completa e da arquitetura de destino do conjunto de ferramentas que causa o problema. Isso é para que possamos testar sua reprodução com o mesmo conjunto de ferramentas em nossas máquinas. Se pudermos reproduzir o problema, essas informações também nos dã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 do seu compilador

1. Abra o Prompt de Comando do Desenvolvedor que corresponde à versão do Visual Studio e à arquitetura de configuração usada para criar seu projeto. Por exemplo, se você compilar usando o Visual Studio 2017 em x64 para destinos x64, escolha Prompt de Comando de Ferramentas Nativas x64 para VS 2017. Para obter mais informações, consulte Atalhos do prompt de comando do desenvolvedor.

2. Na janela do console do prompt de comando do desenvolvedor, digite o comando cl /Bv.

A saída deve ser semelhante a:

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 todo o conteúdo no relatório.

A linha de comando

Precisamos da linha de comando exata, cl.exe e todos os seus argumentos, usados para construir seu código. Isso é para que possamos construí-lo exatamente da mesma maneira em nossas máquinas. É importante porque o problema encontrado pode existir apenas ao construir com um determinado argumento ou combinação de argumentos.

O melhor lugar para encontrar esta informação é no log de compilação imediatamente após passar pelo problema. Ele 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 na pasta Documentos em \Visual Studio versão\Projects\SolutionName\ProjectName\Configuration\ProjectName.tlog\CL.command.1.tlog, ou na pasta User 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 você alterou o local padrão para seu projeto.

   Dentro desse arquivo, localize os nomes dos arquivos de 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 contém os argumentos de comando cl.exe correspondentes.

Copie e cole toda a linha de comando no relatório.

Uma descrição do problema

Precisamos de uma descrição detalhada do problema encontrado. Isso é para que possamos verificar se vemos o mesmo efeito em nossas máquinas. Às vezes, também é útil para nós saber o que você estava tentando realizar e o que esperava que acontecesse.

Uma boa descrição fornece as mensagens de erro exatas fornecidas pelo conjunto de ferramentas ou o comportamento exato de tempo de execução que você vê. Precisamos destas informações para verificar se reproduzimos corretamente a questão. Inclua todos os da saída do compilador, não apenas a última mensagem de erro. Precisamos de ver tudo o que levou à questão que relata. Se você puder duplicar o problema usando o compilador de linha de comando, essa saída do compilador é preferível. O IDE e outros sistemas de compilação podem filtrar as mensagens de erro que você vê ou capturar apenas a primeira linha de uma mensagem de erro.

Se o problema for que o compilador aceita código inválido e não gera um diagnóstico, inclua isso no relatório.

Para relatar um problema de comportamento de tempo de execução, inclua uma cópia exata do que o programa imprime e o que você espera ver. Idealmente, incorpore-o na própria instrução de saída, por exemplo, printf("This should be 5: %d\n", actual_result);. Se o seu programa falhar ou travar, mencione isso também.

Adicione quaisquer outros detalhes que possam nos ajudar a diagnosticar o problema encontrado, como quaisquer soluções alternativas descobertas. Tente não repetir informações encontradas em outro lugar do seu relatório.

A reprodução

Um repro é um exemplo completo e independente de código-fonte. Ele demonstra reprodutivelmente o problema que você encontrou, daí o nome. Precisamos de uma reprodução para que possamos reproduzir o erro em nossas máquinas. O código deve ser suficiente por si só para criar um executável básico que compila e executa. Ou, que iria compilar e executar, se não fosse pelo problema que encontrou. Uma reprodução não é um trecho de código. Ele deve ter funções e classes completas, e conter todas as diretivas de #include necessárias, mesmo para os cabeçalhos padrão.

O que faz uma boa reprodução

Uma boa reprodução é:

• Mínimo. As reproduções devem ser tão pequenas quanto possível, mas devem ainda assim demonstrar exatamente o problema encontrado. Os repros não precisam ser complexos ou realistas. Eles só precisam mostrar o código que está em conformidade com o padrão ou com a implementação documentada do compilador. Para um diagnóstico ausente, sua reprodução deve mostrar o código que não está em conformidade. Reproduções simples e pontuais que contêm apenas código suficiente para demonstrar o problema são as melhores. Se você puder eliminar ou simplificar o código e permanecer em conformidade, e também deixar o problema inalterado, então faça isso. Você não precisa incluir contraexemplos de código que funciona.

• Autossuficiente. Os reprodutores devem evitar dependências desnecessárias. Se você puder reproduzir o problema sem bibliotecas de terceiros, faça-o. Se você puder reproduzir o problema sem qualquer 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);), então faça isso. É ideal se o exemplo puder 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 temos que considerar como um possível contribuinte para o problema é extremamente útil para nós.

• Contra a versão mais recente do compilador. Os relatórios devem usar a atualização mais recente do conjunto de ferramentas, sempre que possível. Ou use a versão de pré-lançamento mais recente 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 retroportadas para versões mais antigas apenas em circunstâncias excecionais.

• Verificado em relação a outros compiladores se aplicável. Repros que envolvem código C++ portátil devem verificar o comportamento em relação a outros compiladores, se possível. Em última análise, o padrão C++ determina a correção do programa, e nenhum compilador é perfeito. No entanto, quando Clang e GCC aceitam seu código sem um diagnóstico, e 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.) 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 para testar o seu código, como em compiladores C++ online no site ISO C++, ou na lista de compiladores C++ online com curadoria no GitHub. Alguns exemplos específicos incluem Wandbox e Compiler Explorer.

  Observação

  Os sites de compiladores online não são afiliados com a Microsoft. Muitos sites de compiladores on-line são executados como projetos pessoais. Alguns desses sites podem estar indisponíveis quando você lê isso, mas uma pesquisa deve encontrar outros que você pode usar.

Problemas no compilador, linker e nas bibliotecas, tendem a se mostrar de maneiras particulares. O tipo de problema que encontrar determinará que tipo de reprodução deve incluir no seu relatório. Sem uma prova adequada, não temos nada a investigar. Aqui estão alguns dos tipos de problemas que você pode ver. Incluímos instruções sobre como gerar o tipo de reprodução que você deve usar para relatar cada tipo de problema.

Falha de frontend (analisador)

Falhas de frontend ocorrem durante a fase de análise do compilador. Normalmente, o compilador emite Erro fatal C1001e faz referência ao arquivo de código-fonte e ao número da linha na qual o erro ocorreu. Ele geralmente menciona um arquivo chamado msc1.cpp, mas você pode ignorar esse detalhe.

Para este tipo de erro, forneça uma repro pré-processada.

Aqui está um 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)

Falhas de back-end ocorrem durante a fase de geração de código do compilador. Normalmente, o compilador emite Erro fatal C1001e pode não fazer referência ao arquivo de código-fonte e ao número da linha associados ao problema. Ele geralmente menciona o compilador de arquivo\utc\src\p2\main.c, mas você pode ignorar esse detalhe.

Para esse tipo de falha, forneça um Link repro se você estiver usando LTCG (Link-Time Code Generation), habilitado pelo argumento de linha de comando /GL para cl.exe. Caso contrário, forneça uma reprodução pré-processada .

Aqui está um exemplo de saída do compilador para uma falha de back-end na qual o LTCG não é usado. Se a saída do compilador for semelhante à seguinte, você deve fornecer um de 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 ERRO INTERNO DO COMPILADOR mencionar link.exe, em vez de cl.exe, o LTCG foi habilitado. Forneça um repro de Link neste caso. Quando não estiver claro se o LTCG foi habilitado a partir da mensagem de erro do compilador, examine os argumentos da linha de comando. Você copiou-os do registo de compilação, num passo anterior para o argumento da linha de comandos /GL.

Falha do vinculador

As falhas do vinculador ocorrem durante a fase de vinculação, após a execução do compilador. Normalmente, o vinculador emite Linker Tools Error LNK1000.

Para este tipo de falha, forneça um Link repro.

Aqui está um exemplo de saída do compilador 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 estiver habilitada e a falha tiver ocorrido somente após um link inicial bem-sucedido, ou seja, somente após o primeiro link completo no qual um link incremental posterior se baseia, forneça também uma cópia dos arquivos de objeto (.obj) e biblioteca (.lib) que correspondem aos arquivos de origem modificados após a conclusão do link inicial.

Geração de código incorreto

A geração de código incorreto é rara. Ocorre quando o compilador gera por engano código incorreto que faz com que seu aplicativo falhe em tempo de execução. Em vez disso, ele deve gerar o código correto ou detetar um problema em tempo de compilação. Se você acredita que o problema encontrado resulta na geração de código incorreto, trate seu relatório da mesma forma que um Back-end (geração de código).

Para este tipo de falha, forneça um Link repro se estiver a utilizar o argumento de linha de comandos /GL para cl.exe. Forneça uma reprodução pré-processada , caso contrário.

Como gerar uma reprodução

Para nos ajudar a localizar a origem do problema, um bom repro é vital. Antes de executar qualquer uma das etapas descritas abaixo para tipos específicos de repros, 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 instruções para gerar os vários tipos de repros a utilizar para relatar diferentes problemas.

Reproduções pré-processadas

Um de reprodução pré-processado é um único arquivo de origem que demonstra um problema. É gerado a partir da saída do pré-processador C. Para criar um, use a opção de compilador /P no arquivo de origem de reprodução original. Esta opção incorpora os cabeçalhos incluídos para remover dependências de outros arquivos de origem e cabeçalho. A opção também resolve macros, condicionais #ifdef e outros comandos do pré-processador que possam depender do seu ambiente local.

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.

2. Abra o Prompt de Comando do Desenvolvedor correspondente à versão do Visual Studio e à arquitetura de configuração usada para criar o seu projeto.

3. Mude para o diretório que contém seu projeto de reprodução.

4. Na janela do console do prompt de comando do desenvolvedor, digite o comando argumentos cl /Pfilename.cpp. Para argumentos, utilize a lista de argumentos que você capturou anteriormente. filename.cpp é o nome do seu arquivo de origem de reprodução. Este comando replica a linha de comando usada para o repro, mas interrompe a compilação após a passagem do pré-processador. Em seguida, ele grava o código-fonte pré-processado para filename.i.

Se você estiver pré-processando um arquivo de código-fonte C++/CX ou estiver usando o recurso Módulos C++, mais algumas etapas serão necessárias. Para obter mais informações, consulte as seções abaixo.

Depois de gerar o arquivo pré-processado, é uma boa idéia certificar-se de que o problema ainda se reproduz quando você compila o arquivo pré-processado.

Para confirmar que o ficheiro pré-processado ainda reproduz o erro

1. Na janela do console do prompt de comando do desenvolvedor, digite o comando clargumentos/TPfilename.i para instruir cl.exe a compilar o ficheiro pré-processado como um ficheiro C++. Os argumentos são os mesmos argumentos capturados acima, mas com quaisquer argumentos /D e /I removidos. Isso porque eles já foram incluídos no arquivo pré-processado. filename.i é o nome do seu ficheiro pré-processado.

2. Confirme se o problema foi reproduzido.

Por fim, anexe o ficheiro preprocessado de reprodução com o nome.i ao seu relatório.

Reproduções de código C++/CX WinRT/UWP pré-processadas

Se você estiver usando C++/CX para criar seu executável, há algumas etapas adicionais necessárias para criar e validar uma reprodução pré-processada.

Para pré-processar o código-fonte C++/CX

1. Crie um arquivo de origem pré-processado conforme descrito em Para pré-processar um arquivo de código-fonte.

2. Procure no arquivo .i do nome do arquivo geradopor diretivas #using.

3. Faça uma lista de todos os arquivos referenciados. Deixe de fora quaisquer ficheiros Windows*.winmd, ficheiros platform.winmd e mscorlib.dll.

Para se preparar para validar que o arquivo pré-processado ainda reproduz o problema,

1. Crie um novo diretório para o arquivo pré-processado e copie-o para o novo diretório.

2. Copie os arquivos .winmd da sua lista de #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 quaisquer caminhos absolutos para apenas os nomes de arquivos simples para os arquivos .winmd copiados.

Confirme se o arquivo pré-processado ainda reproduz o problema, como acima.

Reproduções de módulos C++ pré-processados

Se você estiver usando o recurso Módulos do compilador C++, há algumas etapas diferentes 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

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.

2. Abra o Prompt de Comando do Desenvolvedor que corresponde à versão do Visual Studio e à arquitetura de configuração usada para criar seu projeto.

3. Mude para o diretório que contém seu projeto de reprodução.

4. Na janela do console do prompt de comando do desenvolvedor, digite o comando argumentos cl /Pfilename.cpp. Os argumentos são os argumentos capturados acima, e filename.cpp é o nome do arquivo de origem que consome o módulo.

5. Mude para o diretório que contém o projeto repro que criou a interface do módulo (a saída .ifc).

6. Capture os argumentos de linha de comando usados para criar a interface do módulo.

7. Na janela do console do prompt de comando do desenvolvedor, digite o comando cl /Pargumentosmodulename.ixx. Os argumentos são os argumentos capturados acima, e modulename.ixx é o nome do arquivo que cria a interface do módulo.

Depois de gerar os arquivos pré-processados, é uma boa ideia certificar-se de que o problema ainda se repete quando se usarem os arquivos pré-processados.

Para confirmar que o arquivo pré-processado ainda reproduz o erro

1. Na janela do console do desenvolvedor, volte para o diretório que contém seu projeto repro.

2. Digite o comando clargumentos/TPnome do arquivo.i como acima, para compilar o arquivo pré-processado como se fosse um arquivo de origem C++.

3. Confirme se o problema ainda é reproduzido pelo arquivo pré-processado.

Finalmente, anexe os arquivos de reprodução pré-processados (nome do arquivo.i e nome do módulo.i) juntamente com a saída .ifc ao seu relatório.

Reproduções de links

Um link repro é o conteúdo gerado pelo linker de um diretório, especificado pela variável de ambiente link_repro ou como um argumento para a opção de linker /LINKREPRO. Ele contém artefatos de construção que demonstram coletivamente um problema que ocorre no momento do link. Exemplos incluem uma falha de back-end envolvendo Link-Time Code Generation (LTCG) ou uma falha de vinculador. Esses artefatos de construção são os necessários como entrada do vinculador para que o problema possa ser reproduzido. Uma reprodução de link pode ser criada facilmente usando esta variável de ambiente. Ele permite a capacidade de geração de reprodução integrada do vinculador.

Para gerar uma reprodução de link usando a variável de ambiente link_repro

1. Capture os argumentos de linha de comando usados para criar a sua repro, como descrito em para reportar o conteúdo da linha de comando.

2. Abra o Prompt de Comando do Desenvolvedor que corresponde à versão do Visual Studio e à arquitetura de configuração usada para criar seu projeto.

3. Na janela do console do prompt de comando do desenvolvedor, mude para o diretório que contém seu projeto repro.

4. Digite mkdir linkrepro para criar um diretório chamado linkrepro para o link repro. Você pode usar um nome diferente para capturar outro link repro.

5. Digite o comando definir link_repro=linkrepro para definir a variável de ambiente link_repro para o diretório que você criou. Se a sua compilação for executada a partir de um diretório diferente, como frequentemente é o caso para projetos mais complexos, defina link_repro como o caminho completo para o seu diretório de reprodução de link.

6. Para criar o projeto repro no Visual Studio, na janela do console do prompt de comando do desenvolvedor, digite o comando devenv. Ele garante que o valor da variável de ambiente link_repro seja visível para o Visual Studio. Para criar o projeto na linha de comando, use os argumentos de linha de comando capturados acima para duplicar a compilação de reprodução.

7. Crie seu projeto de reprodução e confirme se o problema esperado ocorreu.

8. Feche o Visual Studio, se você o usou para fazer a compilação.

9. Na janela do console do prompt de comando do desenvolvedor, digite o comando definir link_repro= para limpar a variável de ambiente link_repro.

Finalmente, empacote o repro compactando todo o diretório linkrepro em um arquivo .zip ou similar e anexe-o ao seu relatório.

A opção /LINKREPRO linker tem o mesmo efeito que a variável de ambiente link_repro. Você pode usar a opção /LINKREPROTARGET para especificar o nome a ser filtrado para a reprodução de link gerada. Para usar /LINKREPROTARGET, você também deve especificar a opção de linker /OUT.

Para gerar um link repro usando a opção /LINKREPRO

1. Crie um diretório para manter o link repro. Vamos referir-nos ao caminho completo do diretório que você cria como caminho de diretório. Use aspas duplas ao redor do caminho se ele incluir espaços.

2. Adicione o comando /LINKREPRO:directory-path à linha de comando do linker. No Visual Studio, abra o diálogo Property Pages do seu projeto. Selecione a página de propriedades Configuration Properties>Linker>Command Line. Em seguida, digite a opção /LINKREPRO:directory-path na caixa Opções Adicionais. Escolha OK para salvar as alterações.

3. Crie seu projeto de reprodução e confirme se o problema esperado ocorreu.

Finalmente, empacote o repro compactando todo o caminho do diretório vincule o diretório repro em um arquivo .zip ou similar e anexe-o ao seu relatório.

Outras reproduções

Caso não seja possível reduzir o problema a um único ficheiro de origem ou representação pré-processada, nem requeira uma representação de links, podemos investigar um projeto no IDE. Todas as orientações sobre como criar um bom repro ainda se aplicam: o código deve ser mínimo e autossuficiente. O problema deve ocorrer em nossas ferramentas mais recentes e, se relevante, não deve ser visto em outros compiladores.

Crie seu repro como um projeto IDE mínimo, empacote-o compactando toda a estrutura de diretórios em um arquivo .zip ou similar e anexe-o ao seu relatório.

Formas de enviar a denúncia

Você tem algumas boas maneiras de fazer seu relatório chegar até nós. Você pode usar a ferramenta interna de relatório de problemas do Visual Studio ou a página da Comunidade de Desenvolvedores do Visual Studio. Há também um botão de feedback do produto na parte inferior desta página. A escolha depende se você deseja usar as ferramentas internas no IDE para capturar capturas de tela e organizar seu relatório. Se preferir não fazê-lo, você pode usar o site da Comunidade de Desenvolvedores diretamente.

Utilizar a ferramenta Comunicar um problema

A ferramenta Report a Problem no Visual Studio é uma maneira de os usuários do Visual Studio relatarem problemas com apenas alguns cliques. Aparece um formulário simples para enviar informações detalhadas sobre o problema encontrado. Em seguida, você pode enviar seu relatório sem sair do IDE.

Relatar seu problema através da ferramenta Report a Problem é fácil e conveniente a partir do IDE. Você pode aceder a ele 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>Relatar um problema.

Quando você optar por relatar um problema, primeiro pesquise problemas semelhantes na Comunidade de desenvolvedores. Caso o seu problema tenha sido relatado antes, vote o relatório e adicione comentários com mais detalhes. Se você não vir um problema semelhante, escolha o botão Relatar novo problema 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 conveniente de relatar problemas e encontrar soluções para o Visual Studio e o compilador, as ferramentas e as bibliotecas do C++. Há páginas específicas da Comunidade de Desenvolvedores para Visual Studio, Visual Studio para Mac, .NET, C++, Azure DevOpse Azure DevOps Server.

Abaixo das abas da comunidade, perto da parte superior de cada página, há uma caixa de pesquisa. Você pode usá-lo para encontrar postagens que relatam problemas semelhantes ao seu. Pode encontrar uma solução ou outras informações úteis relacionadas com o seu problema já estão disponíveis. Se alguém já tiver relatado o mesmo problema antes, então vote favoravelmente e comente esse relatório, em vez de criar um novo relatório de problema. Para comentar, votar ou relatar um novo problema, você pode ser solicitado a entrar em sua conta do Visual Studio. Na primeira vez que iniciar sessão, tem de concordar em conceder à aplicação da Comunidade de Programadores acesso ao seu perfil.

Para problemas com o compilador, o ligador e outras ferramentas e bibliotecas do C++, primeiro pesquise na página C++ Developer Community. Se você pesquisar o problema e ele ainda não tiver sido relatado, escolha o botão Comunicar um problema ao lado da caixa de pesquisa. Você pode incluir seu código de reprodução e linha de comando, capturas de tela, links para discussões relacionadas e qualquer outra informação que considere relevante e útil.

Relatórios e privacidade

Todas as informações contidas em relatórios e quaisquer comentários e respostas são publicamente visíveis por padrão. Normalmente, é um benefício, porque permite que toda a comunidade veja os problemas, soluções e soluções alternativas que outros usuários encontraram. No entanto, se estiver preocupado em tornar os seus dados ou identidade públicos, por motivos de privacidade ou propriedade intelectual, tem opções.

Se estiver preocupado em revelar a sua identidade, criar uma nova conta Microsoft que não divulgue quaisquer detalhes sobre si. Utilize esta conta para criar o seu relatório.

Não coloque nada que queira manter privado 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 garantir que seu relatório seja direcionado para as pessoas certas, inclua cppcompiler na lista de tópicos do seu relatório de problemas. Depois que o relatório de problemas é criado, agora é possível especificar quem pode ver suas respostas e anexos.

Para criar um relatório de problemas para informações privadas

1. No relatório que criou, escolha Adicionar comentário para criar a sua descrição privada do problema.

2. No editor de respostas, use o menu pendente abaixo dos botões Enviar e Cancelar para especificar o público da sua resposta. Somente as pessoas especificadas podem ver essas respostas privadas e quaisquer imagens, links ou códigos incluídos nelas. Escolha Visível pelos moderadores e o cartaz original para limitar a visibilidade aos funcionários da Microsoft e a si próprio.

3. Adicione a descrição e quaisquer outras informações, imagens e anexos de arquivo necessários para sua reprodução. Escolha o botão Enviar para enviar essas informações de forma privada.

   Há um limite de 2 GB de arquivos anexados e um máximo de 10 arquivos. Para carregamentos maiores, solicite um URL de upload no seu comentário privado.

Todas as respostas sob este comentário têm a mesma visibilidade restrita que você especificou. É verdade, mesmo que o menu pendente nas respostas não apresente corretamente o estado de visibilidade restrita.

Para manter a sua privacidade e manter as suas informações confidenciais fora da vista do público, tenha cuidado. Mantenha toda a interação com a Microsoft nas respostas sob o comentário restrito. As respostas a outros comentários podem levá-lo a divulgar acidentalmente informações confidenciais.

Como relatar um problema de documentação C++

Usamos problemas do GitHub para rastrear problemas relatados em nossa documentação. Agora você pode criar problemas do GitHub diretamente de uma página de conteúdo, o que permite que você interaja de maneira mais rica com escritores e equipes de produto. Se vir um problema com um documento, um exemplo de código incorreto, uma explicação confusa, uma omissão crítica ou até mesmo apenas um erro de digitação, você pode facilmente nos informar. Desloque-se para a parte inferior da página e selecione Iniciar sessão para fornecer comentários sobre a documentação. Você precisa criar uma conta no GitHub se ainda não tiver uma. Quando você tem uma conta no GitHub, você pode ver todos os nossos problemas de documentação e seu status. Você também recebe notificações quando são feitas alterações para o problema relatado. Para obter mais informações, consulte nossa entrada de blog Feedback System.

Você cria um problema de documentação no GitHub quando usa o botão de feedback da documentação. O problema é preenchido automaticamente com algumas informações sobre a página em que você criou o problema. É assim que sabemos onde o problema está localizado, por isso não edite esta informação. Basta anexar os detalhes sobre o que está errado e, se quiser, uma correção sugerida. Os nossos documentos C++ sãode código aberto, portanto, se quiseres enviar uma correção por ti próprio, podes. Para obter mais informações sobre como você pode contribuir com nossa documentação, consulte nosso guia de contribuição no GitHub.