Konzolové programy v Qt 4 – 1 (úvod)

10. 7. 2009 | David Watzke | Programování | 7057×

Tento seriál bude pojetím připomínat sérii článků o programování GUI programů v Qt 4 a lišit se bude v zaměření. Zaměřovat se budu na součásti, které k běhu nevyžadují modul QtGui a tedy ani X server. Některé věci je zbytečné předvádět graficky, zatímco jiné se do konzole přímo hodí.

Než se pustíte do dalšího čtení, doporučuji prohlédnout si alespoň první díl seriálu o GUI, protože základy jsou podobné a nemá význam opakovat zde celý úvod od začátku.

Cílovou skupinou tohoto seriálu jsou lidé s alespoň základními znalostmi C++. Ačkoliv bude veškerý kód okomentovaný, cílem seriálu není vyučování základů C++.

Jak začít?

Je to celkem prosté. Ve funkci main() místo QApplication vytvoříte instanci QCoreApplication a pak už se jen stačí vyhýbat součástem z modulu QtGui.

První ukázkový program, který jsem připravil, slouží k práci s datem. Zadáte nějaké datum a můžete k němu přičítat (nebo od něj odečítat) dny (d), měsíce (m) a roky (y). Ukázka:

$ ./qdatemod today -7d +1m
neděle, 10. května 2009 -> středa, 3. června 2009

$ ./qdatemod 1.1.1970 +39y +4m +9d
čtvrtek, 1. ledna 1970 -> neděle, 10. května 2009

main.cpp: Nejjednodušší možná varianta. Vytvoříme instanci hlavní třídy a nespouštíme smyčku událostí pomocí app.exec(), protože by nám zde byla k ničemu. Místo toho vracíme hodnotu metody run(), která implementuje veškerou funkčnost.

#include <QCoreApplication>

#include "datemod.h"

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

	DateMod main;

	return main.run();
}

datemod.h: API.

#ifndef DATEMOD_H
#define DATEMOD_H

#include <QObject>

#include <QDate>
#include <QStringList>
#include <QTextStream>

class DateMod : public QObject
{
public:
	DateMod();
	int run();

private:
	int error(QString text, int retcode = 1);

	QDate baseDate;
	QStringList argList;
	QTextStream Output;
};

#endif // DATEMOD_H

datemod.cpp: Zde je novinkou použití třídy QTextStream, která poskytuje rozhraní pro čtení a zápis textu. V programu je použita pro zápis na standardní chybový výstup.

#include "datemod.h"

#include <QCoreApplication>
#include <QDebug>

DateMod::DateMod() : Output(stderr, QIODevice::WriteOnly)
{
	// uložíme si seznam argumentů
	argList << QCoreApplication::arguments();
	// a odstraníme první položku (název spouštěného souboru)
	argList.removeFirst();
}

int DateMod::run()
{
	// potřebujeme alespoň 1 argument (datum)
	if(argList.size() < 1)		
		return error(tr("Need at least one argument (a 'd.M.yyyy' date)!"));

	// načteme zadané datum ("today" nastaví dnešní datum)
	if(argList.first() != tr("today"))
	{
		baseDate = QDate::fromString(argList.first(), "d.M.yyyy");

		if(baseDate.isNull())
			return error(tr("The date you've entered is not valid.") + " " +
				     tr("It's not 'd.M.yyyy' or it doesn't exist or it's out of range."));
	} else
		baseDate = QDate::currentDate();

	// odstraníme ze seznamu první argument
	argList.removeFirst();

	// pokud nemáme žádné další argumenty, vypíšeme samotné datum
	if(!argList.size())
		return error(baseDate.toString(Qt::DefaultLocaleLongDate), 0);

	// regulární výraz, který nám pomůže odfiltrovat zjevné nesmysly a
	// dostat z řetězce potřebné části
	QRegExp regex("^([+-]?[0-9]+)([dmy])$");
	QDate newDate = baseDate;

	// dokud seznam argumentů není prázdný
	while(!argList.isEmpty())
	{
		// pokud argument neodpovídá regulárnímu výrazu
		if(!argList.first().contains(regex))
			return error(tr("Invalid argument: ") + argList.first());

		// odstraníme první argument
		argList.removeFirst();

		bool ok = false;
		// převedeme zadané číslo na integer
		int add = regex.cap(1).toInt(&ok);
		// a zkontrolujeme, zda se to podařilo
		if(!ok)
			return error(tr("Conversion of ") + regex.cap(1) + tr(" to int failed."));
		// uložíme si znak na konci argumentu
		char what = regex.cap(2)[0].toAscii();

		// podle toho, jaký je na konci argumentu znak, přidáme k aktuálnímu datu
		// zadaný počet dní, měsíců nebo roků
		switch(what)
		{
		case 'd':
			newDate = newDate.addDays(add);
			break;
		case 'm':
			newDate = newDate.addMonths(add);
			break;
		case 'y':
			newDate = newDate.addYears(add);
			break;
		default:
			break;
		}

		// pokud nové datum není validní
		if(newDate.isNull())
			return error(tr("Shifted date is invalid (probably out of range)."));
	}

	// když vše proběhne v pořádku, vypíšeme původní a nové datum
	return error(baseDate.toString(Qt::DefaultLocaleLongDate) + " -> " +
		     newDate.toString(Qt::DefaultLocaleLongDate), 0);
}

