Comment puis-je imprimer à 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 être en mesure d'imprimer des choses à la sortie de Visual Studio fenêtre, mais je ne peux pas pour la vie de moi quoi. J'ai essayé "printf" et " cout <<", mais mes messages restent obstinément non imprimé.

Est-il une sorte de moyen spécial de l'impression à la sortie de Visual Studio fenêtre?

  • Notez que la Fenêtre de sortie Visual Studio n'est pas la console. Ils sont à la fois "de windows avec le texte en eux", mais sont différents dans les coulisses.
InformationsquelleAutor izb | 2009-08-26
  1. 125

    Vous pouvez utiliser OutputDebugString. OutputDebugString est une macro en fonction de vos options de génération, soit des cartes à OutputDebugStringA(char const*) ou OutputDebugStringW(wchar_t const*). Dans ce dernier cas, vous devrez fournir une chaîne de caractères larges de la fonction. Pour créer un large littéral de caractère, vous pouvez utiliser le L préfixe:

    OutputDebugStringW(L"My output string.");

    Normalement, vous utilisez la macro version avec le _T macro comme ceci:

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

    Si votre projet est configuré pour construire pour l'UNICODE, il va se développer sur:

    OutputDebugStringW(L"My output string.");

    Si vous n'êtes pas la construction de l'UNICODE, il va se développer sur:

    OutputDebugStringA("My output string.");
    • Parfait! Merci. Pour l'exhaustivité, il s'est avéré que j'avais à faire ceci: OutputDebugString(TEXTE("Bonjour le monde de la console")); .. sans doute en raison d'une sorte d'unicode liées à l'option de compilation.
    • J'ai développé ma réponse un peu pour inclure des informations sur les deux versions de la fonction.
    • +1. En général, vous utilisez la macro version et placer la chaîne _T (qui est le même que TEXT seulement plus courte).
    • notez que vous trouverez qu'il est utile d'avoir debugview de sysinternals. Cela vous permet de voir l'ODS de sortie même si Visual Studio n'est pas en cours d'exécution (ou même de les installer) sur la boîte
    • +1 - beaucoup mieux que de jouer avec la console windows. J'ai également eu à utiliser le TEXTE au lieu de _T - probablement définie dans quelques !@#$% .h fichier.
    • Comment puis-je sortie une chaîne de caractères variable ? Comme OutputDebugString(myStr);
    • Cela dépend du type de myStr. Est-il char*, wchar_t* ou LPTSTR? En supposant que c'est char* vous suffit d'appeler OutputDebugStringA(myStr) ou de l'utilisation OutputDebugStringW avec wchar_t* et OutputDebugString avec LPTSTR comme expliqué dans ma réponse.
    • Vraiment apprécié. Il n'y a tout simplement pas de méthode simple pour sortir les informations de débogage avec VS.
    • Ce qui est plus simple que d'appeler une fonction ayant un seul paramètre qui est le message que vous souhaitez transmettre? Est-ce la norme ANSI/UNICODE de la complexité? Utilisez simplement OutputDebugString et soit définir les symboles de préprocesseur pour correspondre à la largeur des caractères que vous utilisez ou aller avec le flexible "T" de types qui vous permet de compiler à la fois en 8 et 16 bits caractères.
    • J'ai été nécessaires pour voir la sortie d'un programme existant.
    • aucune idée de pourquoi cela n'a pas de sortie de n'importe quelle chaîne sur l'écran lorsque je debug mon code ligne par ligne? OutputDebugStringW(L"My output string."); ?
    • Il n'est pas clair à partir de votre commentaire, ce qui écran, est de sorte qu'il est un peu difficile de vous donner des conseils spécifiques. Si vous déboguez votre processus le débogueur aura un moyen d'afficher la sortie de débogage. Si vous utilisez Visual Studio comme débogueur la sortie est indiqué dans le Sortie de la fenêtre. Pour voir la sortie, vous devez sélectionner Debug de la Afficher la sortie de menu déroulant. Si vous pour une raison quelconque, sont l'exécution de vos processus à l'extérieur d'un débogueur, vous pouvez utiliser DebugView pour voir la sortie de débogage à partir de tous les processus.

    InformationsquelleAutor Martin Liversage
  2. 27

    Si le projet est une interface graphique de projet, pas de console s'affiche. Afin de modifier le projet dans une console, vous devez aller dans les propriétés du projet panneau et set:

    • Dans "de l'éditeur de liens->Système->sous-système de" la valeur "Console (/SUBSYSTEM:CONSOLE)"
    • Dans "C/C++->Préprocesseur->Définitions de Préprocesseur" ajouter "_CONSOLE" définir

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

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

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

    printf et cout fonctionnera comme d'habitude.

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

    • EDITBIN pouvez définir le sous-système de CONSOLE même si vous utilisez WinMain plutôt que int main().
    • Merci! Les 4 lignes de départ avec AllocConsole() a très bien fonctionné. Plus 1 pour que. Rien d'autre ne fonctionne, même si j'ai eu des consoles pour se montrer avant dans Win32 projets avant d'utiliser le /SUBSYSTEM:CONSOLE et/ou _CONSOLE macros avant. Je ne sais pas pourquoi les macros n'a pas fonctionné ce soir. Pourrait-il avoir quelque chose à faire avec l'aide de Common Language Runtime Support (/clr)?
    InformationsquelleAutor Zac
  3. 12

    L'impression real de la console, vous devez le rendre visible à l'aide de l'éditeur de liens drapeau /SUBSYSTEM:CONSOLE. L'extra fenêtre de la console est ennuyeux, mais à des fins de débogage, il est très précieux.

    OutputDebugString impressions à la sortie du débogueur lors de l'exécution dans le débogueur.

    • Vous pouvez également attribuer votre propre console à l'aide de AllocConsole()
    InformationsquelleAutor Ringding
  4. 4

    Examiner à l'aide de VC++ runtime Macros pour les Rapports _RPTN() et _RPTFN()

    Vous pouvez utiliser le _RPTn, et _RPTFn les macros définies dans CRTDBG.H, à
    remplacer l'utilisation de printf états à des fins de débogage. Ces macros
    disparaissent automatiquement dans votre communiqué de construire lorsque _DEBUG n'est pas
    définie, donc il n'est 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 le VC++ runtime fonctions _CrtDbgReport, _CrtDbgReportW directement.

    _CrtDbgReport et _CrtDbgReportW pouvez envoyer le débogage rapport à trois destinations différentes: un déboguer le fichier de rapport, un moniteur de débogage (le
    Débogueur Visual Studio), ou un message de débogage de la fenêtre.

    _CrtDbgReport et _CrtDbgReportW créer le message de l'utilisateur pour le débogage de rapport par la substitution de l'argument[n] arguments dans le format
    chaîne de caractères, en utilisant les mêmes règles définies par le printf ou wprintf
    fonctions. Ces fonctions puis générer le rapport et de débogage
    déterminer la destination ou les destinations, selon le rapport
    modes et fichier défini pour reportType. Lorsque le rapport est envoyé à un
    un message de débogage de la fenêtre, le nom de fichier, lineNumber, et moduleName sont
    inclus dans les informations affichées dans la fenêtre.

    • Il est intéressant d'ajouter à la réponse, ou en notant que _RPTF0 peut être utilisé là où aucune des variables devraient être passé après la chaîne de format. Le _RPTFN macro, d'autre part, il faut au moins un argument à la suite de la chaîne de format.
    InformationsquelleAutor Autodidact
  5. 4

    Si vous avez besoin de voir la sortie d'un programme existant qui a largement utilisé printf w/o changer le code (ou avec un minimum de modifications), vous pouvez redéfinir printf comme suit, et les 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__)
    • être prudent en raison de la statique de la mémoire tampon, cette fonction n'est pas réentrant et ne pouvait pas être utilisé à partir de différents threads.
    InformationsquelleAutor vlad
  6. 3

    Si vous souhaitez imprimer décimal variables:

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

    Votre projet Win32 est probablement un GUI projet, pas un projet console. Cela entraîne une différence dans l'exécutable d'en-tête. En conséquence, votre GUI de projet sera responsable de l'ouverture de sa propre fenêtre. Que peut être une fenêtre de console, si. Appel AllocConsole() pour la créer et utiliser la console Win32 fonctions de l'écriture.

    InformationsquelleAutor MSalters
  8. 2

    Je cherchais un moyen de faire moi-même et a trouvé une solution simple.

    Je suis en supposant que vous avez commencé un défaut Win32 Projet application Windows dans Visual Studio, qui offre une fonction "WinMain". Par défaut, Visual Studio définit le point d'entrée pour le "sous-système:WINDOWS". Vous devez d'abord changer cela en allant à:

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

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

    L'instant, le programme ne sera pas exécuté, depuis un "principal" de la fonction est nécessaire, au lieu de la fonction "WinMain".

    Alors maintenant, vous pouvez ajouter un "principal" de la fonction comme vous le feriez normalement en C++. Après cela, pour démarrer l'interface graphique du programme, vous pouvez appeler la fonction "WinMain" de l'intérieur de la "main" de la fonction.

    La partie initiale 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

    Maintenant, vous pouvez utiliser des fonctions pour la sortie de la console dans n'importe quelle partie de votre programme graphique pour le débogage ou à d'autres fins.

    • Cela fonctionne pour la sortie, mais pas d'entrée.
    InformationsquelleAutor pops
  9. 1

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

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