Como faço para imprimir na janela de saída de depuração em um aplicativo Win32?

Eu tenho um projeto win32 que carreguei no Visual Studio 2005. Gostaria de poder imprimir coisas na janela de saída do Visual Studio, mas não consigo descobrir como. Eu tentei 'printf' e 'cout <<', mas minhas mensagens permanecem teimosamente não impressas.

Existe algum tipo de maneira especial de imprimir na janela de saída do Visual Studio?

Você pode usar OutputDebugString. OutputDebugStringé uma macro que, dependendo das opções de construção, mapeia para OutputDebugStringA(char const*)ou OutputDebugStringW(wchar_t const*). No último caso, você terá que fornecer uma ampla cadeia de caracteres para a função. Para criar um literal de caractere largo, você pode usar o Lprefixo:

OutputDebugStringW(L"My output string.");

Normalmente, você usará a versão macro junto com a _Tmacro, como este:

OutputDebugString(_T("My output string."));

Se o seu projeto estiver configurado para construir para UNICODE, ele se expandirá para:

OutputDebugStringW(L"My output string.");

Se você não estiver construindo para UNICODE, ele se expandirá para:

OutputDebugStringA("My output string.");

Se o projeto for um projeto GUI, nenhum console aparecerá. Para transformar o projeto em um console, você precisa ir ao painel de propriedades do projeto e definir:

• Em " vinculador-> Sistema-> Subsistema ", o valor " Console (/ SUBSISTEMA: CONSOLE) "
• Em " C / C ++ -> Pré-processador-> Definições de pré-processador " adicione o " definição " _CONSOLE "

Esta solução funciona apenas se você tiver o clássico " ponto de entrada int main () ".

Mas se você for como no meu caso (um projeto openGL), você não precisa editar as propriedades, pois funciona melhor:

AllocConsole();
freopen("CONIN$", "r",stdin);
freopen("CONOUT$", "w",stdout);
freopen("CONOUT$", "w",stderr);

printf e cout funcionarão normalmente.

Se você chamar AllocConsole antes da criação de uma janela, o console aparecerá atrás da janela, se você chamá-lo depois, ele aparecerá à frente.

Atualizar

freopenestá obsoleto e pode não ser seguro. Use em seu freopen_slugar:

FILE* fp;

AllocConsole();
freopen_s(&fp, "CONIN$", "r", stdin);
freopen_s(&fp, "CONOUT$", "w", stdout);
freopen_s(&fp, "CONOUT$", "w", stderr);

Para imprimir no realconsole, você precisa torná-lo visível usando o sinalizador do vinculador /SUBSYSTEM:CONSOLE. A janela extra do console é irritante, mas para fins de depuração é muito valiosa.

OutputDebugString imprime na saída do depurador ao executar dentro do depurador.

Considere o uso de macros de tempo de execução VC ++ para Reporting _RPT N () e _RPTF N ()

Você pode usar as macros _RPTn e _RPTFn, definidas em CRTDBG.H, para substituir o uso de instruções printf para depuração. Essas macros desaparecem automaticamente em sua versão de lançamento quando _DEBUG não é definido, portanto, não há necessidade de incluí-las em #ifdefs.

Exemplo...

if (someVar > MAX_SOMEVAR) {
    _RPTF2(_CRT_WARN, "In NameOfThisFunc( )," 
         " someVar= %d, otherVar= %d\n", someVar, otherVar );
}

Ou você pode usar as funções de tempo de execução do VC ++ _CrtDbgReport, _CrtDbgReportW diretamente.

_CrtDbgReport e _CrtDbgReportW podem enviar o relatório de depuração para três destinos diferentes: um arquivo de relatório de depuração, um monitor de depuração (o depurador do Visual Studio) ou uma janela de mensagem de depuração.

_CrtDbgReport e _CrtDbgReportW criam a mensagem do usuário para o relatório de depuração substituindo os argumentos argumento [n] na string de formato, usando as mesmas regras definidas pelas funções printf ou wprintf. Essas funções geram o relatório de depuração e determinam o destino ou destinos, com base nos modos de relatório atuais e no arquivo definido para reportType. Quando o relatório é enviado para uma janela de mensagem de depuração, o nome do arquivo, lineNumber e moduleName são incluídos nas informações exibidas na janela.

Se você deseja imprimir variáveis ​​decimais:

wchar_t text_buffer[20] = { 0 }; //temporary buffer
swprintf(text_buffer, _countof(text_buffer), L"%d", your.variable); // convert
OutputDebugString(text_buffer); // print

Se você precisar ver a saída de um programa existente que usou extensivamente printf sem alterar o código (ou com alterações mínimas), você pode redefinir printf como segue e adicioná-lo ao cabeçalho comum (stdafx.h).

int print_log(const char* format, ...)
{
    static char s_printf_buf[1024];
    va_list args;
    va_start(args, format);
    _vsnprintf(s_printf_buf, sizeof(s_printf_buf), format, args);
    va_end(args);
    OutputDebugStringA(s_printf_buf);
    return 0;
}

#define printf(format, ...) \
        print_log(format, __VA_ARGS__)

Seu projeto Win32 é provavelmente um projeto de GUI, não um projeto de console. Isso causa uma diferença no cabeçalho executável. Como resultado, seu projeto de GUI será responsável por abrir sua própria janela. Isso pode ser uma janela de console, no entanto. Chame AllocConsole()para criá-lo e use as funções do console Win32 para gravá-lo.

Eu estava procurando uma maneira de fazer isso sozinho e descobri uma solução simples.

Presumo que você tenha iniciado um projeto Win32 padrão (aplicativo do Windows) no Visual Studio, que fornece uma função "WinMain". Por padrão, o Visual Studio define o ponto de entrada como "SUBSYSTEM: WINDOWS". Você precisa primeiro alterar isso indo para:

Projeto -> Propriedades -> Vinculador -> Sistema -> Subsistema

E selecione "Console (/ SUBSYSTEM: CONSOLE)" na lista suspensa.

Agora, o programa não será mais executado, pois uma função "principal" é necessária em vez da função "WinMain".

Portanto, agora você pode adicionar uma função "principal" como faria normalmente em C ++. Depois disso, para iniciar o programa GUI, você pode chamar a função "WinMain" de dentro da função "principal".

A parte inicial do seu programa deve ser semelhante a esta:

#include <iostream>

using namespace std;

// Main function for the console
int main(){

    // Calling the wWinMain function to start the GUI program
    // Parameters:
    // GetModuleHandle(NULL) - To get a handle to the current instance
    // NULL - Previous instance is not needed
    // NULL - Command line parameters are not needed
    // 1 - To show the window normally
    wWinMain(GetModuleHandle(NULL), NULL,NULL, 1); 

    system("pause");
    return 0;
}

// Function for entry into GUI program
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    // This will display "Hello World" in the console as soon as the GUI begins.
    cout << "Hello World" << endl;
.
.
.

Resultado da minha implementação

Agora você pode usar funções de saída para o console em qualquer parte de seu programa GUI para depuração ou outros fins.

Você também pode usar o método WriteConsole para imprimir no console.

AllocConsole();
LPSTR lpBuff = "Hello Win32 API";
DWORD dwSize = 0;
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), lpBuff, lstrlen(lpBuff), &dwSize, NULL);