// vypíše text na std. chybový výstup a vrátí hodnotu retcode
int DateMod::error(QString text, int retcode)
{
	// vypíšeme text
	Output << text << "\n";
	Output.flush();

	return retcode;
}

Zdrojáky si můžete stáhnout v archívu qdatemod.tar.bz2.

Spouštění externích procesů

Občas se stane, že z programu potřebujete spustit nějakou utilitu. Pro tyto účely je v Qt k dispozici třída QProcess, která v tomto směru nabízí zajímavé možnosti. Její použití si nyní předvedeme na jednoduchém příkladu.

Na rozdíl od předchozího programu bude mít tento smyčku událostí, i když by se bez ní obešel. Nikdy totiž neuškodí – spíš naopak, je to taková jistota, že po sobě program stihne uklidit v každém případě.

Program spouští příkaz

/sbin/ip address show

a parsuje z jeho výstupu názvy síťových rozhraní v systému. Výstup by měl být stejný, jako když na GNU/Linuxu spustíte

/sbin/ip a | sed -nr '/^[0-9]+:/ s/^[^:]+: ([^:]+).*/\1/p'

Na mém systému toto (i následující program) vypíše:

lo
marvell
nvidia
sit0
vboxnet0

Následuje kód:

main.cpp:

#include <QCoreApplication>
#include <QTimer>

#include "process.h"

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

        // toto zajistí ukončení programu po jeho vykonání
        QTimer::singleShot(0, &a, SLOT(quit()));

        // vytvoříme instanci hlavní třídy
        Process main;
        // a spustíme program
        main.run();

        // spustíme smyčku událostí, která se v tomto případě
        // v podstatě hned ukončí
        return a.exec();
}

process.h: API.

#ifndef PROCESS_H
#define PROCESS_H

#include <QObject>
#include <QStringList>
#include <QProcess>

// třídu zakládám na QObject, jelikož používám sloty a lokalizační systém Qt
class Process : public QObject
{
        Q_OBJECT
public:
        Process();
        void run();

private:
        QProcess* process;
        QString executable;
        QStringList arguments;

private slots:
        void handleOutput(int, QProcess::ExitStatus);
        void handleError(QProcess::ProcessError);
};

#endif // PROCESS_H

process.cpp:

#include "process.h"
#include <QDebug>

Process::Process()
{
        // vytvoříme instanci objektu QProcess
        process = new QProcess(this);

        // cesta k programu, který budeme spouštět
        executable = "/sbin/ip";
        // argumenty programu
        arguments << "address" << "show";

        // propojíme signály procesu se sloty této třídy
        connect(process, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(handleOutput(int,QProcess::ExitStatus)));
        connect(process, SIGNAL(error(QProcess::ProcessError)), this, SLOT(handleError(QProcess::ProcessError)));
}

// zpracuje chybový signál (vypíše chybovou hlášku)
void Process::handleError(QProcess::ProcessError error)
{
        switch(error)
        {
        case QProcess::FailedToStart:
                qDebug() << tr("The process failed to start. (Either the file doesn't exist, or you have insufficient permissions to invoke it.)");
                break;
        case QProcess::Crashed:
                qDebug() << tr("The process crashed.");
                break;
        case QProcess::ReadError:
                qDebug() << tr("An error occurred when attempting to read from the process.");
                break;
        default:
                qDebug() << tr("An unknown error occurred.");
                break;
        }
}

// zpracuje výstup programu; vypíše seznam síťových rozhraní
void Process::handleOutput(int /*retcode*/, QProcess::ExitStatus status)
{
        if(status == QProcess::CrashExit)
        {
                qDebug() << tr("process crashed, quitting");
                return;
        }

        // vezme celý výstup programu a rozdělí jej do seznamu,
        // kde každý řádek představuje jednu položku
        QList<QByteArray> outlines = process->readAllStandardOutput().split('\n');

        // vytvoříme si regulární výraz (s referencí)
        // tento regexp hledá číslo na začátku, za ním dvojtečku a jako referenci bere
        // řetězec, který je za tím (až po další dvojtečku)
        // například z "1: abc: def" bude reference "abc"
        QRegExp rx("^[0-9]+: ([^:]+)");

        // otevřeme si std. výstup pro zápis
        QTextStream out(stdout, QIODevice::WriteOnly);

        // postupně projdeme každý řádek
        for(int i=0; i<outlines.size(); i++)
                // pokud výraz odpovídá
                if(rx.indexIn(outlines[i]) != -1)
                        // vypíšeme první referenci
                        out << rx.cap(1) << '\n';

        out.flush();
}

