Como imprimir no console ao usar o Qt

Estou usando Qt4 e C ++ para fazer alguns programas em computação gráfica. Eu preciso ser capaz de imprimir algumas variáveis ​​no meu console em tempo de execução, sem depuração, mas coutparece não funcionar, mesmo se eu adicionar as bibliotecas. Existe uma maneira de fazer isso?

Se for bom o suficiente para imprimir stderr, você poderá usar os seguintes fluxos originalmente destinados à depuração:

#include<QDebug>

//qInfo is qt5.5+ only.
qInfo() << "C++ Style Info Message";
qInfo( "C Style Info Message" );

qDebug() << "C++ Style Debug Message";
qDebug( "C Style Debug Message" );

qWarning() << "C++ Style Warning Message";
qWarning( "C Style Warning Message" );

qCritical() << "C++ Style Critical Error Message";
qCritical( "C Style Critical Error Message" );

// qFatal does not have a C++ style method.
qFatal( "C Style Fatal Error Message" );

Embora, conforme indicado nos comentários, lembre-se de que as mensagens qDebug são removidas se QT_NO_DEBUG_OUTPUTdefinidas

Se você precisar do stdout, tente algo assim (como Kyle Strand apontou):

QTextStream& qStdOut()
{
    static QTextStream ts( stdout );
    return ts;
}

Você pode ligar da seguinte maneira:

qStdOut() << "std out!";

Eu achei isso mais útil:

#include <QTextStream>

QTextStream out(stdout);
foreach(QString x, strings)
    out << x << endl;

Escrevendo para stdout

Se você deseja algo que, como std::cout, grava na saída padrão do seu aplicativo, basta fazer o seguinte ( crédito ao CapelliC ):

QTextStream(stdout) << "string to print" << endl;

Se você deseja evitar a criação de um QTextStreamobjeto temporário , siga a sugestão de Yakk nos comentários abaixo de criar uma função para retornar um staticidentificador para stdout:

inline QTextStream& qStdout()
{
    static QTextStream r{stdout};
    return r;
}

...

foreach(QString x, strings)
    qStdout() << x << endl;

Lembre- se flushdo fluxo periodicamente para garantir que a saída seja realmente impressa.

Escrevendo para stderr

Observe que a técnica acima também pode ser usada para outras saídas. No entanto, existem maneiras mais legíveis de escrever stderr( crédito para Goz e comentários abaixo de sua resposta):

qDebug() << "Debug Message";    // CAN BE REMOVED AT COMPILE TIME!
qWarning() << "Warning Message";
qCritical() << "Critical Error Message";
qFatal("Fatal Error Message");  // WILL KILL THE PROGRAM!

qDebug()está fechado se QT_NO_DEBUG_OUTPUTestiver ativado no tempo de compilação.

(Goz observa em um comentário que, para aplicativos que não são do console, eles podem ser impressos em um fluxo diferente do que stderr.)

NOTA: Todos os métodos de impressão Qt assumem que os const char*argumentos são cadeias codificadas ISO-8859-1 com \0caracteres finais .

Adicione isso ao seu arquivo de projeto:

CONFIG += console

Quais variáveis ​​você deseja imprimir? Se você quer dizer QStrings, eles precisam ser convertidos em c-Strings. Experimentar:

std::cout << myString.toAscii().data();

Ele também possui uma sintaxe semelhante ao prinft, por exemplo:

qDebug ("message %d, says: %s",num,str); 

Muito útil também

Vá para o projeto Properties -> Linker-> System -> SubSysteme defina-o Console(/S).

Que tal incluir a biblioteca iostream e precisar que cout é um objeto de std como este:

#include <iostream>

std::cout << "Hello" << std::endl;

Se você estiver imprimindo no stderr usando a biblioteca stdio, uma chamada para fflush(stderr)deverá liberar o buffer e obter o log em tempo real.

#include <QTextStream>
...
qDebug()<<"Bla bla bla";

Bem, depois de estudar vários exemplos na Internet que descrevem como enviar mensagens de uma GUI no Qt para o stdout, refinei um exemplo independente de trabalho para redirecionar mensagens para um console, via qDebug () e instalando qInstallMessageHandler (). O console será exibido ao mesmo tempo que a GUI e pode ser oculto, se necessário. O código é fácil de integrar com o código existente no seu projeto. Aqui está a amostra completa e fique à vontade para usá-la da maneira que quiser, desde que adira à Licença GNU GPL v2. Você tem que usar algum tipo de forma e uma MainWindow, eu acho - caso contrário, a amostra será executada, mas provavelmente trava quando forçada a sair. Nota: não há como sair por meio de um botão fechar ou de um menu fechar, porque eu testei essas alternativas e o aplicativo falhará eventualmente de vez em quando. Sem o botão Fechar, o aplicativo permanecerá estável e você poderá fechá-lo na janela principal. Aproveitar!

#include "mainwindow.h"
#include <QApplication>

//GNU GPL V2, 2015-02-07
#include <QMessageBox>
#include <windows.h>
#define CONSOLE_COLUMNS 80
#define CONSOLE_ROWS    5000
#define YOURCONSOLETITLE "Your_Console_Title"

typedef struct{

    CONSOLE_SCREEN_BUFFER_INFOEX conScreenBuffInfoEX;

    HANDLE con_screenbuf;
    HWND hwndConsole;
    HMENU consoleMenu ;
    QString consoleTitle;

    QMessageBox mBox;
    QString localMsg;
    QString errorMessage;
    WINBOOL errorCode;

} consoleT;

static consoleT *console;

BOOL WINAPI catchCTRL( DWORD ctrlMsg ){

        if( ctrlMsg == CTRL_C_EVENT ){

            HWND hwndWin = GetConsoleWindow();
               ShowWindow(hwndWin,SW_FORCEMINIMIZE);
        }

    return TRUE;
}

void removeCloseMenu(){

    int i;

    for( i = 0; i < 10; i++){

        console->hwndConsole = FindWindowW( NULL, console->consoleTitle.toStdWString().data());

        if(console->hwndConsole != NULL)
            break;
    }

    if( !(console->errorCode = 0) && (console->hwndConsole == NULL))
            console->errorMessage += QString("\nFindWindowW error: %1 \n").arg(console->errorCode);

    if( !(console->errorCode = 0) &&  !(console->consoleMenu = GetSystemMenu( console->hwndConsole, FALSE )) )
        console->errorMessage += QString("GetSystemMenu error: %1 \n").arg(console->errorCode);

    if(!(console->errorCode = DeleteMenu( console->consoleMenu, SC_CLOSE, MF_BYCOMMAND )))
           console->errorMessage += QString("DeleteMenu error: %1 \n").arg(console->errorCode);
}

void initialiseConsole(){

    console->conScreenBuffInfoEX.cbSize = sizeof(CONSOLE_SCREEN_BUFFER_INFOEX);
    console->consoleMenu = NULL;
    console->consoleTitle = YOURCONSOLETITLE;
    console->con_screenbuf = INVALID_HANDLE_VALUE;
    console->errorCode = 0;
    console->errorMessage = "";
    console->hwndConsole = NULL;
    console->localMsg = "";

    if(!(console->errorCode = FreeConsole()))
        console->errorMessage += QString("\nFreeConsole error: %1 \n").arg(console->errorCode);

    if(!(console->errorCode = AllocConsole()))
        console->errorMessage += QString("\nAllocConsole error: %1 \n").arg(console->errorCode);

    if( (console->errorCode = -1) && (INVALID_HANDLE_VALUE ==(console->con_screenbuf = CreateConsoleScreenBuffer( GENERIC_WRITE | GENERIC_READ,0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL))))
        console->errorMessage += QString("\nCreateConsoleScreenBuffer error: %1 \n").arg(console->errorCode);

    if(!(console->errorCode = SetConsoleActiveScreenBuffer(console->con_screenbuf)))
        console->errorMessage += QString("\nSetConsoleActiveScreenBuffer error: %1 \n").arg(console->errorCode);

    if(!(console->errorCode = GetConsoleScreenBufferInfoEx(console->con_screenbuf, &console->conScreenBuffInfoEX)))
        console->errorMessage += QString("\nGetConsoleScreenBufferInfoEx error: %1 \n").arg(console->errorCode);

    console->conScreenBuffInfoEX.dwSize.X = CONSOLE_COLUMNS;
    console->conScreenBuffInfoEX.dwSize.Y = CONSOLE_ROWS;

    if(!(console->errorCode = SetConsoleScreenBufferInfoEx(console->con_screenbuf, &console->conScreenBuffInfoEX)))
       console->errorMessage += QString("\nSetConsoleScreenBufferInfoEx error: %1 \n").arg(console->errorCode);

    if(!(console->errorCode = SetConsoleTitleW(console->consoleTitle.toStdWString().data())))
        console->errorMessage += QString("SetConsoleTitle error: %1 \n").arg(console->errorCode);

    SetConsoleCtrlHandler(NULL, FALSE);
    SetConsoleCtrlHandler(catchCTRL, TRUE);

    removeCloseMenu();

    if(console->errorMessage.length() > 0){
        console->mBox.setText(console->errorMessage);
        console->mBox.show();
    }

}

void messageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg){


    if((console->con_screenbuf != INVALID_HANDLE_VALUE)){

        switch (type) {

        case QtDebugMsg:
            console->localMsg = console->errorMessage + "Debug: " + msg;
            WriteConsoleW(console->con_screenbuf, console->localMsg.toStdWString().data(), console->localMsg.toStdWString().length(), NULL, NULL );
            WriteConsoleA(console->con_screenbuf, "\n--\n", 4, NULL, NULL );
            break;

        case QtWarningMsg:
            console->localMsg = console->errorMessage + "Warning: " + msg;
            WriteConsoleW(console->con_screenbuf, console->localMsg.toStdWString().data(), console->localMsg.toStdWString().length() , NULL, NULL );
            WriteConsoleA(console->con_screenbuf, "\n--\n", 4, NULL, NULL );
            break;

        case QtCriticalMsg:
            console->localMsg = console->errorMessage + "Critical: " + msg;
            WriteConsoleW(console->con_screenbuf, console->localMsg.toStdWString().data(), console->localMsg.toStdWString().length(), NULL, NULL );
            WriteConsoleA(console->con_screenbuf, "\n--\n", 4, NULL, NULL );
            break;

        case QtFatalMsg:
            console->localMsg = console->errorMessage + "Fatal: " + msg;
            WriteConsoleW(console->con_screenbuf, console->localMsg.toStdWString().data(), console->localMsg.toStdWString().length(), NULL, NULL );
            WriteConsoleA(console->con_screenbuf, "\n--\n", 4, NULL, NULL );
            abort();
        }
    }
}



int main(int argc, char *argv[])
{

    qInstallMessageHandler(messageHandler);

    QApplication a(argc, argv);

    console = new consoleT();
    initialiseConsole();

    qDebug() << "Hello World!";

    MainWindow w;
    w.show();

    return a.exec();
}

"build & run"> Padrão para "Executar no terminal" -> Ativar

para liberar o buffer, use este comando -> fflush (stdout); você também pode usar "\ n" em printfou cout.