Qt
qmake

Profil par défaut.

qmake est un outil d'automatisation de la construction, fourni avec le framework Qt . Il fait un travail similaire aux outils tels que CMake ou GNU Autotools , mais il est conçu pour être utilisé spécifiquement avec Qt . En tant que tel, il est bien intégré à l'écosystème Qt , notamment QT Creator IDE.

Si vous démarrez Qt Creator et sélectionnez File -> New File or Project -> Application -> Qt Widgets , Qt Creator générera un squelette de projet avec un fichier "pro". Le fichier "pro" est traité par qmake afin de générer des fichiers, qui sont à leur tour traités par les systèmes de construction sous-jacents (par exemple GNU Make ou nmake ).

Si vous avez nommé votre projet "myapp", le fichier "myapp.pro" apparaîtra. Voici comment ce fichier par défaut ressemble, avec des commentaires, qui décrivent chaque variable qmake ajoutée.

# Tells build system that project uses Qt Core and Qt GUI modules.
QT       += core gui

# Prior to Qt 5 widgets were part of Qt GUI module. In Qt 5 we need to add Qt Widgets module.
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

# Specifies name of the binary.
TARGET = myapp

# Denotes that project is an application.
TEMPLATE = app

# List of source files (note: Qt Creator will take care about this list, you don't need to update is manually).
SOURCES += main.cpp\
        mainwindow.cpp

# List of header files (note: Qt Creator will take care about this list).
HEADERS  += mainwindow.h

# List of "ui" files for a tool called Qt Designer, which is embedded into Qt Creator in newer versions of IDE (note: Qt Creator will take care about this list).
FORMS    += mainwindow.ui

Préserver la structure du répertoire source dans une construction (option "object_parallel_to_source" non documentée).

Si vous souhaitez organiser votre projet en conservant les fichiers source dans différents sous-répertoires, vous devez savoir que lors d'une génération, qmake ne conservera pas cette structure de répertoires et conservera tous les fichiers ".o" dans un seul répertoire de construction. Cela peut être un problème si vous aviez des noms de fichiers contradictoires dans différents répertoires, comme la suite.

src/file1.cpp
src/plugin/file1.cpp

Maintenant, qmake décidera de créer deux fichiers "fichier1.o" dans un répertoire de compilation, provoquant le remplacement de l'un d'eux par un autre. Le buld échouera. Pour éviter cela, vous pouvez ajouter l'option de configuration CONFIG += object_parallel_to_source à votre fichier "pro". Cela indiquera à qmake de générer des fichiers de construction qui préservent votre structure de répertoire source. De cette façon, votre répertoire de construction reflétera la structure du répertoire source et les fichiers objets seront créés dans des sous-répertoires distincts.

src/file1.o
src/plugin/file1.o

Exemple complet

QT += core
TARGET = myapp
TEMPLATE = app

CONFIG += object_parallel_to_source

SOURCES += src/file1.cpp \
           src/plugin/file1.cpp

HEADERS  += src/plugin/file1.h

Notez que l'option CONFIG object_parallel_to_source n'est pas officiellement documentée .

Exemple simple (Linux)

Window.h

#include <QWidget>

class Window : public QWidget
{
    Q_OBJECT
public:
    Window(QWidget *parent = Q_NULLPTR) : QWidget(parent) {}
}

main.cpp

#include <QApplication>
#include "Window.h"

int main()
{
    QApplication app;
    Window window;
    window.show();
    return app.exec();
}

example.pro

# The QT variable controls what modules are included in compilation.
# Note that the 'core' and 'gui' modules are included by default.
# For widget-based GUI applications, the 'widgets' module needs to be added.
QT += widgets  

HEADERS = Window.h # Everything added to the HEADER variable will be checked 
                   # to see if moc needs to run on it, and it will be run if
                   # so.

SOURCES = main.cpp # Everything added to the SOURCES variable will be compiled
                   # and (in the simple example) added to the resulting
                   # executable.

Ligne de commande

# Assuming you are in a folder that contains the above files.
> qmake         # You can also add the example.pro file if needed
> make          # qmake creates a Makefile, this runs make on it.
> ./example     # The name of the executable defaults to the .pro file name.

Exemple SUBDIRS

La capacité SUBDIRS de qmake peut être utilisée pour compiler un ensemble de bibliothèques dont chacune dépend d'une autre. L'exemple ci-dessous est légèrement compliqué pour montrer les variations avec la capacité SUBDIRS.

