A Boilerplate Application

The best way to understand Qt is to start from a small example. This application creates a simple "Hello World!" string and writes it into a file using Unicode characters.

  1. #include <QCoreApplication>
  2. #include <QString>
  3. #include <QFile>
  4. #include <QDir>
  5. #include <QTextStream>
  6. #include <QDebug>
  9. int main(int argc, char *argv[])
  10. {
  11.     QCoreApplication app(argc, argv);
  13.     // prepare the message
  14.     QString message("Hello World!");
  16.     // prepare a file in the users home directory named out.txt
  17.     QFile file(QDir::home().absoluteFilePath("out.txt"));
  18.     // try to open the file in write mode
  19.     if(!file.open(QIODevice::WriteOnly)) {
  20.         qWarning() << "Can not open file with write access";
  21.         return -1;
  22.     }
  23.     // as we handle text we need to use proper text codecs
  24.     QTextStream stream(&file);
  25.     // write message to file via the text stream
  26.     stream << message;
  28.     // do not start the eventloop as this would wait for external IO
  29.     // app.exec();
  31.     // no need to close file, closes automatically when scope ends
  32.     return 0;
  33. }

The example demonstrates the use of file access and the how to write text to a a file using text codecs using a text stream. For binary data, there is a cross-platform binary stream called QDataStream that takes care of endianess and other details. The different classes we use are included using their class name at the top of the file. You can also include classes using the module and class name e.g. #include <QtCore/QFile>. For the lazy, there is also the possibility to include all the clases from a module using #include <QtCore>. For instance, in QtCore you have the most common classes used for an application that are not UI related. Have a look at the QtCore class listA Boilerplate Application - 图1 (opens new window) or the QtCore overviewA Boilerplate Application - 图2 (opens new window).

You build the application using CMake and make. CMake reads a project file, CMakeLists.txt and generates a Makefile which is used to build the application. CMake supports other build systems too, for example ninja. The project file is platform independent and CMake has some rules to apply the platform specific settings to the generated makefile. The project can also contain platform scopes for platform-specific rules, which are required in some specific cases.

Here is an example of a simple project file generated by Qt Creator. Notice that Qt attempts to create a file that is compatible with both Qt 5 and Qt 6, as well as various platforms such as Android, OS X and such.

  1. cmake_minimum_required(VERSION 3.14)
  3. project(projectname VERSION 0.1 LANGUAGES CXX)
  5. set(CMAKE_INCLUDE_CURRENT_DIR ON)
  7. set(CMAKE_AUTOUIC ON)
  8. set(CMAKE_AUTOMOC ON)
  9. set(CMAKE_AUTORCC ON)
  11. set(CMAKE_CXX_STANDARD 11)
  12. set(CMAKE_CXX_STANDARD_REQUIRED ON)
  14. # QtCreator supports the following variables for Android, which are identical to qmake Android variables.
  15. # Check https://doc.qt.io/qt/deployment-android.html for more information.
  16. # They need to be set before the find_package(...) calls below.
  18. #if(ANDROID)
  19. #    set(ANDROID_PACKAGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/android")
  20. #    if (ANDROID_ABI STREQUAL "armeabi-v7a")
  21. #        set(ANDROID_EXTRA_LIBS
  22. #            ${CMAKE_CURRENT_SOURCE_DIR}/path/to/libcrypto.so
  23. #            ${CMAKE_CURRENT_SOURCE_DIR}/path/to/libssl.so)
  24. #    endif()
  25. #endif()
  27. find_package(QT NAMES Qt6 Qt5 COMPONENTS Core Quick REQUIRED)
  28. find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core Quick REQUIRED)
  30. set(PROJECT_SOURCES
  31.         main.cpp
  32.         qml.qrc
  33. )
  35. if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
  36.     qt_add_executable(projectname
  37.         MANUAL_FINALIZATION
  38.         ${PROJECT_SOURCES}
  39.     )
  40. else()
  41.     if(ANDROID)
  42.         add_library(projectname SHARED
  43.             ${PROJECT_SOURCES}
  44.         )
  45.     else()
  46.         add_executable(projectname
  47.           ${PROJECT_SOURCES}
  48.         )
  49.     endif()
  50. endif()
  52. target_compile_definitions(projectname
  53.   PRIVATE $<$<OR:$<CONFIG:Debug>,$<CONFIG:RelWithDebInfo>>:QT_QML_DEBUG>)
  54. target_link_libraries(projectname
  55.   PRIVATE Qt${QT_VERSION_MAJOR}::Core Qt${QT_VERSION_MAJOR}::Quick)
  57. set_target_properties(projectname PROPERTIES
  58.     MACOSX_BUNDLE_GUI_IDENTIFIER my.example.com
  59.     MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
  60.     MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
  61. )
  63. if(QT_VERSION_MAJOR EQUAL 6)
  64.     qt_import_qml_plugins(projectname)
  65.     qt_finalize_executable(projectname)
  66. endif()

