1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
---
category: tool
tool: Qt Framework
language: C++
filename: learnqt-de.cpp
contributors:
- ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
translators:
- ["Dennis Keller", "https://github.com/denniskeller"]
lang: de-de
---
**Qt** ist ein weithin bekanntes Framework zum Entwickeln von cross-platform Software,
die auf verschiedenen Hard- und Softwareplatformen mit wenig oder keinen Veränderungen im Code läuft.
Dabei besitzt man die Power und Geschiwindigkeit von nativen Anwendungen.
Obwohl **Qt** ursprünglich in *C++* geschrieben wurde,
gibt es verschiedene Ports für andere Sprachen: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
**Qt** eignet sich hervorragend zum Erstellen von Anwendungen mit grafischer Benutzeroberfläche (GUI).
Dieses Tutorial zeigt, wie man das in *C++* macht.
```c++
/*
* Lass uns klassisch starten
*/
// Alle Header vom Qt Framework starten mit dem Großbuchstaben 'Q'.
#include <QApplication>
#include <QLineEdit>
int main(int argc, char *argv[]) {
// Erstellt ein Objekt um applikationsweit die Resourcen zu managen.
QApplication app(argc, argv);
// Erstellt ein Line edit Widget und zeigt es auf dem Bildschirm
QLineEdit lineEdit("Hello world!");
lineEdit.show();
// Startet die Event Loop der Anwendung.
return app.exec();
}
```
Die GUI bezogene Teile von **Qt** bestehen aus *Widgets* und den *Verbindungen*
dazwischen.
[Lies mehr über Widgets](http://doc.qt.io/qt-5/qtwidgets-index.html)
```c++
/*
* Lass uns Label und einen Button machen.
* Ein Label soll auftauchen, wenn der Button gedrückt wird.
*
* Der Qt Code spricht für sich selbst.
*/
#include <QApplication>
#include <QDialog>
#include <QVBoxLayout>
#include <QPushButton>
#include <QLabel>
int main(int argc, char *argv[]) {
QApplication app(argc, argv);
QDialog dialogWindow;
dialogWindow.show();
// Füge ein vertikales Layout hinzu
QVBoxLayout layout;
dialogWindow.setLayout(&layout);
QLabel textLabel("Danke für das Knopf drücken");
layout.addWidget(&textLabel);
textLabel.hide();
QPushButton button("Drück mich");
layout.addWidget(&button);
// Zeigt verstecktes Label, wenn der Button gedrückt wird.
QObject::connect(&button, &QPushButton::pressed,
&textLabel, &QLabel::show);
return app.exec();
}
```
Beachte den *QObject::connect* Teil. Diese Methode wird verwendet,
um *Signale* eines Objekts mit den *Slots* eines Objektes zu verbinden.
**Signale** werden ausgegeben, wenn bestimmte Dinge mit Objekten passieren.
Beispielsweise wird das *pressed* Signal ausgegeben,
wenn der Benutzer auf das QPushButton Objekt drückt.
**Slots** sind Aktionen, die als Reaktion auf empfangene Signale ausgeführt werden können.
[Lies mehr über Slots und Signale](http://doc.qt.io/qt-5/signalsandslots.html)
Als Nächstes lernen wir, dass wir nicht nur Standard Widgets verwenden können,
sondern auch ihr Verhalten mithilfe von Vererbung verändern können.
Lass uns einen Button erschaffen, der zählt, wie häufig er gedrückt wird.
Dafür definieren wir unsere eigene Klasse *CounterLabel*.
Diese muss wegen der speziellen Qt Architektur in einer seperaten Datei deklariert werden.
```c++
// counterlabel.hpp
#ifndef COUNTERLABEL
#define COUNTERLABEL
#include <QLabel>
class CounterLabel : public QLabel {
Q_OBJECT // Qt definiertes Makro, welches in jedem modifizierten Widget vorhanden sein muss.
public:
CounterLabel() : counter(0) {
setText("Zähler wurde noch nicht erhöht."); // Methode von QLabel
}
public slots:
// Aktion, die ausgeführt wird, wenn der Button gedrückt wird.
void increaseCounter() {
setText(QString("Zähler Wert: %1").arg(QString::number(++counter)));
}
private:
int counter;
};
#endif // Zähllabel
```
```c++
// main.cpp
// Fast das Gleiche, wie das vorherige Beispiel
#include <QApplication>
#include <QDialog>
#include <QVBoxLayout>
#include <QPushButton>
#include <QString>
#include "counterlabel.hpp"
int main(int argc, char *argv[]) {
QApplication app(argc, argv);
QDialog dialogWindow;
dialogWindow.show();
QVBoxLayout layout;
dialogWindow.setLayout(&layout);
CounterLabel counterLabel;
layout.addWidget(&counterLabel);
QPushButton button("Drück mich nochmal.");
layout.addWidget(&button);
QObject::connect(&button, &QPushButton::pressed,
&counterLabel, &CounterLabel::increaseCounter);
return app.exec();
}
```
Das wars! Natürlich ist das Qt Framework erheblich größer, als der der Teil der in diesem Tutorial behandelt wurde.
Das heißt, es gibt viel zu lesen und zu üben.
## Further reading
- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html)
- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
Viel Erfolg und viel Spaß!
|
