Comment imprimer dans la fenêtre de sortie de débogage dans une application Win32?

J'ai un projet win32 que j'ai chargé dans Visual Studio 2005. J'aimerais pouvoir imprimer des éléments dans la fenêtre de sortie de Visual Studio, mais je ne peux pas pour la vie de moi savoir comment. J'ai essayé 'printf' et 'cout <<' mais mes messages restent obstinément non imprimés.

Existe-t-il une manière spéciale d'imprimer dans la fenêtre de sortie de Visual Studio?

Vous pouvez utiliser OutputDebugString. OutputDebugStringest une macro qui, en fonction de vos options de construction, correspond à OutputDebugStringA(char const*)ou OutputDebugStringW(wchar_t const*). Dans ce dernier cas, vous devrez fournir une large chaîne de caractères à la fonction. Pour créer un littéral de caractère large, vous pouvez utiliser le Lpréfixe:

OutputDebugStringW(L"My output string.");

Normalement, vous utiliserez la version macro avec la _Tmacro comme ceci:

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

Si votre projet est configuré pour construire pour UNICODE, il se développera en:

OutputDebugStringW(L"My output string.");

Si vous ne construisez pas pour UNICODE, il se développera en:

OutputDebugStringA("My output string.");

Si le projet est un projet GUI, aucune console n'apparaîtra. Pour changer le projet en une console, vous devez aller dans le panneau des propriétés du projet et définir:

• Dans " linker-> System-> SubSystem ", la valeur " Console (/ SUBSYSTEM: CONSOLE) "
• Dans " C / C ++ -> Preprocessor-> Preprocessor Definitions ", ajoutez la définition " _CONSOLE "

Cette solution ne fonctionne que si vous aviez le point d'entrée classique " int main () ".

Mais si vous êtes comme dans mon cas (un projet openGL), vous n'avez pas besoin de modifier les propriétés, car cela fonctionne mieux:

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

printf et cout fonctionneront comme d'habitude.

Si vous appelez AllocConsole avant la création d'une fenêtre, la console apparaîtra derrière la fenêtre, si vous l'appelez après, elle apparaîtra en avant.

Mettre à jour

freopenest obsolète et peut être dangereux. Utilisez à la freopen_splace:

FILE* fp;

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

Pour imprimer sur la realconsole, vous devez le rendre visible à l'aide de l'indicateur de l'éditeur de liens /SUBSYSTEM:CONSOLE. La fenêtre de console supplémentaire est ennuyeuse, mais à des fins de débogage, elle est très précieuse.

OutputDebugString imprime sur la sortie du débogueur lors de l'exécution à l'intérieur du débogueur.

Envisagez d'utiliser les macros d'exécution VC ++ pour Reporting _RPT N () et _RPTF N ()

Vous pouvez utiliser les macros _RPTn et _RPTFn, définies dans CRTDBG.H, pour remplacer l'utilisation d'instructions printf pour le débogage. Ces macros disparaissent automatiquement dans votre version de version lorsque _DEBUG n'est pas défini, il n'est donc pas nécessaire de les enfermer dans #ifdefs.

Exemple...

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

Ou vous pouvez utiliser les fonctions d'exécution VC ++ _CrtDbgReport, _CrtDbgReportW directement.

_CrtDbgReport et _CrtDbgReportW peuvent envoyer le rapport de débogage vers trois destinations différentes: un fichier de rapport de débogage, un moniteur de débogage (le débogueur Visual Studio) ou une fenêtre de message de débogage.

_CrtDbgReport et _CrtDbgReportW créent le message utilisateur pour le rapport de débogage en substituant l'argument [n] arguments dans la chaîne de format, en utilisant les mêmes règles définies par les fonctions printf ou wprintf. Ces fonctions génèrent ensuite le rapport de débogage et déterminent la ou les destinations, en fonction des modes de rapport actuels et du fichier défini pour reportType. Lorsque le rapport est envoyé à une fenêtre de message de débogage, le nom de fichier, lineNumber et moduleName sont inclus dans les informations affichées dans la fenêtre.

Si vous souhaitez imprimer des variables décimales:

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

Si vous avez besoin de voir la sortie d'un programme existant qui a largement utilisé printf sans changer le code (ou avec des changements minimes), vous pouvez redéfinir printf comme suit et l'ajouter à l'en-tête commun (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__)

Votre projet Win32 est probablement un projet GUI, pas un projet de console. Cela provoque une différence dans l'en-tête de l'exécutable. En conséquence, votre projet GUI sera responsable de l'ouverture de sa propre fenêtre. Cela peut être une fenêtre de console, cependant. Appelez AllocConsole()pour le créer et utilisez les fonctions de la console Win32 pour y écrire.

Je cherchais un moyen de le faire moi-même et j'ai trouvé une solution simple.

Je suppose que vous avez démarré un projet Win32 par défaut (application Windows) dans Visual Studio, qui fournit une fonction "WinMain". Par défaut, Visual Studio définit le point d'entrée sur «SUBSYSTEM: WINDOWS». Vous devez d'abord changer cela en accédant à:

Projet -> Propriétés -> Linker -> Système -> Sous-système

Et sélectionnez "Console (/ SUBSYSTEM: CONSOLE)" dans la liste déroulante.

Désormais, le programme ne fonctionnera pas, car une fonction "main" est nécessaire à la place de la fonction "WinMain".

Vous pouvez maintenant ajouter une fonction "main" comme vous le feriez normalement en C ++. Ensuite, pour démarrer le programme GUI, vous pouvez appeler la fonction "WinMain" depuis la fonction "main".

La partie de départ de votre programme devrait maintenant ressembler à ceci:

#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;
.
.
.

Résultat de ma mise en œuvre

Vous pouvez maintenant utiliser des fonctions pour générer une sortie vers la console dans n'importe quelle partie de votre programme GUI à des fins de débogage ou à d'autres fins.

Vous pouvez également utiliser la méthode WriteConsole pour imprimer sur la console.

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