Einführung

C++ GUI mit Qt

Rudolf Lehn

Schülerforschungszentrum
Bad Saulgau
Inhaltsverzeichnis

1 Konzepte und Konstrukte von Qt 1

1.1 Allgemeine Qt-Hinweise 1
1.1.1 Installations- und Ausführungshinweise unter SuSE-Linux 1
1.1.2 Installations- und Ausführungshinweise unter Windows 2
1.1.3 Installations- und Ausführungshinweise unter MAC OS X 2
1.2 Das erste Qt-Programm: qHello 2
1.3 Addition zweier ganzer Zahl mit Qt 4
1.4 Signal-Slot-Konzept bei Qt 7
1.4.1 Vordefinierte Signal-Slot-Verbindungen 7
1.4.2 Selbstdefinierte Signal-Slot-Verbindungen 7
1.5 C++ Programm zur Messwerterfassung mit Qt 8
1.6 Zinseszinsberechnung mit C++ unter Qt 11
1.7 Punkt- und Pfeiloperator bei Qt-Objekten 15
1.8 Häufigkeiten mit Qt 16
1.9 Grafik - Simulation 20
1.10 Zusammenfassung zu Kapitel 1 23
 Vorbemerkung
Das folgende Skript gibt eine grundlegende Einführung in die Qt Programmierung.
Literatur:
• Helmut Herold: Das Qt Buch
• J. Blanchette, M. Summerfield: C++ GUI - Programmierung mit Qt3
• M. K. Dalheimer et al.: Practical Qt
• Online-Dokumentation von Trolltech:
http://www.trolltech.com/documentation/index.html
Ein Update des Skripts wird auf der URL www.sfz-bw.de veröffentlicht.
Hinweise und Korrekturen werden erbeten an sfz@rlehn.com.
1. Konzepte und Konstrukte von Qt

1.1. Allgemeine Qt-Hinweise

Qt ist eine von der norwegischen Firma Troll Tech entwickelte C++ Klassenbibliothek, die eine ein-
fach und plattformunabhängige GUI-Programmierung (Graphical User Interface) ermöglicht.
Qt arbeitet mit sogenannten Widgets, welche Benutzerschnittstellen für die Eingabesteuerung oder
für grafische Darstellungen sind. Nahezu alles, was man auf einer in Qt geschriebenen Oberflä-
che sieht, ist ein Widget: Buttons, Laufbalken, Dialogboxen, . . . . Widgets können ihrerseits wieder
Subwidgets enthalten. In Qt ist ein Widget ein Objekt einer Klasse, die von der Klasse QWidget
abgeleitet ist.

1.1.1. Installations- und Ausführungshinweise unter SuSE-Linux

Qt wird normalerweise unter SuSE gleich mitinstalliert, da KDE mit Qt betrieben wird. Man muss
nur noch schauen, ob die Verzeichnisse so in /.profile gesetzt sind, dass qmake (erzeugt das Qt-
Projekt) vom Benutzerverzeichnis aus aufgerufen werden kann.
Beispiel für ein ~/.profile:
QTDIR=/usr/lib/qt3;
PATH=$QTDIR/bin:$PATH;
MANPATH=$QTDIR/man:$MANPATH;
LD_LIBRARY_PATH=$QTDIR/lib:$LD_LIBRARY_PATH;
Hier ist in /usr/lib das qt zu finden. Die aktuellen Einstellungen können mit dem echo-Befehl
geprüft werden, z. B. echo $QTDIR.
Jedes Qt-Projekt wird in ein eigenes Verzeichnis gelegt. Es ist also (jedenfalls für den Anfang) sinn-
voll, das Qt-Programm (d. h. ein C++ Programm) gleich in dieses Verzeichnis zu schreiben. Soll
z. B. das Qt-Projekt qHello hergestellt werden, dann könnte das qHello.cpp Programm z. B. in
~/compiler/cc/Qt/qHello/ stehen. Anschließend wird es mit den folgenden drei Anweisungen
zu einem lauffähigen Programm qHello gemacht:
qmake -project
qmake
make
Mit dem ersten Kommando qird ein .pro (project) File erzeugt. Mit dem zweiten Kommando
wird ein makefile basierend auf dem Projektfile erzeugt. Mit make wird dann eine lauffähige Qt-
Applikation hergestellt.

1
 . Mai  1. Konzepte und Konstrukte von Qt

1.1.2. Installations- und Ausführungshinweise unter Windows

Die Qt/Windows Distribution wird als selbst-extrahierendes Archivfile mit einem eingebauten In-
stallationsprogramm zum Downloaden angeboten.
Die Windowsversion wird hier noch nicht beschrieben!

1.1.3. Installations- und Ausführungshinweise unter MAC OS X

Die Qt/MAC Distribution wird als selbst-extrahierendes Archivfile mit einem eingebauten Instal-
lationsprogramm zum Downloaden angeboten unter
http://www.trolltech.com/download/qt/mac.html
• Wie bei Linux müssen die Verzeichnisse so in /.profile gesetzt sind, dass qmake (erzeugt das
Qt-Projekt) vom Benutzerverzeichnis aus aufgerufen werden kann.
QTDIR=/Developer/qt
PATH=$QTDIR/bin:$PATH
MANPATH=$QTDIR/doc/man:$MANPATH
DYLD_LIBRARY_PATH=$QTDIR/lib:$DYLD_LIBRARY_PATH
export QTDIR PATH MANPATH DYLD_LIBRARY_PATH
• Lies INSTALL
cd $QTDIR
./configure -thread
/usr/bin/make
sudo ln -sf $QTDIR/lib/libqt-mt.3.dylib /usr/lib
sudo ln -sf $QTDIR/lib/libqui.1.dylib /usr/lib
Bei MAC OS X wird wie bei Linux im Textfenster die Übersetzung vorgenommen. Der Aufruf des
Programms wird allerdings nicht aus dem Textfensterheraus durchgeführt, sondern über den Fin-
der.

1.2. Das erste Qt-Programm: qHello