Structure du répertoire

Certains des fichiers suivants seront omis dans un souci de concision. Ils peuvent être supposés être le format en tant qu'exemples non-subdir.

project_dir/
-project.pro
-common.pri
-build.pro
-main.cpp
-logic/
----logic.pro
----some logic files
-gui/
----gui.pro
----gui files

project.pro

C'est le fichier principal qui active l'exemple. C'est aussi le fichier qui serait appelé avec qmake sur la ligne de commande (voir ci-dessous).

TEMPLATE = subdirs  # This changes to the subdirs function.  You can't combine 
                    # compiling code and the subdirs function in the same .pro
                    # file.

# By default, you assign a directory to the SUBDIRS variable, and qmake looks
# inside that directory for a <dirname>.pro file.
SUBDIRS = logic

# You can append as many items as desired.  You can also specify the .pro file
# directly if need be.
SUBDIRS += gui/gui.pro

# You can also create a target that isn't a subdirectory, or that refers to a
# different file(*).
SUBDIRS += build
build.file = build.pro # This specifies the .pro file to use
# You can also use this to specify dependencies.  In this case, we don't want 
# the build target to run until after the logic and gui targets are complete.
build.depends = logic gui/gui.pro

(*) Voir la documentation de référence pour les autres options pour une cible de sous-répertoires.

common.pri

#Includes common configuration for all subdirectory .pro files.
INCLUDEPATH += . ..
WARNINGS += -Wall

TEMPLATE = lib

# The following keeps the generated files at least somewhat separate 
# from the source files.
UI_DIR = uics
MOC_DIR = mocs
OBJECTS_DIR = objs

logique / logic.pro

# Check if the config file exists
! include( ../common.pri ) {
    error( "Couldn't find the common.pri file!" )
}

HEADERS += logic.h
SOURCES += logic.cpp

# By default, TARGET is the same as the directory, so it will make 
# liblogic.so (in linux).  Uncomment to override.
# TARGET = target

gui / gui.pro

! include( ../common.pri ) {
    error( "Couldn't find the common.pri file!" )
}

FORMS += gui.ui
HEADERS += gui.h
SOURCES += gui.cpp

# By default, TARGET is the same as the directory, so it will make 
# libgui.so (in linux).  Uncomment to override.
# TARGET = target

build.pro

TEMPLATE = app

SOURCES += main.cpp

LIBS += -Llogic -Lgui -llogic -lgui

# This renames the resulting executable
TARGET = project

Ligne de commande

# Assumes you are in the project_dir directory
> qmake project.pro # specific the .pro file since there are multiple here.
> make -n2 # This makes logic and gui concurrently, then the build Makefile.
> ./project # Run the resulting executable.

Exemple de bibliothèque

Un exemple simple pour créer une bibliothèque (plutôt qu'un exécutable, qui est la valeur par défaut). Variable TEMPLATE spécifie le type du projet que vous effectuez. lib option lib permet à makefile de construire une bibliothèque.

library.pro

HEADERS += library.h
SOURCES += library.cpp

TEMPLATE = lib

# By default, qmake will make a shared library.  Uncomment to make the library 
# static.
# CONFIG += staticlib

# By default, TARGET is the same as the directory, so it will make 
# liblibrary.so or liblibrary.a (in linux).  Uncomment to override.
# TARGET = target

Lorsque vous staticlib une bibliothèque, vous pouvez ajouter des options dll (par défaut), staticlib ou plugin - plugin à CONFIG .

Création d'un fichier de projet à partir du code existant

Si vous avez un répertoire avec les fichiers source existants, vous pouvez utiliser qmake avec le -project -option pour créer un fichier de projet.

Supposons que le dossier MyProgram contienne les fichiers suivants:

• main.cpp
• foo.h
• foo.cpp
• bar.h
• bar.cpp
• sous-répertoire / foobar.h
• sous-répertoire / foobar.cpp

Puis en appelant

qmake -project

un fichier MyProgram.pro est créé avec le contenu suivant:

######################################################################
# Automatically generated by qmake (3.0) Mi. Sep. 7 23:36:56 2016
######################################################################

TEMPLATE = app
TARGET = MyProgram
INCLUDEPATH += .

# Input
HEADERS += bar.h foo.h subdir/foobar.h
SOURCES += bar.cpp foo.cpp main.cpp subdir/foobar.cpp

Le code peut alors être construit comme décrit dans cet exemple simple .