Premiers pas avec qmake

Ce tutoriel vous enseigne les bases de qmake. Les autres rubriques de ce manuel contiennent des informations plus détaillées sur l'utilisation de qmake.

Commencer simplement

Supposons que vous venez de terminer l'implémentation de base de votre application et que vous avez créé les fichiers suivants :

• hello.cpp
• hello.h
• main.cpp

Vous trouverez ces fichiers dans le répertoire examples/qmake/tutorial de la distribution Qt. La seule autre chose que vous savez sur la configuration de l'application est qu'elle est écrite en Qt. Tout d'abord, à l'aide de votre éditeur de texte préféré, créez un fichier appelé hello.pro dans examples/qmake/tutorial. La première chose à faire est d'ajouter les lignes qui indiquent à qmake les fichiers source et les fichiers d'en-tête qui font partie de votre projet de développement.

Nous commencerons par ajouter les fichiers source au fichier de projet. Pour ce faire, vous devez utiliser la variable SOURCES. Commencez simplement une nouvelle ligne avec SOURCES += et mettez hello.cpp après. Vous devriez obtenir quelque chose comme ceci :

SOURCES += hello.cpp

Nous répétons cette opération pour chaque fichier source du projet, jusqu'à ce que nous obtenions ce qui suit :

SOURCES += hello.cpp
SOURCES += main.cpp

Si vous préférez utiliser une syntaxe semblable à celle de Make, avec tous les fichiers listés en une seule fois, vous pouvez utiliser l'échappement des nouvelles lignes comme ceci :

SOURCES = hello.cpp \
          main.cpp

Maintenant que les fichiers sources sont listés dans le fichier de projet, les fichiers d'en-tête doivent être ajoutés. Ceux-ci sont ajoutés exactement de la même manière que les fichiers sources, sauf que le nom de la variable que nous utilisons est HEADERS.

Une fois cette opération effectuée, votre fichier de projet devrait ressembler à ceci :

HEADERS += hello.h
SOURCES += hello.cpp
SOURCES += main.cpp

Le nom de la cible est défini automatiquement. Il est identique au nom de fichier du projet, mais avec le suffixe approprié à la plate-forme. Par exemple, si le fichier du projet s'appelle hello.pro, la cible sera hello.exe sous Windows et hello sous Unix. Si vous souhaitez utiliser un nom différent, vous pouvez le définir dans le fichier du projet :

TARGET = helloworld

Le fichier de projet terminé devrait ressembler à ceci :

HEADERS += hello.h
SOURCES += hello.cpp
SOURCES += main.cpp

Vous pouvez maintenant utiliser qmake pour générer un Makefile pour votre application. Sur la ligne de commande, dans le répertoire de votre projet, tapez ce qui suit :

qmake -o Makefile hello.pro

Tapez ensuite make ou nmake en fonction du compilateur que vous utilisez.

Pour les utilisateurs de Visual Studio, qmake peut également générer des fichiers de projet Visual Studio. Par exemple, qmake peut générer des fichiers de projet Visual Studio :

qmake -tp vc hello.pro

Rendre une application débogable

La version release d'une application ne contient pas de symboles de débogage ni d'autres informations de débogage. Pendant le développement, il est utile de produire une version de débogage de l'application qui contient les informations pertinentes. Pour ce faire, il suffit d'ajouter debug à la variable CONFIG du fichier de projet.

Par exemple, il est possible d'utiliser qmake comme précédemment pour générer une version de débogage :

CONFIG += debug
HEADERS += hello.h
SOURCES += hello.cpp
SOURCES += main.cpp

Utilisez qmake comme précédemment pour générer un Makefile. Vous obtiendrez ainsi des informations utiles sur votre application lorsque vous l'exécuterez dans un environnement de débogage.

Ajout de fichiers source spécifiques à la plate-forme

