Qt का उपयोग करते समय कंसोल को कैसे प्रिंट करें


159

मैं कंप्यूटर ग्राफिक्स में कुछ प्रोग्राम बनाने के लिए Qt4 और C ++ का उपयोग कर रहा हूं। मुझे अपने कंसोल में कुछ वैरिएबल को रन-टाइम में प्रिंट करने में सक्षम होना चाहिए, डिबगिंग नहीं, लेकिन coutमैं पुस्तकालयों को जोड़ने पर भी काम नहीं करता। क्या इसे करने का कोई तरीका है?


3
क्या आप कॉट पर काम नहीं कर सकते हैं क्योंकि यह निश्चित रूप से काम करना चाहिए। क्या आपको एक संकलन त्रुटि है। क्या आप ऐसे कूट का उदाहरण दिखा सकते हैं जो आपके लिए काम नहीं कर रहा है? यह भी बताएं कि आप एप्लिकेशन कैसे चला रहे हैं। क्या आप इसे कंसोल से या IDE के भीतर से चला रहे हैं और इसकी आउटपुट विंडो को आउटपुट नहीं देख रहे हैं?
अर्नोल्ड स्पेंस

बस पूर्णता के लिए: @AnnoldSpence - पुस्तकालयों के बिना, मुझे मिलता है error: ‘cout’ was not declared in this scope; iostream के साथ, मुझे मिलता है error: no match for ‘operator<<’ in ‘std::operator<< [with _Traits = std::char_traits<char>](((std::basic_ostream<char>&)(& std::cout)), ...; जवाब में आदेशों का उपयोग करने के बजाय ठीक काम करता है।
sdaau

जब समस्या का विवरण सरलता से दिया जाता है, तो समाधान प्रस्तुत करना मुश्किल होता है, "यह काम नहीं करता है"। कृपया अपने प्रश्न को संपादित करें कि आप क्या होने की उम्मीद करते हैं और यह कैसे वास्तविक परिणामों से अलग है, इसका अधिक पूर्ण विवरण देने के लिए। एक अच्छी व्याख्या करने पर संकेत के लिए कैसे पूछें देखें ।
स्पाइट

इस मामले में, आपको स्पष्ट रूप से निर्दिष्ट करना चाहिए कि वे "चर" क्यूटी-विशिष्ट ऑब्जेक्ट (जैसे QString) हैं।
user202729

जवाबों:


203

यदि इसे प्रिंट करना अच्छा है stderr, तो आप मूल रूप से डिबगिंग के लिए निम्नलिखित धाराओं का उपयोग कर सकते हैं:

#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" );

हालांकि जैसा कि टिप्पणियों में बताया गया है, QT_NO_DEBUG_OUTPUTपरिभाषित किए जाने पर qDebug संदेशों को ध्यान में रखा जाता है

यदि आपको स्टडआउट की आवश्यकता है तो आप कुछ इस तरह की कोशिश कर सकते हैं (जैसा कि काइल स्ट्रैंड ने बताया है):

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

फिर आप निम्नानुसार कॉल कर सकते हैं:

qStdOut() << "std out!";

1
मैंने पूछा, डिबगिंग नहीं करते समय, एक फ़ंक्शन होना चाहिए जो मुझे रनिंग के दौरान कंसोल में संदेश लिखने की अनुमति देता है, डिबगिंग के दौरान नहीं।
२.१

11
इसके नाम के बावजूद, यह फ़ंक्शन डीबगर के साथ डीबगिंग से संबंधित नहीं है। यह एक सुविधा फंक्शन है जो Qt स्टैडर को आउटपुट भेजने के लिए प्रदान करता है जिसे एक परिभाषित के साथ संकलन से हटाया जा सकता है। तो यह रनटाइम पर कंसोल को आउटपुट प्राप्त करने के लिए एक विकल्प है।
अर्नोल्ड स्पेंस

आप सभी का बहुत-बहुत धन्यवाद, मैं यह प्रयोग कर रहा हूँ :)। मुझे लगता है कि मेरे द्वारा उपयोग किए गए किसी भी कोड को लिखने की कोई आवश्यकता नहीं है। धन्यवाद! यह सुपर उपयोगी रहा है।
लेसोनार्ज़नोव

51
# शामिल <QDebug>
डकी

62
कृपया सभी कंसोल आउटपुट के लिए qDebug का उपयोग न करें। केवल सही डिबग प्रिंट के लिए इसका उपयोग करें त्रुटियों और चेतावनियों के लिए qWarning, qCritical और qFatal का उपयोग करें। क्योंकि प्रदर्शन को बचाने और आउटपुट को अव्यवस्थित करने से एप्लिकेशन को रोकने के लिए qt_NO_DEBUG_OUTPUT के साथ संकलन करते समय qDebug स्टेटमेंट को हटाया जा सकता है।
JustMaximumPower