void Process::run()
{
        // spustí program s danými argumenty
        process->start(executable, arguments);
        // čeká, dokud se program neukončí
        process->waitForFinished(-1);
}

Zdrojáky si můžete stáhnout v archívu process.tar.bz2.

       

Komentáře

[__]

Includovat v C++ pouze same hlavickove soubory z C, s jedinou vyjimkou (QT4) jasne ukazuje ze pouzivat C++ pro tvorbu programu pro SHELL je spatne. Pouzivat navic jeste QT4 pro text-mode programy je jeste vice spatne. Spravne by se melo pouzit treba glib a kod by mel byt C99 ci GNU99.

[David Watzke]

Kde includuju hlavičkový soubory z C?

Pouzivat navic jeste QT4 pro text-mode programy je jeste vice spatne.

Jakto?

Spravne by se melo pouzit treba glib a kod by mel byt C99 ci GNU99.

Řekl kdo?

[Deleted [8409]]

To nic, jeden z dalších fanatiků. On asi myslel tvůj "process.h"

[Dvorak]

Toto by profesionální programátor nikdy neřekl.

I v konzolových aplikacích je potřeba spousta věcí jako networking, XML processing, regexp, threads,a dalsí a další, pro které má QT výbornou podporu (multiplatformově).

Navíc, objektové programování je jasná cesta ve většině jazyků. Proto dnes prosazovat čisté cécko zda se být prochu mimo.

 

[Petr Tomášek]

A proč ne raději glib?

[Lojza]

 Protože je to článek o QT, ne?  Taky se v diskuzi pod článkem o gtk+ budete ptát, proč nepoužít raději GLib? POkdu tomu rozumíte, tak sem rovnou napište důvody k upřednostnění GLib a pokud jenom z nudy machrujete, tak jsem na vás ztratil čas (což mě mrzí. ale neomlouvám se).

[Petr Tomášek]

On tu nějaký článek o Gtk+ je?

[Max]

Buď vůbec nechápeš, na co reaguješ, nebo máš potřebu reagovat a tak musíš plácnout i sebevětší kravinu, jelikož nemáš žádné rozumné argumenty .
Zdar Max

[andree]

hmm, tak to vela stastia, az budes chciet nakodit konzolovy renderer napr. html+css, alebo nejaku corba aplikaciu verim, ze ti vtedy nejaka ta "spatnost" da dostatocny dovod, preco napisat 10x viac kodu, a umerne viac dokumentacie a chyb :)

[vencas]

1. Je možné vytvořit v qt4 konzolovou aplikaci, která si pak může, pokud to potřebuje, otevřít nějaké okno, pak ho zase zavřít, normálně pokračovat jen v konzoli atd? V qt3 to dělám tak, že program běží na konzoli zcela bez qt, pak v určitou chvíli zavolám XInitThreads(); app=new QApplication(0,NULL);, vyhodí to sice varování QApplication: invalid Display* argument, ale pak normálně funguje. Má na to qt4 nějaké čisté řešení?
2. Pokud qt4 defaultně používá evenloop z glib, dá se pak udělat, že by si ten zpočátku konzolový program otvíral okna qt+gtk(+tk z nějakých starých python skriptů) mixovaně a fungovalo by to?

Dík, Venca

[David Watzke]

1) Nikdy jsem to nezkoušel, ale když se nad tím zamyslím, tak můžeš zkusit vytvořit QApplication hned na začátku, jako bys to udělal v grafickém programu a potom prostě něco provádět a zavolat show() na nějakej widget (okno) až když ho budeš chtít zobrazit. Budeš si u toho okna asi muset reimplementovat closeEvent() nebo tak.

[mikro]

ide to este jednoduchsie -- ako vravis, cesta je cez klasicke QDialog::show() miesto exec() + treba nastavit, nech sa aplikacia neukonci po zavreti posledneho okna, tusim to je v QApplication triede alebo nejakych global flagoch.

[David Watzke]

Dá se to nastavit přes QApplication property quitOnLastWindowClosed.

[Petr Tomášek]

Řešením je použít glib a vůbec se Qt nezabývat... (mimochodem, na tom vidíte, že gtk+/glib je líp navržena, než celá slavná Qt, prostě nikoho nenutí používat X-y...)

[Mark]

