Qt for beginners — Hello World !

<<< Introduction | Summary | A pretty button >>>

We are now ready to create our first window. And it will be as usual, a hello world.

Qt Creator features

Before writing our first GUI app, let’s discover Qt Creator.

Qt Creator is yet another IDE for C++, but it is very well suited for coding Qt applications. It provides a doc browser and the “designer”, which makes creation of windows easier, all wrapped in a well-designed user interface. It’s also one of the fastest IDE’s available.

Here are some features of Qt Creator : Qt Creator overview.

Our first window

Let’s start by creating our first project. It will be an empty project, so we have to proceed with:
File > New file or project > Other Projects > Empty Qt Project

Create a new project

Follow the wizard, and after selecting the project folder and name, and select the version of Qt to use, you should land on this page

pro editor

This is the project file (extension .pro). Qt uses a command line tool that parses these project files in order to generate “makefiles”, files that are used by compilers to build an application. This tool is called qmake. But, we shouldn’t bother too much about qmake, since Qt Creator will do the job for us.

In a project file, there is some minimal code that should always be written :

  1. TEMPLATE = app
  2. TARGET = name_of_the_app
  3.  
  4. QT = core gui
  5.  
  6. greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

  • TEMPLATE describes the type to build. It can be an application, a library, or simply subdirectories.
  • TARGET is the name of the app or the library.
  • QT is used to indicate what libraries (Qt modules) are being used in this project. Since our first app is a small GUI, we will need QtCore and QtGui.

Let’s now add the entry point of our application. Using File > New file or project > C++ > C++ Source file should do the job.

Create main

Follow the wizard once again, naming the file “main”, and you are done.
You will notice that in the project file, a new line has been added automatically by Qt Creator :

  1. TEMPLATE = app
  2. TARGET = name_of_the_app
  3.  
  4. QT = core gui
  5.  
  6. SOURCES += \
  7.     main.cpp

Headers and sources files can be added manually with

  1. HEADERS += first_file.h second_file.h
  2. SOURCES += first_file.cpp second_file.cpp

or

  1. HEADERS += first_file.h \
  2.            second_file.h
  3. SOURCES += first_file.cpp \
  4.            second_file.cpp

If you use Qt Creator’s wizards, this is done automatically.

The minimal source code of a Qt application is

  1. #include <QApplication>
  2.  
  3. int main(int argc, char **argv)
  4. {
  5.     QApplication app (argc, argv);
  6.     return app.exec();
  7. }

QApplication is a very important class. It takes care of input arguments, but also a lot of other things, and most notably, the event loop. The event loop is a loop that waits for used input in GUI applications.

When calling app.exec(); the event loop is launched.

Let’s compile this application. By clicking on the green arrow on the bottom left, Qt Creator will compile and execute it. And what happened ? The application seems to be launched and not responding. That is actually normal. The event loop is running and waiting for events, like mouse clicks on a GUI, but we did not provide any event to be processed, so it will run indefinitely.

Let’s add something to be displayed.

  1. #include <QApplication>
  2. #include <QPushButton>
  3.  
  4. int main(int argc, char **argv)
  5. {
  6.     QApplication app (argc, argv);
  7.  
  8.     QPushButton button ("Hello world !");
  9.     button.show();
  10.  
  11.     return app.exec();
  12. }

Compile it, and … here it is ! Our first window !

Our first window

How is a Qt program compiled

Qt Creator does the job for us, but it might be interesting to know how Qt programs are compiled.

For small programs, it is easy to compile everything by hand, creating objects files, then linking them. But for bigger projects, the command line easily becomes hard to write. If you are familiar with Linux, you may know that all the programs are compiled using a makefile that describes all these command lines to execute. But for some projects, even writing a makefile can become tedious.

qmake generates those makefiles for you. With a simple syntax, it produces the makefile that is used to compile a Qt program. But that is not its only goal. Qt uses meta-objects to extend C++ functionalities, and qmake is responsible to prepare a makefile that contains this meta-object extraction phase. You will see this in another chapter.

So, Qt apps are compiled in 3 steps

  1. A .pro file is written to describe the project to compile
  2. A makefile is generated using qmake
  3. The program is build using make (or nmake or jom on windows)

<<< Introduction | Summary | A pretty button >>>

Categories: