Wie leite ich die Ausgabe von qDebug, qWarning, qCritical usw. um?

Ich verwende viele qDebug() <<Anweisungen für die Debug-Ausgabe. Gibt es eine plattformübergreifende Möglichkeit, diese Debug-Ausgabe in eine Datei umzuleiten, ohne auf Shell-Skripte zurückzugreifen? Ich vermute, dass open () und dup2 () die Arbeit unter Linux erledigen, aber wird es mit MinGW unter Windows kompiliert funktionieren?

Und vielleicht gibt es einen Qt-Weg, dies zu tun?

Sie müssen einen Nachrichtenhandler mithilfe der qInstallMsgHandlerFunktion installieren und können dann QTextStreamdie Debug- Nachricht in eine Datei schreiben . Hier ist ein Beispielbeispiel:

#include <QtGlobal>
#include <stdio.h>
#include <stdlib.h>

void myMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
    QByteArray localMsg = msg.toLocal8Bit();
    switch (type) {
    case QtDebugMsg:
        fprintf(stderr, "Debug: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        break;
    case QtInfoMsg:
        fprintf(stderr, "Info: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        break;
    case QtWarningMsg:
        fprintf(stderr, "Warning: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        break;
    case QtCriticalMsg:
        fprintf(stderr, "Critical: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        break;
    case QtFatalMsg:
        fprintf(stderr, "Fatal: %s (%s:%u, %s)\n", localMsg.constData(), context.file, context.line, context.function);
        abort();
    }
}

int main(int argc, char **argv)
{
    qInstallMessageHandler(myMessageOutput); // Install the handler
    QApplication app(argc, argv);
    ...
    return app.exec();
}

Entnommen aus dem Dokument von qInstallMsgHandler(ich habe nur die Kommentare hinzugefügt):

• QtMsgHandler qInstallMessageHandler (QtMsgHandler-Handler)

In dem obigen Beispiel die Funktion myMessageOutputAnwendungen , stderrdie Sie vielleicht mit einem anderen Dateistrom ersetzen oder komplett neu schreiben die Funktion!

Sobald Sie diese Funktion schreiben und installieren, alle qDebug(sowie qWarning, qCriticaletc) Nachrichten würden auf die Datei , die Sie schriftlich in dem Handler weitergeleitet.

Von hier aus geht alle Ehre an den Geist .

#include <QApplication>
#include <QtDebug>
#include <QFile>
#include <QTextStream>

void myMessageHandler(QtMsgType type, const QMessageLogContext &, const QString & msg)
{
    QString txt;
    switch (type) {
    case QtDebugMsg:
        txt = QString("Debug: %1").arg(msg);
        break;
    case QtWarningMsg:
        txt = QString("Warning: %1").arg(msg);
    break;
    case QtCriticalMsg:
        txt = QString("Critical: %1").arg(msg);
    break;
    case QtFatalMsg:
        txt = QString("Fatal: %1").arg(msg);
    break;
    }
    QFile outFile("log");
    outFile.open(QIODevice::WriteOnly | QIODevice::Append);
    QTextStream ts(&outFile);
    ts << txt << endl;
}

int main( int argc, char * argv[] )
{
    QApplication app( argc, argv );
    qInstallMessageHandler(myMessageHandler);   
    ...
    return app.exec();
}

Hier ist ein funktionierendes Beispiel für das Einbinden des Standardnachrichtenhandlers.

Vielen Dank an Ross Rogers!

// -- main.cpp

// Get the default Qt message handler.
static const QtMessageHandler QT_DEFAULT_MESSAGE_HANDLER = qInstallMessageHandler(0);

void myCustomMessageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
    // Handle the messages!

    // Call the default handler.
    (*QT_DEFAULT_MESSAGE_HANDLER)(type, context, msg);
}

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

    QApplication a(argc, argv);

    qDebug() << "Wello Horld!";

    return 0;
}

Hier ist eine plattformübergreifende Lösung, um sich bei der Konsole anzumelden, wenn die App von Qt Creator ausgeführt wurde, und bei der debug.logDatei, wenn sie kompiliert und als eigenständige App ausgeführt wird.

main.cpp :

#include <QApplication>
#include <QtGlobal>
#include <QtDebug>
#include <QTextStream>
#include <QTextCodec>
#include <QLocale>
#include <QTime>
#include <QFile>   

const QString logFilePath = "debug.log";
bool logToFile = false;
    
void customMessageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
    QHash<QtMsgType, QString> msgLevelHash({{QtDebugMsg, "Debug"}, {QtInfoMsg, "Info"}, {QtWarningMsg, "Warning"}, {QtCriticalMsg, "Critical"}, {QtFatalMsg, "Fatal"}});
    QByteArray localMsg = msg.toLocal8Bit();
    QTime time = QTime::currentTime();
    QString formattedTime = time.toString("hh:mm:ss.zzz");
    QByteArray formattedTimeMsg = formattedTime.toLocal8Bit();
    QString logLevelName = msgLevelHash[type];
    QByteArray logLevelMsg = logLevelName.toLocal8Bit();

    if (logToFile) {
        QString txt = QString("%1 %2: %3 (%4)").arg(formattedTime, logLevelName, msg,  context.file);
        QFile outFile(logFilePath);
        outFile.open(QIODevice::WriteOnly | QIODevice::Append);
        QTextStream ts(&outFile);
        ts << txt << endl;
        outFile.close();
    } else {
        fprintf(stderr, "%s %s: %s (%s:%u, %s)\n", formattedTimeMsg.constData(), logLevelMsg.constData(), localMsg.constData(), context.file, context.line, context.function);
        fflush(stderr);
    }

    if (type == QtFatalMsg)
        abort();
}