150

मुझे यह सबसे उपयोगी लगा:

#include <QTextStream>

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

14
मुझे नहीं पता कि उत्तर क्यों स्वीकार नहीं किया गया है, लेकिन यह सुनिश्चित करने के लिए सबसे उपयोगी है।
Semyon दानिलोव

4
माना। stderr के लिए है, ठीक है, त्रुटियों (और डिबगिंग)। यह स्वीकृत उत्तर होना चाहिए क्योंकि यह केवल एक है जो stdout और qt का उपयोग करता है।
मार्शल युबैंक

1
यह एक मेरे लिए काम करता है - और cout के माध्यम से जानकारी का उत्पादन करने के लिए सही तरीके की तरह लग रहा था
माइकल विन्सेंट

2
यदि आप त्रुटियों / चेतावनियों को मुद्रित करने के तरीके के बारे में Goz के उत्तर से जानकारी को शामिल करते हैं, साथ ही साथ थोड़ी जानकारी (उदास रूप से Goz के उत्तर की कमी लेकिन इसके नीचे मौजूद टिप्पणियों में) qDebug()आदि के बारे में वास्तव में क्या करते हैं, यह अब तक का श्रेष्ठतम उत्तर होगा। (IMO यह पहले से ही बेहतर है क्योंकि ओपी कुछ बदलने के लिए कह रहा है std::cout, लेकिन 40 मतदाता सहमत नहीं दिखाई देते हैं)।
काइल स्ट्रैंड

QTextStream qStdout() { return {stdout}; }यह एक उपयोगी तरीका हो सकता है इसे लपेटने के लिए, qWarning()आदि के साथ संगत और शायद कुछ staticराज्य अस्थायी प्रवाह से बचने के लिए?
यक्क - एडम नेवरुमोंट

36

को लिख रहे हैं stdout

यदि आप ऐसा कुछ चाहते हैं, जैसे std::cout, आपके एप्लिकेशन के मानक आउटपुट पर लिखते हैं, तो आप बस निम्नलिखित कर सकते हैं ( CapelliC के लिए क्रेडिट ):

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

यदि आप एक अस्थायी QTextStreamऑब्जेक्ट बनाने से बचना चाहते हैं , तो एक staticहैंडल बनाने के लिए एक फ़ंक्शन बनाने के लिए नीचे टिप्पणी में याक के सुझाव का पालन करें stdout:

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

...

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

flushसमय-समय पर स्ट्रीम को याद रखें कि आउटपुट वास्तव में मुद्रित है।

को लिख रहे हैं stderr

ध्यान दें कि उपरोक्त तकनीक का उपयोग अन्य आउटपुट के लिए भी किया जा सकता है। हालांकि, लिखने के लिए और अधिक पठनीय तरीके हैं stderr( Goz का श्रेय और उनके उत्तर के नीचे की टिप्पणियाँ):

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()यदि QT_NO_DEBUG_OUTPUTसंकलन-समय पर चालू किया जाता है, तो उसे बंद कर दिया जाता है।

(Goz टिप्पणी में ध्यान दिलाता है कि गैर-कंसोल ऐप्स के लिए, ये एक अलग स्ट्रीम में प्रिंट कर सकते हैं stderr।)


नोट: सभी Qt प्रिंट विधियों का मानना ​​है कि const char*तर्क ISO-8859-1 हैं, जो समाप्ति \0वर्णों के साथ एन्कोडेड स्ट्रिंग्स हैं ।


1
QTextStream qStdout() { static QTextStream r{stdout}; return r; }?
यक्क - एडम नेवरुमोंट

1
@Yakk अच्छा सुझाव! मैं अपने उत्तर में शामिल करूँगा।
काइल स्ट्रैंड

q5 के साथ संकलन करते समय qFatal () को एक त्रुटि मिलती है। एक पोस्ट पढ़ें, कि यह (वहाँ / काम हो) वैसे भी मानसिक नहीं था ... इसका उपयोग न करें! :)
रिलेस्कोप