Après quelques heures de codage, vous avez peut-être commencé à travailler sur la partie de votre application spécifique à la plate-forme, et décidé de garder le code dépendant de la plate-forme à part. Vous avez donc maintenant deux nouveaux fichiers à inclure dans votre fichier de projet : hellowin.cpp et hellounix.cpp. Nous ne pouvons pas simplement les ajouter à la variable SOURCES car cela placerait les deux fichiers dans le Makefile. Nous devons donc utiliser un champ d'application qui sera traité en fonction de la plate-forme pour laquelle nous construisons.

Une portée simple qui ajoute le fichier dépendant de la plate-forme pour Windows ressemble à ceci :

win32 {
    SOURCES += hellowin.cpp
}

Lors de la construction pour Windows, qmake ajoute hellowin.cpp à la liste des fichiers sources. Lorsqu'il construit pour une autre plate-forme, qmake l'ignore tout simplement. Il ne reste plus qu'à créer une portée pour le fichier spécifique à Unix.

Une fois cela fait, votre fichier de projet devrait ressembler à ceci :

CONFIG += debug
HEADERS += hello.h
SOURCES += hello.cpp
SOURCES += main.cpp
win32 {
    SOURCES += hellowin.cpp
}
unix {
    SOURCES += hellounix.cpp
}

Utilisez qmake comme précédemment pour générer un Makefile.

Arrêter qmake si un fichier n'existe pas

Il se peut que vous ne souhaitiez pas créer un Makefile si un certain fichier n'existe pas. Nous pouvons vérifier si un fichier existe en utilisant la fonction exists(). Nous pouvons arrêter le traitement de qmake en utilisant la fonction error(). Cela fonctionne de la même manière que les champs d'application. Il suffit de remplacer la condition de portée par la fonction. Une vérification pour un fichier appelé main.cpp ressemble à ceci :

!exists( main.cpp ) {
    error( "No main.cpp file found" )
}

Le symbole ! est utilisé pour annuler le test. Autrement dit, exists( main.cpp ) est vrai si le fichier existe, et !exists( main.cpp ) est vrai si le fichier n'existe pas.

CONFIG += debug
HEADERS += hello.h
SOURCES += hello.cpp
SOURCES += main.cpp
win32 {
    SOURCES += hellowin.cpp
}
unix {
    SOURCES += hellounix.cpp
}
!exists( main.cpp ) {
    error( "No main.cpp file found" )
}

Utilisez qmake comme précédemment pour générer un fichier makefile. Si vous renommez temporairement main.cpp, vous verrez le message et qmake arrêtera le traitement.

Vérification de plusieurs conditions

Supposons que vous utilisiez Windows et que vous souhaitiez voir la sortie des déclarations à l'adresse qDebug() lorsque vous exécutez votre application sur la ligne de commande. Pour voir la sortie, vous devez compiler votre application avec le paramètre de console approprié. Nous pouvons facilement mettre console sur la ligne CONFIG pour inclure ce paramètre dans le Makefile sous Windows. Cependant, disons que nous ne voulons ajouter la ligne CONFIG que lorsque nous fonctionnons sous Windows et que debug est déjà sur la ligne CONFIG. Cela nécessite l'utilisation de deux scopes imbriqués. Créez d'abord une portée, puis créez l'autre portée à l'intérieur de celle-ci. Placez les paramètres à traiter dans le deuxième champ d'application, comme ceci :

win32 {
    debug {
        CONFIG += console
    }
}

Les scopes imbriqués peuvent être reliés à l'aide de deux points, de sorte que le fichier de projet final ressemble à ceci :

CONFIG += debug
HEADERS += hello.h
SOURCES += hello.cpp
SOURCES += main.cpp
win32 {
    SOURCES += hellowin.cpp
}
unix {
    SOURCES += hellounix.cpp
}
!exists( main.cpp ) {
    error( "No main.cpp file found" )
}
win32:debug {
    CONFIG += console
}

C'est tout ! Vous avez maintenant terminé le tutoriel sur qmake et vous êtes prêt à écrire des fichiers de projet pour vos projets de développement.