We will not go into the depths of this file. Just remember Qt uses CMake’s CMakeLists.txt files to generate platform-specific makefiles, that are then used to build a project. In the build system section we will have a look at more basic, handwritten, CMake files.

The simple code example above just writes the text and exits the application. For a command line tool, this is good enough. For a user interface you need an event loop which waits for user input and somehow schedules draw operations. Here follows the same example now uses a button to trigger the writing.

Our main.cpp surprisingly got smaller. We moved code into an own class to be able to use Qt’s signal and slots for the user input, i.e. to handle the button click. The signal and slot mechanism normally needs an object instance as you will see shortly, but it can also be used with C++ lambdas.

  1. #include <QtCore>
  2. #include <QtGui>
  3. #include <QtWidgets>
  4. #include "mainwindow.h"
  7. int main(int argc, char** argv)
  8. {
  9.     QApplication app(argc, argv);
  11.     MainWindow win;
  12.     win.resize(320, 240);
  13.     win.setVisible(true);
  15.     return app.exec();
  16. }

In the main function we create the application object, a window, and then start the event loop using exec(). For now, the application sits in the event loop and waits for user input.

  1. int main(int argc, char** argv)
  2. {
  3.     QApplication app(argc, argv); // init application
  5.     // create the ui
  7.     return app.exec(); // execute event loop
  8. }

Using Qt, you can build user interfaces in both QML and Widgets. In this book we focus on QML, but in this chapter, we will look at Widgets. This lets us create the program only C++.

image

The main window itself is a widget. It becomes a top-level window as it does not have any parent. This comes from how Qt sees a user interface as a tree of UI elements. In this case, the main window is the root element, thus becomes a window, while the push button, that is a child of the main window, becomes a widget inside the window.

  1. #ifndef MAINWINDOW_H
  2. #define MAINWINDOW_H
  4. #include <QtWidgets>
  6. class MainWindow : public QMainWindow
  7. {
  8. public:
  9.     MainWindow(QWidget* parent=0);
  10.     ~MainWindow();
  11. public slots:
  12.     void storeContent();
  13. private:
  14.     QPushButton *m_button;
  15. };
  17. #endif // MAINWINDOW_H

Additionally, we define a public slot called storeContent() in a custom section in the header file. Slots can be public, protected, or private, and can be called just like any other class method. You may also encounter a signals section with a set of signal signatures. These methods should not be called and must not be implemented. Both signals and slots are handled by the Qt meta information system and can be introspected and called dynamically at run-time.

The purpose of the storeContent() slot is that is is called when the button is clicked. Let’s make that happen!

  1. #include "mainwindow.h"
  3. MainWindow::MainWindow(QWidget *parent)
  4.     : QMainWindow(parent)
  5. {
  6.     m_button = new QPushButton("Store Content", this);
  8.     setCentralWidget(m_button);
  9.     connect(m_button, &QPushButton::clicked, this, &MainWindow::storeContent);
  10. }
  12. MainWindow::~MainWindow()
  13. {
  15. }
  17. void MainWindow::storeContent()
  18. {
  19.     qDebug() << "... store content";
  20.     QString message("Hello World!");
  21.     QFile file(QDir::home().absoluteFilePath("out.txt"));
  22.     if(!file.open(QIODevice::WriteOnly)) {
  23.         qWarning() << "Can not open file with write access";
  24.         return;
  25.     }
  26.     QTextStream stream(&file);
  27.     stream << message;
  28. }

In the main window, we first create the push button and then register the signal clicked() with the slot storeContent() using the connect method. Every time the signal clicked is emitted the slot storeContent() is called. And now, the two objects communicate via signal and slots despite not being aware of each other. This is called loose coupling and is made possible using the QObject base class which most Qt classes derive from.