Jetzt soll - immer mit einem Blick auf die Designerergebnisse - ein helloQt-Programm entwickelt
werden. Erstelle ein Verzeichnis, in dem das Qt-Projekt helloQt untergebracht wird. Erstelle mit
einem beliebigen Editor folgendes C++ Programm helloQt.cpp.
1 #include <qapplication.h> // ... fuer jedes Qt−Programm
2 #include <qlabel.h> // ... fuer Klasse QLabel
3 #include <qpushbutton.h> // ... fuer Klasse QPushButton
4 #include <qfont.h> // ... fuer Klasse QFont
5 int main( int argc , char * argv [] )
6 {
7 // Jedes Qt−Programm beginnt mit der Einrichtung eines QApplication−Objekts
8 QApplication* myapp = new QApplication( argc, argv );
9


 . Mai  1. Konzepte und Konstrukte von Qt

10 // Einrichtung eines Hauptfensters , in dem andere Fenster

11 // mit Text , Buttons ... untergebracht werden koennen
12 QWidget* mywidget = new QWidget();
13 // ... horizontale , vertikale Position von links oben ; Breite und Hoehe in Pixel
14 mywidget−>setGeometry(200,100,300,150);
15
16 // Einrichtung eines Labels ( d.h . nur Text)
17 QLabel* mylabel = new QLabel( "Hello SFZ−Friends!", mywidget);
18 // Relative Position (40,50) in mywidget; (200 breit , 50 hoch)
19 mylabel−>setGeometry(40,50,200,50);
20 // Schriftart waehlen
21 mylabel−>setFont(QFont("Times", 18, QFont::Bold));
22
23 /* Mit folgender Anweisung wird ein Button erzeugt
24 Der 1. Parameter legt den Button−Text fest
25 Der 2. Parameter legt das Elternwidget fest , in dem
26 dieser Button erscheinen soll − hier mywidget
27 */
28 QPushButton* button = new QPushButton("Quit",mywidget);
29 button−>setGeometry(40,100,80,40);
30
31 /* Mit der Methode connect() wird als Reaktion auf das Eintreffen des
32 Signals clicked () die vordefinierte Slotroutine quit () ausgef\"uhrt,
33 die zur sofortigen Beendigung des Programms f\"uhrt.
34 */
35 QObject::connect(button, SIGNAL(clicked()), &myapp, SLOT(quit()));
36
37 // myapp soll die Rolle des Hauptwidgets uebernehmen.
38 myapp−>setMainWidget( mywidget);
39 // Zeige das Hauptwidget mit seinen Subwidgets an
40 mywidget−>show();
41 // Kontrolle des Programmablaufs wird an myapp uebergeben
42 return myapp−>exec();
43 }

Jetzt muß qmake und make aufgerufen werden.

Grundstruktur der Qt-Programme
#include <qapplication.h> // ... fuer jedes Qt-Programm
#include <q....h> // ... fuer die weiteren notwendigen Klassen Q....

.....

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

{
// Jedes Qt-Programm beginnt mit der Einrichtung eines QApplication-Objekts
QApplication* myapp = new QApplication( argc, argv );

// Einrichtung eines Hauptfensters, in dem andere Fenster


 . Mai  1. Konzepte und Konstrukte von Qt

// mit Text, Buttons ... untergebracht werden koennen

QWidget* mywidget = new QWidget();
// ... horizontale, vertikale Position von links oben; Breite und Hoehe in Pixel
mywidget->setGeometry(x_pos, y_pos,breite,hoehe);
...........

// myapp soll die Rolle des Hauptwidgets uebernehmen.

myapp->setMainWidget( mywidget);
// Zeige das Hauptwidget mit seinen Subwidgets an
mywidget->show();
//Kontrolle des Programmablaufs wird an myapp uebergeben
return myapp->exec();
}

1.3. Addition zweier ganzer Zahl mit Qt

Erstelle ein Verzeichnis, in dem das Qt-Projekt AddGanzeZahlenQt untergebracht wird. Erstelle mit
einem beliebigen Editor folgende C++ Programmteile addganzezahlen.cpp, addganzezahlen.h
und main.cpp. Diese Programmteile sind nach den Designervorlagen gestaltet.
In dem Headerfile addganzezahlen.h sind die Klassen und Variablen vorausdefiniert, so dass sie
überall zur Verfügung stehen.
1 #ifndef ADDGANZEZAHLEN_H // siehe ??)
2 #define ADDGANZEZAHLEN_H
3
4 #include <qdialog.h>
5
6 class QLabel;
7 class QLineEdit;
8 class QPushButton;
9
10 class AddGanzeZahlen : public QDialog //eigene Slots
11 {
12 Q_OBJECT
13
14 public:
15 AddGanzeZahlen(QWidget* parent=0, const char* name=0, bool modal=FALSE, WFlags fl=0);
16 QLabel* textLabel1;
17 QLabel* textLabel2;
18 QLabel* summeTextLabel;
19 QPushButton* loeschenPushButton;
20 QPushButton* rechnePushButton;
21 QPushButton* quitPushButton;
22 QLineEdit* int1LineEdit;
23 QLineEdit* int2LineEdit;
24 QLineEdit* summeLineEdit;
25


 . Mai  1. Konzepte und Konstrukte von Qt

26 public slots :
27 void summe();
28
29 private:
30 void init () ;
31 };
32 #endif // ADDGANZEZAHLEN_H

