QDebug, qWarning, qCritical आदि आउटपुट को रीडायरेक्ट कैसे करें?

Question 1

मैं qDebug() <<डिबग आउटपुट के लिए बहुत सारे बयानों का उपयोग कर रहा हूं । क्या कोई क्रॉस-प्लेटफ़ॉर्म तरीका है जो मैं शेल स्क्रिप्ट्स का सहारा लिए बिना उस डिबग आउटपुट को किसी फ़ाइल में रीडायरेक्ट कर सकता हूं? मैं अनुमान लगा रहा हूं कि ओपन () और डुप 2 () लिनक्स में काम करेगा, लेकिन क्या यह विंडोज में मिनगव के साथ संकलित होगा?

और शायद यह करने के लिए एक क्यूटी तरीका है?

Question 2

आपको qInstallMsgHandlerफ़ंक्शन का उपयोग करके एक संदेश हैंडलर स्थापित करना है, और फिर, आप डिबग संदेश को किसी फ़ाइल में QTextStreamलिखने के लिए उपयोग कर सकते हैं । यहाँ एक नमूना उदाहरण दिया गया है:

#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();
}

के दस्तावेज़ से लिया गया qInstallMsgHandler(मैंने केवल टिप्पणियाँ जोड़ी):

QtMsgHandler qInstallMessageHandler (QtMsgHandler हैंडलर)

उपरोक्त उदाहरण में, फ़ंक्शन myMessageOutputका उपयोग करता है stderrजिसे आप किसी अन्य फाइल स्ट्रीम के साथ बदलना चाहते हैं, या फ़ंक्शन को पूरी तरह से फिर से लिखना चाहते हैं!

एक बार जब आप इस फ़ंक्शन को लिखते हैं और इंस्टॉल करते हैं, तो आपके सभी qDebug(साथ ही qWarning, qCriticalआदि) संदेश उस फ़ाइल में रीडायरेक्ट हो जाएंगे जो आप हैंडलर में लिख रहे हैं।

Question 3

से यहाँ सभी क्रेडिट को जाता है भावना ।

#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();
}

Question 4

यहां डिफ़ॉल्ट संदेश हैंडलर को हुक करने का एक कार्यशील उदाहरण दिया गया है।

शुक्रिया @Ross रोजर्स!

// -- 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;
}

Question 5

यहाँ कंसोल पर लॉग इन करने के लिए एक क्रॉस-प्लेटफ़ॉर्म समाधान है, अगर ऐप को क्यूटी क्रिएटर से और debug.logफ़ाइल में चलाया गया था , जब इसे संकलित किया जाता है और स्टैंडअलोन ऐप के रूप में चलाया जाता है।

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

लॉग स्वरूपण QString("%1 %2: %3 (%4)").arg...(फ़ाइल के लिए) और fprintf(stderr, "%s %s: %s (%s:%u, %s)\n"...(कंसोल के लिए ) द्वारा नियंत्रित किया जाता है ।

प्रेरणा: https://gist.github.com/polovik/10714049 ।

Question 6

खैर, मैं कहूंगा कि जब आपको अपने डिबग आउटपुट को stderr से भिन्न कुछ पर पुनर्निर्देशित करने की आवश्यकता होती है, जब आप कुछ लॉगिंग टूल के बारे में सोच सकते हैं। यदि आपको लगता है कि आपको एक की आवश्यकता है तो मैं इसका उपयोग करने की सलाह दूंगाQxtLogger ( "QxtLogger वर्ग का उपयोग करना आसान है, लॉगिंग टूल का विस्तार करना आसान है।" ) Qxtलाइब्रेरी से।

Question 7

यहाँ एक सरल, धागा सुरक्षित मुहावरेदार Qt उदाहरण है stderrजिसे लॉग इन करना और फाइल करना:

शून्य संदेशहैंडलर (QtMsgType प्रकार, const QMessageLogContext और संदर्भ, const QString और संदेश)
{
    स्थिर क्यूम्यूटेक्स म्यूटेक्स;
    QMutexLocker लॉक (और म्यूटेक्स);

    स्थिर QFile logFile (LOGFILE_LOCATION);
    स्टेटिक बूल logFileIsOpen = logFile.open (QIODevice :: Append | QIODevice :: Text);

    std :: cerr << qPrintable (qFormatLogMessage (प्रकार, संदर्भ, संदेश)) << std :: endl;

    अगर (logFileIsOpen) {
        logFile.write (qFormatLogMessage (प्रकार, संदर्भ, संदेश) .toUtf8 () + '\ n');
        logFile.flush ();
    }
}

इसे qInstallMessageHandler(messageHandler)अन्य उत्तरों में वर्णित अनुसार स्थापित करें ।