1
@KyleStrand क्या आप उसके लिए एक फ़ंक्शन का उपयोग नहीं कर सकते? template <typename C> constexpr typename std::remove_const<typename std::remove_reference<C>::type>::type& no_const(C* c) { return const_cast<typename std::remove_const<typename std::remove_reference<C>::type>::type&>(*c); } का उपयोग करें: no_const(this).method()। आप उस फ़ंक्शन को कक्षा में एक विधि के रूप में इंजेक्ट कर सकते हैं, और फिर आपको पास करने की भी आवश्यकता नहीं होगी this: Foo& no_const() const { return ::no_const(this); } कोई टाइपोस, मैं वादा करता हूं।
मोनिका

1
@ मिच एचएम, उन लिंक और क्यूटी प्रलेखन की समीक्षा करते हुए, आप सही कह रहे हैं; मुझे यह इंगित करने के लिए कुछ भी दिखाई नहीं देता है कि अस्थायी QTextStreamवस्तुओं के कारण कोई वास्तविक ज्ञात समस्या है । संपादित।
काइल स्ट्रैंड

32

इसे अपने प्रोजेक्ट फ़ाइल में जोड़ें:

CONFIG += console

5
प्रश्न में कोई जानकारी नहीं दी गई थी कि किस निर्माण प्रणाली का उपयोग किया जा रहा है। यह उपयोग करते समय केवल प्रासंगिक है qmake
काइल स्ट्रैंड

19

आप किस चर को प्रिंट करना चाहते हैं? यदि आप QStrings से मतलब रखते हैं, तो उन्हें सी-स्ट्रिंग्स में बदलने की आवश्यकता है। प्रयत्न:

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

8
@ कोडेरापुर्पा आपको जोड़ने की जरूरत है#include <iostream>
सेबेस्टियन नेगरेजस

myString.toUtf8().data()बेहतर है क्योंकि यह असीसी रेंज के बाहर वर्णों को प्रिंट करता है। उदाहरण के लिए चीनी पात्र
पीटरचूला

8

यह भी प्रिंट की तरह एक वाक्यविन्यास है, जैसे:

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

साथ ही बहुत काम


8

प्रोजेक्ट के पास जाएं Properties -> Linker-> System -> SubSystem, फिर उसे सेट करें Console(/S)


1
यह (जैसे काइल लुत्ज़ का उत्तर) बिल्ड-सिस्टम विशिष्ट है।
काइल स्ट्रैंड

3

इस बारे में iostream पुस्तकालय और सटीक कि cout इस तरह से std की एक वस्तु है :

#include <iostream>

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

1

यदि आप stdio लाइब्रेरी का उपयोग करके stderr पर प्रिंट कर रहे हैं, तो कॉल को fflush(stderr)बफर को फ्लश करना चाहिए और आपको वास्तविक समय लॉगिंग प्राप्त करनी चाहिए।



0

खैर, इंटरनेट पर कई उदाहरणों का अध्ययन करने के बाद कि क्यूटी में एक जीयूआई से स्टैडआउट में संदेशों को कैसे आउटपुट किया जाए, मैंने qDebug () और qststallMessageHandler () स्थापित करके एक कंसोल के लिए संदेशों को पुनर्निर्देशित करने पर एक स्टैंड-अलोन उदाहरण को परिष्कृत किया है। कंसोल को GUI के समान दिखाया जाएगा और यदि आवश्यक समझा जाए तो उसे छिपाया जा सकता है। कोड आपके प्रोजेक्ट में मौजूदा कोड के साथ एकीकृत करना आसान है। यहां पूरा नमूना है और किसी भी तरह से इसका उपयोग करने के लिए स्वतंत्र महसूस करें, जब तक कि आप लाइसेंस जीएनयू जीपीएल बी 2 का पालन न करें। आपको कुछ प्रकार के एक फॉर्म का उपयोग करना होगा और एक मेनविंडो मुझे लगता है - अन्यथा नमूना चलेगा, लेकिन संभवतः छोड़ने के लिए मजबूर होने पर दुर्घटनाग्रस्त हो जाएगा। नोट: एक करीबी बटन या एक मेनू क्लोज़ के माध्यम से छोड़ने का कोई तरीका नहीं है क्योंकि मैंने उन विकल्पों का परीक्षण किया है और एप्लिकेशन अंततः हर अब और फिर दुर्घटनाग्रस्त हो जाएगा। क्लोज बटन के बिना एप्लिकेशन स्थिर होगा और आप इसे मुख्य विंडो से बंद कर सकते हैं। का आनंद लें!

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

0

"बिल्ड एंड रन"> "टर्मिनल में रन" के लिए डिफ़ॉल्ट -> सक्षम करें

इस कमांड का उपयोग करने के लिए बफर फ्लश करें -> फ़्लफ़श (स्टडआउट); आप भी उपयोग कर सकते हैं "\ n" में printfया cout

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.