In dem Programmteil addganzezahlen.cpp werden die Berechnungen und die Gestaltung des For-
mulars durchgeführt.
1 #include "addganzezahlen.h"
2
3 #include <qlabel.h> // fuer Klasse QLabel
4 #include <qpushbutton.h> // fuer Klasse QPushButton
5 #include <qlineedit.h> // fuer Klasse QLineEdit
6 #include <qvalidator.h> // fueer die Klasse QValidator
7
8 void AddGanzeZahlen::summe()
9 {
10 // Eingabe der ganzen Zahlen sichern
11 int integer1 = int1LineEdit−>text().toInt () ;
12 int integer2 = int2LineEdit−>text().toInt () ;
13
14 // Eingabe und Ergebnis darstellen
15 int summe = integer1 + integer2;
16 summeLineEdit−>setText(QString::number(summe));
17 }
18
19 void AddGanzeZahlen::init()
20 {
21 int1LineEdit−>setValidator(new QIntValidator(int1LineEdit));
22 int1LineEdit−>setText("50");
23 int2LineEdit−>setValidator(new QIntValidator(int2LineEdit));
24 int2LineEdit−>setText("100");
25 }
26
27 AddGanzeZahlen::AddGanzeZahlen(QWidget* parent, const char* name, bool modal, WFlags fl):
QDialog(parent, name, modal, fl)
28 {
29 // Formular aufbauen − vgl . Designervorschlag
30 // 1. und 2. ganze Zahl und die Summe
31 textLabel1 = new QLabel("1. ganze Zahl", this);
32 textLabel1−>setGeometry(60,60,100,20);
33 textLabel2 = new QLabel("2. ganze Zahl", this);
34 textLabel2−>setGeometry(60,130,100,20);
35 summeTextLabel = new QLabel("Summe", this);
36 summeTextLabel−>setGeometry(60,200,60,20);
37 // Buttons Loeschen , Rechnen und Quit


 . Mai  1. Konzepte und Konstrukte von Qt

38 loeschenPushButton = new QPushButton("Loeschen", this);

39 loeschenPushButton−>setGeometry(40,250,100,30);
40 rechnePushButton = new QPushButton("Rechnen", this);
41 rechnePushButton−>setGeometry(200,250,100,30);
42 quitPushButton = new QPushButton("&Quit", this);
43 quitPushButton−>setGeometry(350,250,100,30);
44 // Eingabefelder und Summen−Feld der ganzen Zahlen
45 int1LineEdit = new QLineEdit(this);
46 int1LineEdit−>setGeometry(200,60,100,30);
47 int2LineEdit = new QLineEdit(this);
48 int2LineEdit−>setGeometry(200,130,100,30);
49 summeLineEdit = new QLineEdit(this);
50 summeLineEdit−>setGeometry(200,200,100,30);
51 summeLineEdit−>setReadOnly(true);
52
53 QObject::connect(loeschenPushButton, SIGNAL(clicked()),
54 summeLineEdit, SLOT(clear()));
55 QObject::connect(loeschenPushButton, SIGNAL(clicked()),
56 int1LineEdit , SLOT(clear()));
57 QObject::connect(loeschenPushButton, SIGNAL(clicked()),
58 int2LineEdit , SLOT(clear()));
59 QObject::connect(quitPushButton, SIGNAL(clicked()), this, SLOT(close()));
60 QObject::connect(rechnePushButton, SIGNAL(clicked()),
61 this , SLOT(summe()));
62
63 // tab order
64 // 1. Widget und dann das 2. Widget angeben
65 setTabOrder(int1LineEdit, int2LineEdit);
66 setTabOrder(int2LineEdit, rechnePushButton);
67 setTabOrder(rechnePushButton, quitPushButton);
68
69 init () ;
70 }

Das Hauptprogramm main() ist damit nur noch wenige Zeilen lang.
1 #include <qapplication.h> // fuer jedes Qt−Programm
2 #include "addganzezahlen.h"
3
4 int main(int argc , char * argv[])
5 {
6 // Jedes Qt−Programm beginnt mit der Instantiierung eines QApplication−Objekts
7 QApplication myapp(argc, argv);
8 // Hauptfenster
9 AddGanzeZahlen* mywidget = new AddGanzeZahlen();
10
11 // Zeige das Hauptwidget mit seinen Subwidgets an
12 mywidget−>show();
13 // Kontrolle des Programmablaufs wird an myapp uebergeben


 . Mai  1. Konzepte und Konstrukte von Qt

14 return myapp.exec();
15 }

Führe folgende Schritte aus, um ein lauffähiges Programm zu erhalten:

qmake -project
qmake
make

1.4. Signal-Slot-Konzept bei Qt

Qt stell einen sogenannten Signal-Slot-Mechanismus zur Verfügung, um zwischen Widgets zu kom-

munizieren. Wenn bestimmte Ereignisse (Events) passieren, werden von den Widgets Signale aus-
gegeben. Diese Signale können mit vordefinierten oder zu selbstdefinierten Slots verbunden wer-
den.
Die Verbindung von Signalen und Slots erfolgt mit QObject::connect(). Meistens wird sie folgen-
dermaßen eingesetzt:
QOject::connect( signal_object, // Objekt, das das Signal schickt
SIGNAL(signal_name(...)),// Signal, das mit Slot zu verbinden ist
slot_object,// Objekt, welches das Signal empfaengt
SLOT(slot_name(...))); // Slot, der mit dem Signal zu verbinden ist.

1.4.1. Vordefinierte Signal-Slot-Verbindungen

QObject::connect(loeschenPushButton, SIGNAL(clicked()),
summeLineEdit, SLOT(clear()));
Mit der Methode connect() von der Klasse QObject wird als Reaktion auf das Eintreffen des Si-
gnals clicked() von loeschenPushButton die vordefinierte Slotroutine clear() in summeLineEdit
in Gang gesetzt.

1.4.2. Selbstdefinierte Signal-Slot-Verbindungen

BeispielL
QObject::connect(rechnePushButton, SIGNAL(clicked()),
this, SLOT(summe()));
Um sich Klassen zu definieren, die eigene Slots und/oder signale deklarieren, muss folgende Qt-
Syntax eingehalten werden:
Class MyClass : public QObject {
Q_OBJECT
.......
signals:
// hier werden die entsprechenden Signale deklariert, wie z.B.
void buchstabe_q_gedrueckt();


 . Mai  1. Konzepte und Konstrukte von Qt

public slots:
// hier werden die public Slots deklariert, wie z.B.
void summe();
privat slots:
// hier werden die privaten Slots deklariert, wie z.B.
void ich_bin_internSlot();
// weitere moegliche Deklarationen
}
Merke vgl. 10)
• Deklarationen von Slots und Signalen ist nur in Klassen erlaubt.
• Klassen mit eigenen Slots bzw. Signalen müssen von QObject abgeleitet sein.
• Klassen mit eigenen Slots bzw. Signalen müssen Q_OBJECT aufrufen.

1.5. C++ Programm zur Messwerterfassung mit Qt

Erstelle ein Verzeichnis, in dem das Qt-Projekt MesswerteQt untergebracht wird. Erstelle mit einem
beliebigen Editor folgende C++ Programmteile messwerte.cpp, messwerte.h und main.cpp. Diese
Programmteile sind nach den Designervorlagen gestaltet.
In dem Headerfile messwerte.h sind die Klassen und Variablen vorausdefiniert, so dass sie überall
zur Verfügung stehen.
1 #ifndef MESSWERTE_H
2 #define MESSWERTE_H
3
4 #include <qdialog.h>
5
6 class QPushButton;
7 class QLabel;
8 class QListBox;
9 class QListBoxItem;
10 class QLineEdit;
11
12 class Messwertehauptwidget : public QDialog
13 {
14 Q_OBJECT
15
16 public:
17 Messwertehauptwidget( QWidget* parent = 0, const char* name = 0, bool modal = FALSE,
WFlags fl = 0 );
18 ~Messwertehauptwidget();
19
20 QPushButton* rechnePushButton;
21 QPushButton* loeschePushButton;
22 QPushButton* quitPushButton;
23 QLabel* messwerteListeTextLabel;


 . Mai  1. Konzepte und Konstrukte von Qt

24 QListBox* messListBox;
25 QLabel* messTextLabel;
26 QLineEdit* messLineEdit;
27 QLabel* mittelTextLabel;
28 QLineEdit* mittelLineEdit;
29
30 public slots :
31 virtual void listenEintrag () ;
32 virtual void mittelwert() ;
33
34 private:
35 void init () ;
36 };
37 #endif // MESSWERTE_H

