Comment puis-je obtenir de sortie de la console en C++ avec un programme Windows?

Découvrez L'ajout de la Console I/O d'une GUI Win32 Application. Cela peut vous aider à faire ce que vous voulez.

Si vous n'avez pas, ou ne pouvez pas modifier le code, essayez les suggestions trouvé ici pour rediriger la sortie de la console dans un fichier.

---

Edit: peu de fil de la nécromancie ici. J'ai d'abord répondu à cette 9ish il y a des années, dans les premiers jours de la SORTE, avant le (bon) politique de non-link-seules réponses sont entrées en vigueur. Je vais reposter le code de l'article original dans l'espoir d'expier mes péchés passés.

guicon.cpp -- Une redirection de la console de fonction

#include <windows.h>
#include <stdio.h>
#include <fcntl.h>
#include <io.h>
#include <iostream>
#include <fstream>
#ifndef _USE_OLD_IOSTREAMS
using namespace std;
#endif
//maximum mumber of lines the output console should have
static const WORD MAX_CONSOLE_LINES = 500;
#ifdef _DEBUG
void RedirectIOToConsole()
{
int hConHandle;
long lStdHandle;
CONSOLE_SCREEN_BUFFER_INFO coninfo;
FILE *fp;
//allocate a console for this app
AllocConsole();
//set the screen buffer to be big enough to let us scroll text
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo);
coninfo.dwSize.Y = MAX_CONSOLE_LINES;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize);
//redirect unbuffered STDOUT to the console
lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "w" );
*stdout = *fp;
setvbuf( stdout, NULL, _IONBF, 0 );
//redirect unbuffered STDIN to the console
lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "r" );
*stdin = *fp;
setvbuf( stdin, NULL, _IONBF, 0 );
//redirect unbuffered STDERR to the console
lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
fp = _fdopen( hConHandle, "w" );
*stderr = *fp;
setvbuf( stderr, NULL, _IONBF, 0 );
//make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
//point to console as well
ios::sync_with_stdio();
}
#endif
//End of File

guicon.h -- Interface pour la redirection de console de la fonction

#ifndef __GUICON_H__
#define __GUICON_H__
#ifdef _DEBUG
void RedirectIOToConsole();
#endif
#endif
//End of File

test.cpp -faisant preuve d'une redirection de console

#include <windows.h>
#include <iostream>
#include <fstream>
#include <conio.h>
#include <stdio.h>
#ifndef _USE_OLD_OSTREAMS
using namespace std;
#endif
#include "guicon.h"
#include <crtdbg.h>
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
#ifdef _DEBUG
RedirectIOToConsole();
#endif
int iVar;
//test stdio
fprintf(stdout, "Test output to stdout\n");
fprintf(stderr, "Test output to stderr\n");
fprintf(stdout, "Enter an integer to test stdin: ");
scanf("%d", &iVar);
printf("You entered %d\n", iVar);
//test iostreams
cout << "Test output to cout" << endl;
cerr << "Test output to cerr" << endl;
clog << "Test output to clog" << endl;
cout << "Enter an integer to test cin: ";
cin >> iVar;
cout << "You entered " << iVar << endl;
#ifndef _USE_OLD_IOSTREAMS
//test wide iostreams
wcout << L"Test output to wcout" << endl;
wcerr << L"Test output to wcerr" << endl;
wclog << L"Test output to wclog" << endl;
wcout << L"Enter an integer to test wcin: ";
wcin >> iVar;
wcout << L"You entered " << iVar << endl;
#endif
//test CrtDbg output
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR);
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR);
_RPT0(_CRT_WARN, "This is testing _CRT_WARN output\n");
_RPT0(_CRT_ERROR, "This is testing _CRT_ERROR output\n");
_ASSERT( 0 && "testing _ASSERT" );
_ASSERTE( 0 && "testing _ASSERTE" );
Sleep(2000);
return 0;
}
//End of File

À l'aide d'une combinaison de la réponse de luc et Roger réponse ici a travaillé pour moi dans mon Bureau Windows de l'Application du projet.