Ha. Vieš na čom je najlepšie vidieť, že gtk+/glib je lepšie navrhnutá než celá slávna Qt? Na tom, že ma dlhší názov. 9-2=7, takže gtk+/glib musí byť 7 krát lepšie navrhnutá.

[|🇵🇸]

Vždyť je to zlomek a 'g' se vykrátí...

[Mark]

[Deleted [8409]]

Děláte ze sebe jenom vola

[Petr Tomášek]

To je argument jak prase...

[Deleted [8409]]

že gtk+/glib je líp navržena

je argument ještě lepší

[Petr Tomášek]

Ano, to totiž argument je. Glib můžu použít v konzolové aplikaci na systému bez X11 + gtk+...

[Deleted [8409]]

QtCore taky, dál?

[Michal Vyskočil]

S Qt „zabyjis svobodu. Je tvoji povinosti pouzit svobodny toolkit ktery je prenositelny a pouziva GNOME !!!

[Max]

Nu, vzhledem k tomu, že už je rozumně licencováno, tak už to asi neplatí, ne?
Zdar Max

[xkucf03]

A před tím snad nebylo rozumně licencováno? (GPL)

[Deleted [8409]]

LOL +1, toto jsem četl poprvé:)

[andree]

hm, myslel som ze qt gui bezi aj na platformach, ktore Xka vobec nepoznaju... hm, co sa tu dnes nedozviem :)

[Fuky]

QApplication: Invalid Display* argument

A je nějaké rozumné odůvodnění předchozí hlášky v případě, že argc = 0, argv = NULL? Nějakou diskuzi jsem našel, ale nic rozumného z ní nevyplynulo. V GTK lze použít gtk_init(NULL, NULL); v Qt se zbavuju otravné hlášky:

int argc = 1;
char *argv[1];
QApplication app(argc, argv);

Jak to řešit "čistě"?

[Fuky]

Už vím, předpokládal jsem, že volám:

QApplication ( int & argc, char ** argv )

Ale z app(0, NULL); usoudil kompilátor, že chci volat:

QApplication ( Display * dpy, HANDLE visual = 0, HANDLE colormap = 0 )

Viz ./gui/kernel/qapplication.cpp:

    if (! dpy)
        qWarning("QApplication: Invalid Display* argument");

[vencas]

Huráá, super, díky!! Podařilo se mi to očůrat takhle:

int argc=0;
app=new QApplication(argc,(char**)NULL);

Tím se vybere ten správný overload a varování se nezobrazí.

Náš administrátor shledal tento komentář závadným.

vulgární

Zobrazit komentář

[mirec]

Minule som sa pokúšal urobiť aplikáciu schopnú vyrenderovať HTML stránku a exportovať ju do PDF. Je možné používať QPainter aj bez GUI? Neviem prečo, ale keď som nemal zobrazené žiadne okno aplikácia vždy havarovala. Pritom nepotrebujem QPainter použiť na vykresľovanie okna, ale iba na vykreslenie do súboru ...

A ešte jedna drobnosť, neviem či poznáte knižnice ako Turbo Vision. Bolo by krásne ak by niektoré GUI prvky (základné) fungovali aj v konzole (niečo ako ncurses s tým, že by aplikácia nebežiaca v X zobrazila jednoduché rozhranie skladajúce sa z ASCII znakov). Žiaľ Qt je zamerané len na klasické okná :(

[s0]

QPainter je soucasti modulu QtGui, takze s cistym QtCore pouzit nejde. Samotne kresleni "do souboru", t.j. na jakykoliv podporovany "device" lze kreslit bez oken. Akorat musi existovat instance QAppliaction.

[David Watzke]

A QtGui potřebuje X server (i když v tomhle případě nemusí běžet), takže třeba na serveru to je fakt radost...

[limit_false]

Potreba X11 se da "obejit" pouzitim Xvnc nebo Xvfb. Dalsi zpusob je opatchovat Qt jak to dela napr. http://code.google.com/p/wkhtmltopdf/

[mirec]

No kreslenie funguje kým nepoužijem fonty. U fontov využíva niečo z X aj keď kreslí do súboru :(

[limit_false]

S "textovym" Qt nejde moc dobre psat daemony, ktere se potrebuji fork()-nout na pozadi. (I kdyz platformne nezavisle wrappery jako QTcpSocket mohou navadet k tomu psat neco takoveho. BTW QTcpSocket je taky plny prekvapeni, hlavne signaly v neocekavanou dobu.)

U libICE existuje race condition, ktera zpusobi ze libICE po forknuti programu zacne psat do spatnych socketu (a program spadne). Tenhle race condition sa neprojevi vzdy, jenom na nekterych systemech. Je samozrejme mozne skompilovat Qt bez podpory libICE, ale pokud vim je to vzdy by default zapnuto na vsech distribucich.