Im Programmteil messwerte.cpp werden die Messwerte eingelesen, in die Liste eingetragen und
es wird der Mittelwert berrechnet.
1 #include "messwerte.h"
2
3 #include <qpushbutton.h>
4 #include <qlabel.h>
5 #include <qlistbox.h>
6 #include <qlineedit.h>
7 #include <qvalidator.h>
8
9 void Messwertehauptwidget::init()
10 {
11 messLineEdit−>setValidator(new QIntValidator(messLineEdit));
12 }
13
14 void Messwertehauptwidget::listenEintrag()
15 {
16 // zur Liste hinzufuegen
17 messListBox−>insertItem(messLineEdit−>text());
18 messLineEdit−>clear();
19 }
20
21 void Messwertehauptwidget::mittelwert()
22 {
23 double mittel=0;
24 int maxzahl=messListBox−>count();
25 for ( int i = 0; i<maxzahl;i++)
26 {
27 QListBoxItem *item = messListBox−>item(i);
28 mittel += static_cast <double>(item−>text().toInt())/maxzahl;
29 }
30 mittelLineEdit−>setText(QString::number(mittel));
31 }


 . Mai  1. Konzepte und Konstrukte von Qt

32
33 // Konstruktor von Messwertehauptwidget als Kind von ’ parent ’
34 Messwertehauptwidget::Messwertehauptwidget( QWidget* parent, const char* name,
35 bool modal, WFlags fl )
36 : QDialog( parent, name, modal, fl )
37 {
38
39 rechnePushButton = new QPushButton("Rechnen", this);
40 rechnePushButton−>setGeometry(40,350,100,30);
41 rechnePushButton−>setAutoDefault( FALSE );
42
43 loeschePushButton = new QPushButton("Loeschen",this );
44 loeschePushButton−>setGeometry(200,350,100,30);
45 loeschePushButton−>setAutoDefault( FALSE );
46
47 quitPushButton = new QPushButton("Quit", this );
48 quitPushButton−>setGeometry(350,350,100,30);
49 quitPushButton−>setAutoDefault( FALSE );
50
51 messwerteListeTextLabel = new QLabel("Messwert−Liste" ,this);
52 messwerteListeTextLabel−>setGeometry( QRect( 60, 10, 200, 20 ) );
53 messwerteListeTextLabel−>setAlignment( int( QLabel::AlignCenter ) );
54
55 messListBox = new QListBox( this);
56 messListBox−>setGeometry( QRect( 60, 40, 200, 250 ) );
57
58 messTextLabel = new QLabel("neuer Messwert", this);
59 messTextLabel−>setGeometry( QRect( 270, 170, 100, 20 ) );
60
61 messLineEdit = new QLineEdit(this);
62 messLineEdit−>setGeometry( QRect( 400, 170, 130, 20 ) );
63 messLineEdit−>setAlignment( int( QLineEdit::AlignRight ) );
64
65 mittelTextLabel = new QLabel("Mittelwert", this);
66 mittelTextLabel−>setGeometry( QRect( 50, 300, 100, 20 ) ) ;
67 mittelTextLabel−>setAlignment( int( QLabel::AlignCenter ) );
68
69 mittelLineEdit = new QLineEdit( this);
70 mittelLineEdit−>setGeometry( QRect( 200, 300, 100, 20 ) ) ;
71 // QColor(int red , int green , int blue )
72 mittelLineEdit−>setPaletteBackgroundColor( QColor( 255, 229, 170 ) );
73 mittelLineEdit−>setReadOnly( TRUE );
74
75 // signals and slots connections
76 connect( quitPushButton, SIGNAL( clicked() ), this , SLOT( close() ) ) ;
77 connect( messLineEdit, SIGNAL( returnPressed() ), this, SLOT( listenEintrag() ) ) ;
78 connect( rechnePushButton, SIGNAL( clicked() ), this, SLOT( mittelwert() ) ) ;
79 connect( loeschePushButton, SIGNAL( clicked() ), messListBox, SLOT( clear() ) ) ;
80 connect( loeschePushButton, SIGNAL( clicked() ), mittelLineEdit, SLOT( clear() ) ) ;


 . Mai  1. Konzepte und Konstrukte von Qt

81 connect( loeschePushButton, SIGNAL( clicked() ), messLineEdit, SLOT( clear() ) ) ;

82
83 init () ;
84 }
85
86 // Destructor loescht das Objekt und gibt alle belegten Speicher wieder frei
87 Messwertehauptwidget::~Messwertehauptwidget()
88 {
89 // no need to delete child widgets , Qt does it all for us
90 }

Das Hauptprogramm main() ist damit nur noch wenige Zeilen lang.
1 #include <qapplication.h>
2 #include "messwerte.h"
3
4 int main( int argc , char * argv [] )
5 {
6 QApplication *myapp = new QApplication( argc, argv );
7 Messwertehauptwidget *mywidget = new Messwertehauptwidget();
8 mywidget−>show();
9 return myapp−>exec();
10 }

Führe folgende Schritte aus, um ein lauffähiges Programm zu erhalten:

qmake -project
qmake
make

1.6. Zinseszinsberechnung mit C++ unter Qt

Erstelle ein Verzeichnis, in dem das Qt-Projekt ZinsQt.pro untergebracht wird. Erstelle mit einem
beliebigen Editor folgende C++ Programmteile zinsmainwidget.h, zinsmainwidget.cpp und main.cpp.
Diese Programmteile sind nach den Designervorlagen gestaltet.
In dem Headerfile zinsmainwidget.h sind die Klassen und Variablen vorausdefiniert, so dass sie
überall zur Verfügung stehen.
1 #ifndef ZINSESZINSMAINWIDGET_H
2 #define ZINSESZINSMAINWIDGET_H
3 #include <qdialog.h>
4 class QPushButton;
5 class QLabel;
6 class QLineEdit;
7 class QListView;
8 class QListViewItem;
9 class zinseszinsmainwidget : public QDialog
10 {
11 Q_OBJECT


 . Mai  1. Konzepte und Konstrukte von Qt

12
13 public:
14 zinseszinsmainwidget( QWidget* parent = 0, const char* name = 0, bool modal = FALSE,
WFlags fl = 0 );
15 ~zinseszinsmainwidget();
16 QPushButton* loeschenPushButton;
17 QPushButton* quitPushButton;
18 QPushButton* rechnePushButton;
19 QLabel* zinssatzTextLabel;
20 QLabel* laufzeitTextLabel;
21 QLabel* aufzinsTextLabel;
22 QLabel* startkapTextLabel;
23 QLineEdit* startkapLineEdit;
24 QLineEdit* laufzeitLineEdit;
25 QListView* kapitalListView;
26 QLineEdit* zinssatzLineEdit;
27 public slots :
28 virtual void kapitalertrag () ;
29 private:
30 void init () ;
31 };
32 #endif // ZINSESZINSMAINWIDGET_H