void RedirectIOToConsole() {
//Create a console for this application
AllocConsole();
//Get STDOUT handle
HANDLE ConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE);
int SystemOutput = _open_osfhandle(intptr_t(ConsoleOutput), _O_TEXT);
FILE *COutputHandle = _fdopen(SystemOutput, "w");
//Get STDERR handle
HANDLE ConsoleError = GetStdHandle(STD_ERROR_HANDLE);
int SystemError = _open_osfhandle(intptr_t(ConsoleError), _O_TEXT);
FILE *CErrorHandle = _fdopen(SystemError, "w");
//Get STDIN handle
HANDLE ConsoleInput = GetStdHandle(STD_INPUT_HANDLE);
int SystemInput = _open_osfhandle(intptr_t(ConsoleInput), _O_TEXT);
FILE *CInputHandle = _fdopen(SystemInput, "r");
//make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog point to console as well
ios::sync_with_stdio(true);
//Redirect the CRT standard input, output, and error handles to the console
freopen_s(&CInputHandle, "CONIN$", "r", stdin);
freopen_s(&COutputHandle, "CONOUT$", "w", stdout);
freopen_s(&CErrorHandle, "CONOUT$", "w", stderr);
//Clear the error state for each of the C++ standard stream objects. We need to do this, as
//attempts to access the standard streams before they refer to a valid target will cause the
//iostream objects to enter an error state. In versions of Visual Studio after 2005, this seems
//to always occur during startup regardless of whether anything has been read from or written to
//the console or not.
std::wcout.clear();
std::cout.clear();
std::wcerr.clear();
std::cerr.clear();
std::wcin.clear();
std::cin.clear();
}

Si vous envoyez la sortie de votre programme vers un fichier ou un tuyau, par exemple

myprogram.exe > file.txt
myprogram.exe | anotherprogram.exe

ou vous exécutez votre programme à partir d'un autre programme et à la capture de sa sortie par l'intermédiaire d'un tuyau, alors vous n'avez pas besoin de changer quoi que ce soit. Le tout fonctionne, même si le point d'entrée est WinMain.

Toutefois, si vous exécutez votre programme dans une console ou dans Visual Studio, puis la sortie n'apparaît pas dans la console ou dans la fenêtre de Sortie de Visual Studio. Si vous voulez voir la sortie de "live", puis essayez l'une des autres réponses.

Fondamentalement, cela signifie que la sortie standard, fonctionne exactement comme avec les applications de console, mais il n'est pas connecté à une console dans laquelle vous exécutez votre application, et il semble y avoir aucun moyen facile de le faire (toutes les autres solutions présentées ici de connecter la sortie d'une nouvelle console fenêtre pop-up lorsque vous exécutez votre application, même à partir d'une autre console).

Aller de Projet>Propriétés de Projet>Linker>Système et dans le volet de droite, définissez sous-systèmes option pour Console(/SUBSYSTEM:CONSOLE)

Puis compiler votre programme et l'exécuter à partir de la console pour voir si vous l'invite de commande indique vos sorties ou pas.

Passé toute la journée d'aujourd'hui en essayant de le faire fonctionner correctement. Trouvé des réponses sur le web qui ressemblent à des luc et Sev de.

La méthode fonctionne, mais le problème vient quand je l'ai sortie de la console, soit par des appels de FreeConsole ou tout simplement l'arrêt de l'application normalement. En mode debug, je vois debug assertions à propos de fichier non valide poignées dans le CRT code de nettoyage.

Je pense que le problème est causé en partie par le trop compliqué rediriger les processus que tout le monde utilise, et en partie parce que la norme IO flux ne sont pas redirigés avant de quitter.

Je ne comprends pas du tout le besoin d'utiliser _open_osfhandle et _fdopen dans ce processus.

C'est la solution complète qui fonctionne pour moi:

La redirection de la Console de Standard IO:

bool RedirectConsoleIO()
{
bool result = true;
FILE* fp;
//Redirect STDIN if the console has an input handle
if (GetStdHandle(STD_INPUT_HANDLE) != INVALID_HANDLE_VALUE)
if (freopen_s(&fp, "CONIN$", "r", stdin) != 0)
result = false;
else
setvbuf(stdin, NULL, _IONBF, 0);
//Redirect STDOUT if the console has an output handle
if (GetStdHandle(STD_OUTPUT_HANDLE) != INVALID_HANDLE_VALUE)
if (freopen_s(&fp, "CONOUT$", "w", stdout) != 0)
result = false;
else
setvbuf(stdout, NULL, _IONBF, 0);
//Redirect STDERR if the console has an error handle
if (GetStdHandle(STD_ERROR_HANDLE) != INVALID_HANDLE_VALUE)
if (freopen_s(&fp, "CONOUT$", "w", stderr) != 0)
result = false;
else
setvbuf(stderr, NULL, _IONBF, 0);
//Make C++ standard streams point to console as well.
ios::sync_with_stdio(true);
//Clear the error state for each of the C++ standard streams.
std::wcout.clear();
std::cout.clear();
std::wcerr.clear();
std::cerr.clear();
std::wcin.clear();
std::cin.clear();
return result;
}

Libérant une Console:

bool ReleaseConsole()
{
bool result = true;
FILE* fp;
//Just to be safe, redirect standard IO to NUL before releasing.
//Redirect STDIN to NUL
if (freopen_s(&fp, "NUL:", "r", stdin) != 0)
result = false;
else
setvbuf(stdin, NULL, _IONBF, 0);
//Redirect STDOUT to NUL
if (freopen_s(&fp, "NUL:", "w", stdout) != 0)
result = false;
else
setvbuf(stdout, NULL, _IONBF, 0);
//Redirect STDERR to NUL
if (freopen_s(&fp, "NUL:", "w", stderr) != 0)
result = false;
else
setvbuf(stderr, NULL, _IONBF, 0);
//Detach from console
if (!FreeConsole() || !result)
return false;
return true;
}

Redimensionnement De La Console De La Mémoire Tampon:

void AdjustConsoleBuffer(int16_t minLength)
{
//Set the screen buffer to be big enough to scroll some text
CONSOLE_SCREEN_BUFFER_INFO conInfo;
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &conInfo);
if (conInfo.dwSize.Y < minLength)
conInfo.dwSize.Y = minLength;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), conInfo.dwSize);
}

L'allocation d'une Nouvelle Console:

bool CreateNewConsole(int16_t minLength)
{
bool result = false;
//Release any current console and redirect IO to NUL
ReleaseConsole();
//Attempt to create new console
if (AllocConsole())
{
AdjustConsoleBuffer(minLength);
result = RedirectConsoleIO();
}
return result;
}

Fixation à la Mère de la Console:

bool AttachParentConsole(int16_t minLength)
{
bool result = false;
//Release any current console and redirect IO to NUL
ReleaseConsole();
//Attempt to attach to parent process's console
if (AttachConsole(ATTACH_PARENT_PROCESS))
{
AdjustConsoleBuffer(minLength);
result = RedirectConsoleIO();
}
return result;
}

Appel de WinMain:

Lien avec /SUBSYSTEM:Windows

int APIENTRY WinMain(
HINSTANCE /*hInstance*/,
HINSTANCE /*hPrevInstance*/,
LPTSTR    /*lpCmdLine*/,
int       /*cmdShow*/)
{
if (CreateNewConsole(1024))
{
int i;
//test stdio
fprintf(stdout, "Test output to stdout\n");
fprintf(stderr, "Test output to stderr\n");
fprintf(stdout, "Enter an integer to test stdin: ");
scanf("%d", &i);
printf("You entered %d\n", i);
//test iostreams
cout << "Test output to cout" << endl;
cerr << "Test output to cerr" << endl;
clog << "Test output to clog" << endl;
cout << "Enter an integer to test cin: ";
cin >> i;
cout << "You entered " << i << endl;
std::cout << endl << "Press any key to continue..." << endl;
_getch();
ReleaseConsole();
}
return 0;
};

Comme mentionné il y et il y la solution la plus simple est d'utiliser vos Pages de propriétés du Projet pour alterner entre CONSOLE et WINDOWS SubSytems pour activer ou désactiver la sortie de la console à volonté.

Votre programme aura juste besoin main et WinMain points d'entrée pour s'assurer à la fois la configuration de la compilation.
Le main fonction appelant simplement WinMain comme indiqué ci-dessous par exemple:

int main()
{
cout << "Output standard\n";
cerr << "Output error\n";
return WinMain(GetModuleHandle(NULL), NULL, GetCommandLineA(), SW_SHOWNORMAL);
}