int main(int argc, char *argv[])
{
    QByteArray envVar = qgetenv("QTDIR");       //  check if the app is ran in Qt Creator

    if (envVar.isEmpty())
        logToFile = true;

    qInstallMessageHandler(customMessageOutput); // custom message handler for debugging

    QApplication a(argc, argv);
    // ...and the rest of 'main' follows

Die Protokollformatierung wird von QString("%1 %2: %3 (%4)").arg...(für die Datei) und fprintf(stderr, "%s %s: %s (%s:%u, %s)\n"...(für die Konsole) durchgeführt.

Inspiration: https://gist.github.com/polovik/10714049 .

Nun, ich würde sagen, dass der Moment, in dem Sie Ihre Debug-Ausgabe auf etwas anderes als stderr umleiten müssen, der Moment ist, in dem Sie über ein Protokollierungstool nachdenken könnten. Wenn Sie der Meinung sind, dass Sie eines benötigen, würde ich die Verwendung QxtLogger( "Die QxtLogger-Klasse ist ein einfach zu verwendendes und einfach zu erweiterndes Protokollierungswerkzeug." ) Aus der QxtBibliothek empfehlen .

Hier ist ein einfaches, thread-sicheres, idiomatisches Qt-Beispiel, in dem Sie sich sowohl in stderrals auch in einer Datei anmelden können :

void messageHandler (Typ QtMsgType, const QMessageLogContext & context, const QString & message)
{
    statischer QMutex-Mutex;
    QMutexLocker-Sperre (& mutex);

    statische QFile logFile (LOGFILE_LOCATION);
    statisch bool logFileIsOpen = logFile.open (QIODevice :: Append | QIODevice :: Text);

    std :: cerr << qPrintable (qFormatLogMessage (Typ, Kontext, Nachricht)) << std :: endl;

    if (logFileIsOpen) {
        logFile.write (qFormatLogMessage (Typ, Kontext, Nachricht) .toUtf8 () + '\ n');
        logFile.flush ();
    }}
}}

Installieren Sie es mit qInstallMessageHandler(messageHandler)wie in anderen Antworten beschrieben.