Im Programmteil zinsmainwidget.cpp werden die Daten eingelesen und ein Aufzinsplan berech-
net.
1 #include "zinsmainwidget.h"
2
3 #include <qpushbutton.h>
4 #include <qlabel.h>
5 #include <qlineedit.h>
6 #include <qheader.h>
7 #include <qlistview.h>
8 #include <qlayout.h>
9 #include <qvalidator.h>
10
11 void zinseszinsmainwidget::kapitalertrag()
12 {
13 double K0 = startkapLineEdit−>text().toDouble();
14 double p = zinssatzLineEdit−>text().toDouble();
15 int n = laufzeitLineEdit−>text(). toInt () ;
16 double K = K0;
17
18 QString nstring;
19 nstring. setNum(n);
20 kapitalListView−>setSorting(−1);
21 for ( int i =1; i<=n; i++)
22 {
23 K=K0*pow(1.0 + p/100,i);


 . Mai  1. Konzepte und Konstrukte von Qt

24 QString Kstring;
25 Kstring.setNum( K );
26 QString istring ;
27 istring . setNum(i);
28
29 /*
30 for ( uint j = istring . length () ; j<nstring. length () ; j++)
31 istring . prepend (" ") ;
32 */
33 new QListViewItem(kapitalListView, istring, Kstring);
34 }
35 }
36
37 void zinseszinsmainwidget::init()
38 {
39 startkapLineEdit−>setValidator(new QDoubleValidator(startkapLineEdit));
40 zinssatzLineEdit−>setValidator(new QDoubleValidator(zinssatzLineEdit));
41 laufzeitLineEdit−>setValidator(new QIntValidator(laufzeitLineEdit));
42 }
43
44 /*
45 * Constructs a zinseszinsmainwidget as a child of ’ parent ’, with the
46 * name ’name’ and widget flags set to ’ f ’.
47 *
48 * The dialog will by default be modeless , unless you set ’ modal’ to
49 * TRUE to construct a modal dialog .
50 */
51 zinseszinsmainwidget::zinseszinsmainwidget( QWidget* parent, const char* name, bool modal,
WFlags fl )
52 : QDialog( parent, name, modal, fl )
53 {
54
55 loeschenPushButton = new QPushButton( "Loeschen",this);
56 loeschenPushButton−>setGeometry(240, 350, 100, 30);
57
58 quitPushButton = new QPushButton( "Quit", this );
59 quitPushButton−>setGeometry( 450, 350, 100, 30);
60
61 rechnePushButton = new QPushButton("Rechnen", this);
62 rechnePushButton−>setGeometry( 50, 350, 100, 30);
63
64 aufzinsTextLabel = new QLabel( "Aufzinsplan",this);
65 aufzinsTextLabel−>setGeometry( 40, 20, 200, 20);
66 aufzinsTextLabel−>setAlignment( int( QLabel::AlignCenter ) );
67
68 startkapTextLabel = new QLabel( "Startkapital in EUR",this);
69 startkapTextLabel−>setGeometry( 300, 80, 150, 20);
70 startkapTextLabel−>setAlignment( int( QLabel::AlignCenter ) );
71


 . Mai  1. Konzepte und Konstrukte von Qt

72 zinssatzTextLabel = new QLabel( "Zinssatz in %",this);

73 zinssatzTextLabel−>setGeometry(310, 150, 150, 20);
74 zinssatzTextLabel−>setAlignment( int( QLabel::AlignCenter ) );
75
76 zinssatzLineEdit = new QLineEdit("5.00",this);
77 zinssatzLineEdit−>setGeometry(450, 150, 100, 22);
78 zinssatzLineEdit−>setAlignment( int( QLineEdit::AlignRight ) );
79
80 laufzeitTextLabel = new QLabel( "Laufzeit in Jahren" ,this);
81 laufzeitTextLabel−>setGeometry(300, 230, 150, 20);
82 laufzeitTextLabel−>setAlignment( int( QLabel::AlignCenter ) );
83
84 startkapLineEdit = new QLineEdit("10000.00",this);
85 startkapLineEdit−>setGeometry(450, 80, 100, 20);
86 startkapLineEdit−>setAlignment( int( QLineEdit::AlignRight ) );
87
88 laufzeitLineEdit = new QLineEdit("10", this);
89 laufzeitLineEdit−>setGeometry(450, 230, 100, 20);
90 laufzeitLineEdit−>setAlignment( int( QLineEdit::AlignRight ) );
91
92 kapitalListView = new QListView( this);
93 kapitalListView−>addColumn("Jahre", 50);
94 kapitalListView−>addColumn("Kapital", 100);
95 kapitalListView−>setGeometry(40, 50, 155, 250);
96
97 // signals and slots connections
98 connect( quitPushButton, SIGNAL( clicked() ), this , SLOT( close() ) ) ;
99 connect( rechnePushButton,SIGNAL( clicked()),this,SLOT(kapitalertrag()) );
100 connect( loeschenPushButton,SIGNAL(clicked()),zinssatzLineEdit,SLOT(clear()));
101 connect( loeschenPushButton,SIGNAL(clicked()),laufzeitLineEdit,SLOT(clear()));
102 connect( loeschenPushButton,SIGNAL(clicked()),startkapLineEdit,SLOT(clear()));
103 connect( loeschenPushButton,SIGNAL(clicked()),kapitalListView,SLOT(clear()));
104
105 init () ;
106 }
107
108 /*
109 * Destroys the object and frees any allocated resources
110 */
111 zinseszinsmainwidget::~zinseszinsmainwidget()
112 {
113 // no need to delete child widgets , Qt does it all for us
114 }

Führe folgende Schritte aus, um ein lauffähiges Programm zu erhalten:

qmake -project
qmake
make


 . Mai  1. Konzepte und Konstrukte von Qt

1.7. Punkt- und Pfeiloperator bei Qt-Objekten

Auf die Qt-Objekte kann - wie allgemein auf Klassenobjekte - mit dem Punktoperator (.) oder dem
Pfeiloperator (->) zugegriffen werden.
In der Qt-Dokumentation ist für die Klasse QPushButton die folgende Anweisung zu finden: QPushButton
::QPushButton ( const QString & text, QWidget * parent, const char * name = 0 );. Das & gibt an, dass
die Adresse der Variablen text anzugeben ist und *parent gibt an, dass parent Zeiger auf die
QWidget-Elternklasse ist.
Für die Klasse QWidget steht in der Dokumentation die Anweisung QWidget ( QWidget * parent
= 0, const char * name = 0, WFlags f = 0 ) ; . Werden keine Angaben gemacht, dann werden die Stan-
dardeinstellungen (0) genommen und das Widget ist das top-Widget.
Punktoperator
{
#include <qapplication.h>
#include <qpushbutton.h>
#include <qstring.h>

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

{

QApplication myapp(argc, argv);

QWidget mywidget;
mywidget.setGeometry(50,200,600,600);
QPushButton quitPushButton("Quit",&mywidget);
quitPushButton.setGeometry(200,300,100,30);
myapp.setMainWidget(&mywidget);
mywidget.show();
return myapp.exec();
}

Pfeiloperator
{
#include <qapplication.h>
#include <qpushbutton.h>
#include <qstring.h>

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

{

QApplication myapp(argc, argv);

QWidget *mywidget = new QWidget();
mywidget−>setGeometry(50,200,600,600);
QPushButton *quitPushButton = new QPushButton("Quit",mywidget);
quitPushButton−>setGeometry(200,300,100,30);
myapp.setMainWidget(mywidget);
mywidget−>show();


 . Mai  1. Konzepte und Konstrukte von Qt

return myapp.exec();
}

Auch QApplication hätte mit einem Pfeiloperator geschrieben werden können.

QApplication *myapp = new QApplication(argc, argv);. Dann lautet die return-Anweisung return
myapp−>exec().
Die Pfeil- und Punktoperatoren können in einem Programm wechselseitig verwendet werden.

1.8. Häufigkeiten mit Qt

wuerfel.h
1 #ifndef WUERFEL_H
2 #define WUERFEL_H
3
4 #include <qdialog.h>
5
6 class QVBoxLayout;
7 class QHBoxLayout;
8 class QLabel;
9 class QPushButton;
10 class QLineEdit;
11 class QFrame;
12
13 class wuerfel : public QDialog
14 {
15 Q_OBJECT
16
17 public:
18 wuerfel( QWidget* parent = 0, const char* name = 0, bool modal = FALSE, WFlags fl = 0 );
19 ~wuerfel();
20
21 QLabel* wuerfelTextLabel;
22 QPushButton* quitPushButton;
23 QLabel* wurfzahlTextLabel;
24 QPushButton* neuPushButton;
25 QLineEdit* wurfzahlLineEdit;
26 QFrame* frame;
27 QLabel* textLabel1;
28
29 public slots :
30 virtual void haeufigkeiten();
31
32 protected:
33
34 protected slots :
35 virtual void languageChange();


 . Mai  1. Konzepte und Konstrukte von Qt

36
37
38 private:
39 void init () ;
40
41 };
42
43 #endif // WUERFEL_H

wuerfel.cpp
1 #include "wuerfel.h"
2
3 #include <qlabel.h>
4 #include <qpushbutton.h>
5 #include <qlineedit.h>
6 #include <qframe.h>
7 #include <qlayout.h>
8 #include <qimage.h>
9 #include <qpixmap.h>
10 #include <qvalidator.h>
11
12 const int arraySize = 7; // nur Index 1 bis 6 werden gewaehlt
13 int haeufigkeit[arraySize ] = {0};
14 QLabel *haeufigkeitsLabel[arraySize];
15 int max = 0; // maximale Haeufigkeit einer Augenzahl
16
17
18 void wuerfel:: init ()
19 {
20 wurfzahlLineEdit−>setValidator(new QIntValidator(wurfzahlLineEdit));
21 }
22
23 void wuerfel::haeufigkeiten()
24 {
25 int az;
26 srand(time(0));
27 int maxWZ = wurfzahlLineEdit−>text().toInt();
28 // int maxWZ = 100;
29
30 for ( int anz=1; anz <= maxWZ; anz++)
31 {
32 az = 1 + rand()%6;
33 if (++haeufigkeit[az]>max)
34 max = haeufigkeit[az];
35 }
36 double faktor = (double)frame−>height()/max;
37 for ( int i=1;i<arraySize; i++)
38 {


 . Mai  1. Konzepte und Konstrukte von Qt

39 haeufigkeitsLabel[i]−>
40 setGeometry(QRect(frame−>width()/(arraySize−1)*(i−1)+2,
41 int(frame−>height()−haeufigkeit[i]*faktor),
42 frame−>width()/(arraySize−1)−4,
43 int(haeufigkeit[ i ]* faktor) ) ) ;
44 }
45 }
46
47 wuerfel::wuerfel( QWidget* parent, const char* name, bool modal, WFlags fl )
48 : QDialog( parent, name, modal, fl )
49 {
50
51 wuerfelTextLabel = new QLabel(this, "wuerfelTextLabel");
52 wuerfelTextLabel−>setGeometry( QRect( 130, 40, 290, 40 ) );
53 QFont wuerfelTextLabel_font( wuerfelTextLabel−>font() );
54 wuerfelTextLabel_font.setBold( TRUE );
55 wuerfelTextLabel−>setFont( wuerfelTextLabel_font );
56 wuerfelTextLabel−>setFrameShape( QLabel::MenuBarPanel );
57 wuerfelTextLabel−>setAlignment( int( QLabel::AlignCenter ) );
58
59 quitPushButton = new QPushButton(this, "quitPushButton");
60 quitPushButton−>setGeometry( QRect( 320, 390, 120, 32 ) );
61 quitPushButton−>setAutoDefault( FALSE );
62
63 wurfzahlTextLabel = new QLabel(this, "wurfzahlTextLabel");
64 wurfzahlTextLabel−>setGeometry( QRect( 150, 340, 151, 31 ) );
65 wurfzahlTextLabel−>setAlignment( int( QLabel::AlignCenter ) );
66
67 neuPushButton = new QPushButton(this, "neuPushButton");
68 neuPushButton−>setGeometry( QRect( 120, 390, 120, 32 ) );
69
70 wurfzahlLineEdit = new QLineEdit(this, "wurfzahlLineEdit");
71 wurfzahlLineEdit−>setGeometry( QRect( 310, 340, 100, 22 ) );
72 wurfzahlLineEdit−>setAlignment( int( QLineEdit::AlignRight ) );
73
74 frame = new QFrame( this, "frame" );
75 frame−>setGeometry( QRect( 110, 90, 300, 200 ) );
76 frame−>setFrameShape( QFrame::StyledPanel );
77 frame−>setFrameShadow( QFrame::Raised );
78
79 QString str ;
80 for ( int i =1; i < arraySize ; i++)
81 {
82 str . sprintf ( "%d",i) ;
83 haeufigkeitsLabel[i ]= new QLabel(str, frame);
84 haeufigkeitsLabel[i]−>setAlignment(Qt::AlignTop| Qt::AlignHCenter);
85 haeufigkeitsLabel[i]−>setPaletteBackgroundColor(Qt::darkBlue);
86 haeufigkeitsLabel[i]−>setPaletteForegroundColor(Qt::white);
87 }


 . Mai  1. Konzepte und Konstrukte von Qt

88
89 haeufigkeiten() ;
90 double faktor = (double)frame−>height()/max;
91 for ( int i=1;i<arraySize; i++)
92 {
93 haeufigkeitsLabel[i]−>
94 setGeometry(QRect(frame−>width()/(arraySize−1)*(i−1)+2,
95 int(frame−>height()−haeufigkeit[i]*faktor),
96 frame−>width()/(arraySize−1)−4,
97 int(haeufigkeit[ i ]* faktor) ) ) ;
98 }
99
100 languageChange();
101
102 // signals and slots connections
103 connect( quitPushButton, SIGNAL( clicked() ), this , SLOT( close() ) ) ;
104 connect( wurfzahlLineEdit, SIGNAL( returnPressed() ),
105 this , SLOT( haeufigkeiten() ) ) ;
106
107 // tab order
108 init () ;
109 }
110
111 /*
112 * Destroys the object and frees any allocated resources
113 */
114 wuerfel::~wuerfel()
115 {
116 // no need to delete child widgets , Qt does it all for us
117 }
118
119 /*
120 * Sets the strings of the subwidgets using the current
121 * language.
122 */
123 void wuerfel::languageChange()
124 {
125 setCaption( trUtf8 ( "Wuerfeln" ) ) ;
126 wuerfelTextLabel−>setText( trUtf8( "Haeufigkeitsverteilung beim Wuerfeln" ) );
127 quitPushButton−>setText( tr( "Quit" ) ) ;
128 wurfzahlTextLabel−>setText( trUtf8( "Anzahl der Wuerfe" ) );
129 neuPushButton−>setText( tr( "Neues Spiel" ) );
130 wurfzahlLineEdit−>setText( tr( "100" ) ) ;
131 // textLabel1 −>setText( tr ( " AZ" ) ) ;
132 }

main.cpp
1 #include <qapplication.h>


 . Mai  1. Konzepte und Konstrukte von Qt

2 #include "wuerfel.h"
3
4 int main( int argc , char ** argv )
5 {
6 QApplication a( argc, argv ) ;
7 wuerfel w;
8 w.show();
9 a.connect( &a, SIGNAL( lastWindowClosed() ), &a, SLOT( quit() ) );
10 return a.exec() ;
11 }

Wechsle in das Verzeichnis, in dem das W?ºrfel-Projekt erstellt wurde und gib in einem Textfenster
folgende Befehle ein.
qmake -project
qmake
make

1.9. Grafik - Simulation

Im Folgenden wird ein einfaches Modell dargestellt, welches das Einsickern von Öl ins Erdreich
simuliert. Man stellt sich einen vertikalen Schnitt durch den Erdboden vor. Anfangs soll das Öl sich
in den mittleren beiden Vierteln der oberen Erdschicht, und zwar an jedem zweiten Pixel befinden.
Über das Eindringen des Öls in den Erdboden werden folgende Annahmen gemacht:
• Befindet sich Öl an der Position (x,y), so dringt es mit der Wahrscheinlichkeit p(0 6 p 6 1) in
die nächsttiefere Schicht zur Position (x − 1, y + 1) und unabhängig davon ebenfalls mit der
Wahrscheinlichkeit p zur Stelle (x + 1, y + 1) vor.
• Befindet sich an der Stelle (x,y) kein Öl, so gelangt natürlich von dieser Position auch keine
Flüssigkeit in die nächsttiefere Erdschicht.
• Das Programm simuliert das Einsickern des Öls, indem es zufällig als Wahrscheinlichkeit für
die Bodenbeschaffenheit einen Wert zwischen 0,6 bis 0,75 auswählt.
• Mit jedem Mausklick über dem Malfenster wird eine neue Simulation gestartet.
1 #include <qapplication.h>
2 #include <qwidget.h>
3 #include <qlabel.h>
4 #include <qpainter.h>
5 #include <stdlib.h>
6 #include <time.h>
7 #define MAXX 1000
8 #define MAXY 600
9 // ........................................................ Klasse MalFenster
10 class MalFenster : public QWidget
11 {
12 protected:
13 virtual void mousePressEvent( QMouseEvent * ) {


 . Mai  1. Konzepte und Konstrukte von Qt

14 delete l ;
15 repaint ( true ) ;
16 }
17 virtual void paintEvent( QPaintEvent* ) {
18 int x , y;
19 QColor schicht[MAXX+1],
20 schichtDrueber[MAXX+1];
21 bool nochOel = true;
22 // .......... Beschaffenheit des Bodens zufaellig
23 QString s ;
24 int prozent = rand() % 16 + 60; // 60..75%
25 int grenze = RAND_MAX/100*prozent;
26 s . sprintf ( " Bodendurchl\"assigkeit: %d %%\n", prozent );
27 l = new QLabel( this );
28 l−>setGeometry( 0, MAXY, MAXX, 40 );
29 l−>setPalette( QPalette( Qt ::white, Qt ::white ) ) ;
30 l−>setText( s ) ;
31 l−>show();
32 // .......... Eindringen des Oels am Bildschirm simulieren
33 QPainter maler( this ) ; // erzeugt QPainter−Objekt zum Zeichnen
34 maler.setBackgroundColor( Qt::lightGray );
35 for ( x =0 ; x<=MAXX ; x++)
36 schichtDrueber[x] = Qt::lightGray;
37 for ( x=MAXX/4 ; x<=MAXX*3/4 ; x++) {
38 maler.setPen( schichtDrueber[x] = x%2 ? Qt::blue : Qt::lightGray ) ;
39 maler.drawPoint( x, 0 ) ;
40 }
41 for ( y =0 ; y<MAXY && nochOel; y++) {
42 nochOel = false;
43 for ( x =0 ; x<=MAXX ; x++)
44 if ( schichtDrueber[x]==Qt::blue || schichtDrueber[x]==Qt::red) {
45 nochOel = true;
46 if ( x−1>=0 ) {
47 maler.setPen( schicht[x−1] =
48 rand()<=grenze ? Qt::blue : Qt::lightGray ) ;
49 maler.drawPoint( x−1, y+1 );
50 }
51 if ( x+1<=MAXX ) {
52 maler.setPen( schicht[x+1] =
53 rand()<=grenze ? Qt::red : Qt::lightGray ) ;
54 maler.drawPoint( x+1, y+1 );
55 }
56 }
57 for ( x =0 ; x<=MAXX ; x++) {
58 schichtDrueber[x] = schicht[x ];
59 schicht[x ] = Qt::lightGray;
60 }
61 }
62 }


 . Mai  1. Konzepte und Konstrukte von Qt

63 private:
64 QLabel *l;
65 };
66 // ..................................................................... main
67 int main( int argc , char * argv [] )
68 {
69 QApplication myapp( argc, argv );
70 srand(time(NULL));
71 MalFenster* mywidget = new MalFenster;
72 mywidget−>setGeometry( 50, 50, MAXX, MAXY+40 );
73 srand( time( NULL ) );
74 myapp.setMainWidget( mywidget );
75 mywidget−>show();
76 return myapp.exec();
77 }

Zeile-für-Zeile Erläuterungen
• Malfenster ist eine Subklasse von QWidget.
⊲ Um abgeleiteten Klassen gegenüber der Öffentlichkeit weitgehende Rechte einräumen
zu können, ohne den privaten Status mancher Elemente aufzugeben, gibt es den Zu-
griffsspezifizierer protected. Daten und Methoden sind in der eigenen in in allen public
abgeleiteteden Klassen zugreifbar, nicht aber in anderen Klassen oder außerhalb der
Klasse.
⊲ Die Klasse QLabel kann zur Anzeige von Text verwendet werden. Mit der von der der
Klasse QWidget geerbten Methode setGeometry() wird die relative Position dieses La-
bles im übergeordneten Widget festgelegt. Auch die Methode setpalette wird von
QWidget angeboten. Übergibt man ihrem Konstruktor zwei Farben wie in der Anweisung
l->setPalette( QPalette( Qt::blue, Qt::yellow ));, dann werden diese Farben
als Button- (blue) und Background-Farben (yellow) benutzt. Alle anderen Farben der
drei Farbgruppen (RGB) werden automatisch berechnet, so dass die Kontraste scharf
sind. Setzt man zwei gleich Farben - wie im Programm - dann ist das Label einfarbig.
Die QLabel-Methode setText(s) setzt den Text s in das Label-Widget. Die wieder von
QWidget geerbete Methode show() zeigt den Widget-Inhalt an.
⊲ virtual void mousePressEvent( QMouseEvent * ) {
delete l ;
repaint ( true ) ;
}

Soll erst zur Laufzeit entschieden werden, welches Objekt angesprochen wird, dann
können virtuelle Funktionen der Basisklassen überladen werden. Die Deklaration einer
Funktion als virtual bewirkt, dass Objekten indirekt die Information über den Objekt-
typ mitgegeben wird.
Der erste Klick auf eine Maustaste führt zu einem Aufruf der Methode mousePressEvent().
An die Methode mousePressEvent wird ein Zeiger auf ein Objekt der Klasse QMouseEvent
übergeben.


 . Mai  1. Konzepte und Konstrukte von Qt

Die Methode paintEvent wird aufgerufen, wenn ein Widget oder ein Teil davon neu
gezeichnet werden muss. Dies ist z. B. nach einem Aufruf der Methode show() der Fall.
⊲ Unter Qt können mit der Farbklasse QColor Farben festgelegt werden. Eine der Möglich-
keiten besteht darin, vordefinierte QColor-Objekte zu verwenden.
schicht[x] = Qt::lightGray;
⊲ Die QString-Klasse ist eine Abstraktion zum C-Stringkozept, wo das String-Ende durch
ein 0-Byte gekennzeichnet ist (vgl. ??). Die QString-Methoden akzeptieren die char*-
Parameter. Es ist aber zu beachten, dass Funktionen, die C-Strings in ein QString-Objekt
kopieren, das abschließende 0-Byte nicht mitkopieren, da ein String in einem QString-
Objekt nicht wie in klassischen C-Strings mit einem 0-Byte abgeschlossen ist, sondern
die Länge des jeweiligen Strings intern mitgeführt wird. Ein nicht-initialisiertes QString-
Objekt hat den Wert null, d. h. sowohl die interne Länge als auch sein Datenzeiger sind
auf 0 gesetzt. Die Methode s.sprintf(" Bodendurchl\"assigkeit: %d %%\n", prozent )
gibt unter Kontrolle eines Formatstrings Argumente aus. Jede Spezifikation wird mit
dem %-Zeichen eingeleitet. Wenn die Variable den Wert 0.7 hat, dann wird hier ausgege-
ben: Bodendurchl\"assigkeit 0.7 % , d. h. %d zeigt an, dass das Argument prozent
als ganze Zahl zu behandeln ist.
⊲ QPainter maler( this ); erzeugt ein QPainter-Objekt, mit dem in ein QWidget-Objekt
gezeichnet werden kann. Diese Klasse kann alles zeichnen, von einfachen Linien bis zu
komplexen Figuren.
• int prozent = rand() % 16 + 60; erzeugt in Kombination mit srand eine Zufallszahl (vgl.
??).
Hinweis:
Zu Qt gibt es eine umfangreiche Online-Dokumentation:
http://doc.trolltech.com/3.3/index.html

1.10. Zusammenfassung zu Kapitel 1

1. Qt arbeitet mit sogenannten Widgets, welche Benutzerschnittstellen für die Eingabesteuerung

oder für grafische Darstellungen sind.
Grundstruktur der Qt-Programme:
#include <qapplication.h>
#include <q ... h>
...

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

{
QApplication myapp(argc,argv);
QWidget *mywidget = new Qwidget();
mywidget−>setGeometry(x_pos,y_pos,breite,hoehe);
........
........


 . Mai  1. Konzepte und Konstrukte von Qt

myapp.setMainWidget(myWidget);
mywidget−>show();
return myapp.exec();
}

2. Beispiel für das Signal-Slot-Konzept von Qt

Mit
connect( slider, SIGNAL(valueChanged(int)), lcd, SLOT(display(int)) );
wird festgelegt, dass bei jeder Änderung des Schiebebalkenwerts das Signal valueChanged(int)
mit dem aktuellen Schiebebalken-Wert als Argument geschickt und dieses Argument an die
Slotroutine display(int) weitergereicht wird.

