Les développeurs de Qt 4 proposent des outils très utiles qui facilitent la gestion de vos projets utilisant Qt 4. En effet, il existe un outil permettant de transformer les fichiers du designer (.ui) en fichiers C++, un autre permettant de générer le code nécessaire pour la création de widgets personnalisés...

Cependant, ils fournissent également un outil permettant de gérer automatiquement les fichiers du designer, les fichiers dans lesquels vous définissez des widgets personnalisés, et même en réalité tout votre projet : qmake. Cet outil permet de générer un fichier de projet .pro, de générer à partir de ce dernier les règles de compilation de votre projet, et bien d'autres choses, comme la détection de votre compilateur, du répertoire d'installation de Qt 4...

Un tutoriel a été écrit pour présenter cet outil et décrire son utilisation : Compilation des projets Qt 4.

En C++, il peut être parfois intéressant de déclarer une classe directement dans un fichier d'implémentation (.cpp, .cxx, .cc…). Cependant, certaines classes exploitées par Qt obligent les fichiers à passer par le moc.

Pour remédier à ce problème, il est tout à fait possible d'appliquer le moc sur ce fichier. En contrepartie, il faut inclure le fichier généré à la suite de la déclaration de la classe dans le .cpp.

Si vous utilisez qmake, il suffit, juste après la déclaration de la classe, d'inclure un fichier utilisant le nom du fichier cpp suivi de l'extension .moc. Cette méthode est utilisée dans certains codes de la Q/R pour simplifier la compilation de l'exemple à un seul fichier.

...
class myTest : QObject
{
    Q_OBJECT
    ...
};
#include "test.moc"
...

Avant de compiler Qt, vérifiez que des binaires ne sont pas déjà fournis sur Developpez.com.

Tout d'abord, pour une compilation simple, avec toutes les options par défaut, utilisez l'un de ces jeux de commandes.

Vous devez utiliser, sous Windows, une invite configurée pour votre compilateur (avec les variables %PATH%, %INCLUDE% et %LIB% configurées), telle que l'Invite de commande de Visual Studio, disponible dans le menu Démarrer (avec la barre de recherche).

rem Version 9.0 :
set QMAKESPEC="win32-msvc2008"
rem Version 8.0 :
set QMAKESPEC="win32-msvc2005"
rem Version 7.1 :
set QMAKESPEC="win32-msvc2003"
rem Version 7.0 :
set QMAKESPEC="win32-msvc2002"
rem Versions 7.0+ :
set QMAKESPEC="win32-msvc.net"
rem Version 6.0 :
set QMAKESPEC="win32-msvc'

configure
nmake

configure
make

configure vous demandera si vous acceptez la licence de Qt : vous devez d'abord la lire (), puis l'accepter (y).

Si vous voulez personnaliser votre compilation (ajouter le support d'autres bibliothèques comme OpenSSL, par exemple), vous pouvez voir l'ensemble des drapeaux disponibles en utilisant cette commande.

Il vous suffit de préciser le drapeau -xplatform lors de la configuration de Qt.

Celui-ci informera le compilateur que les binaires devront être exécutables sur cette plateforme, et que les outils doivent se lancer sur la plateforme hôte (précisée éventuellement par le drapeau -platform).

Vous pouvez spécifier tous les autres drapeaux dont vous avez besoin.

Pour effectuer une compilation croisée Qt, vous devez disposer d'un compilateur croisé (par exemple, GCC, ou l'un des compilateurs croisés fournis avec Visual Studio).

Voici deux listes reprenant l'ensemble des plateformes supportées.

• Supported Platforms ;
• Compilation croisée de Qt.

Pour obtenir un compilateur, référez-vous à l'article sur la cross-compilation avec GCC 4 sous Windows pour Linux

configure -h

Vous n'avez le droit de compiler Qt statiquement que si l'une de ces conditions est remplie :

• vous écrivez un logiciel open source sous licence GPL ;
• vous avez une licence commerciale.

Si vous n'êtes pas dans un de ces deux cas, ne compilez pas statiquement votre application.

La LGPL ne change rien au problème : l'utilisateur doit pouvoir remplacer votre version de Qt par celle qu'il désire. Si vous liez statiquement à Qt, l'utilisateur ne pourra pas remplacer Qt, et vous serez en infraction avec la licence.

Compiler statiquement une application permet de gagner légèrement en performance et de diminuer légèrement la taille du package à distribuer. Il est rare de compiler statiquement pour GNU/Linux pour des raisons de performance et de flexibilité.

Pour compiler statiquement, il faut une version de Qt compilée statiquement, il faut recompiler la bibliothèque avec l'option -static. Ensuite, il faut compiler l'application elle-même statiquement. Si vous utilisez qmake, il suffit d'ajouter la directive CONFIG += static au fichier de configuration (fichier .pro), de relancer qmake et de recompiler le projet.

Il reste le problème des plug-ins. Qt charge certaines fonctionnalités grâce à un système de plug-ins. Ce chargement dynamique ne peut évidemment pas fonctionner en version statique. Pour utiliser un plug-in, il faut modifier l'application pour le charger explicitement à la compilation. Ceci est fait à l'aide de la macro Q_IMPORT_PLUGIN().

#include <QApplication>
#include <QtPlugin>

Q_IMPORT_PLUGIN(qtaccessiblewidgets)
Q_IMPORT_PLUGIN(qjpeg)
Q_IMPORT_PLUGIN(qgif)

int main(int argc, char *argv[])
{
   ...

Le plug-in qtaccessiblewidgets permet d'utiliser les outils d'accessibilité avec l'application, il est recommandé de toujours inclure ce plug-in.

Utiliser une bibliothèque (statique ou dynamique) dans un projet nécessite deux choses :

• indiquer au compilateur où rechercher les fichiers d'en-tête relatifs à la bibliothèque pour avoir accès aux fonctions qu'elle propose ;
• indiquer au compilateur de lier la bibliothèque à l'exécutable du projet.

Étape 1 : indiquer au compilateur le chemin des fichiers d'en-tête de la bibliothèque externe

La manière classique est d'ajouter l'option de compilation suivante à l'appel de votre compilateur :

-I/chemin/des/en-têtes/de/la/bibliothèque

Si vous utilisez un IDE, fouillez dans les propriétés de votre projet afin de lui indiquer où rechercher les fichiers d'en-tête de votre bibliothèque.

Avec Qt, il faut ajouter une ligne au fichier de projet (.pro) :

INCLUDEPATH += /chemin/des/en-têtes/de/la/bibliothèque

Vous pouvez dès à présent inclure dans votre code source des fichiers provenant du répertoire spécifié.

Étape 2 : indiquer au compilateur de lier la bibliothèque à l'exécutable

Pour lier une bibliothèque à l'exécutable d'un projet Qt, il est nécessaire de modifier le fichier de projet afin que le Makefile généré par qmake tienne compte de cette bibliothèque.

Prenons l'exemple du fichier d'import de la bibliothèque libmaLibrairie.a localisée dans /chemin/de/la/lib/libmaLibrairie.a.

La manière classique de linker (lier) une bibliothèque à un projet C/C++ est d'ajouter les options de compilation suivantes lors de l'exécution du linker (ld, sous les systèmes GNU/Linux) :

 -lmaLibrairie
 -L/chemin/de/la/lib

On ne précise pas le préfixe (lib) ni l'extension (.a) du fichier d'import !

Sous Qt, il faut ajouter des lignes au fichier de projet :

LIBS += -lmaLibrairie
LIBS += -L/chemin/de/la/lib

Sous Windows, le caractère \ utilisé comme séparateur dans les chemins doit être échappé (par exemple, C:\MonDossier devient C:\\MonDossier). De plus, l'espace dans un nom de dossier peut entraîner des erreurs, indiquez-le dans ce cas entre guillemets (par exemple, C:\\Mon Dossier devient "C:\\Mon Dossier").

Une fois le fichier de projet modifié, exécutez qmake pour mettre à jour les Makefile, puis make (ou nmake sous Visual Studio) pour recompiler votre projet.

Qt est un framework très complet, il propose beaucoup de choses de lui-même. Cependant, très souvent, il n'est pas utile de réinventer la roue : Qt, comme beaucoup d'autres, se base donc sur des bibliothèques écrites par d'autres, pour proposer certaines fonctionnalités. Voici ces bibliothèques et leurs versions minimales, qui peuvent ajouter des fonctionnalités à Qt. Elles doivent être activées dès la compilation ; l'activation peut être effectuée par le biais de drapeaux passés à configure.

• OpenSSL : OpenSSL.
• DBus : DBus.
• Direct3D (déprécié dès Qt 4.5, de retour avec Qt 5.8) : DirectX SDK (v9).
• OpenGL : inclus dans l'OS.
• OpenVG : inclus dans le SDK de la plateforme ou ShivaVG.

Il est possible d'activer Direct3D aussi pour MinGW.

• DirectX : DirectX SDK (v9).
• VLC : libvlc.
• MPlayer : MPlayer.

Il est possible d'activer Phonon aussi pour MinGW.

Les bibliothèques nécessaires sont en général installées en même temps que le SGBD, parfois de manière optionnelle.

• MySQL : MySQL.
• Oracle : Oracle.
• ODBC : livré avec Windows ; implémentation différente pour UNIX.
• PostgreSQL : PostgreSQL 7.3.
• Sybase : FreeTDS, MS DB-Library, Sybase Open Client.
• DB2 : DB2.
• SQLite : 2 et 3 (la dernière est livrée avec Qt).
• Borland InterBase : InterBase.
• FireBird (IB Free) : FireBird.

Si vous avez téléchargé le SDK de Qt à partir du site officiel, les sources sont déjà compilées pour la plateforme choisie à l'aide du compilateur MinGW (portage de GCC pour Windows). Cependant, il est possible de compiler ces sources avec d'autres compilateurs, notamment les compilateurs natifs de chaque plateforme (comme Visual C++ sous Windows).

Actuellement, voici l'ensemble des compilateurs supportés pour la version 4.5.3 de Qt, dans leur notation canonique :

Plateformes supportées activement
aix-xlc, aix-xlc-64, hpux-acc, hpux-g++, hpux-g++-64, hpuxi-acc, qws/linux-arm-g++, qws/linux-x86-g++, linux-g++, linux-icc, linux-icc-32, linux-icc-64, macx-g++, macx-g++42, solaris-cc, solaris-g++, win32-g++, win32-icc, win32-msvc2003, win32-msvc2005, win32-msvc2008, wince-msvc2005, wince-msvc2008

Plateformes supportées par la communauté Qt
darwin-g++, freebsd-g++, freebsd-g++34, freebsd-g++40, freebsd-icc, hpuxi-g++, linux-cxx, linux-ecc-64, linux-g++, linux-kcc, linux-llvm, linux-lsb-g++, lynxos-g++, macx-llvm, netbsd-g++, openbsd-g++, qws/linux-g++

Plateformes précédemment supportées
irix-cc, irix-g++, win32-msvc, win32-msvc2002, win32-msvc.net

Pour compiler les sources Qt avec les plateformes supportées, il est nécessaire que le compilateur soit installé sur votre machine, que les variables permettant de le connaître soient définies dans l'instance de votre shell (invite de commande sous Windows) et que vous ajoutiez l'argument -platform lors de l'appel à configure (configuration de la compilation), suivi du compilateur sous la forme canonique (par exemple, $>configure -platform win32-msvc2008).

Vous pouvez utiliser QMAKE_TARGET.arch pour cela. La variable QMAKE_TARGET représente les informations de la machine hôte qui exécute qmake et QMAKE_TARGET.arch vous permet de déterminer l'architecture de destination. Vous pouvez l'utiliser comme suit :

contains(QMAKE_TARGET.arch, x86_64){
	faire quelque chose en conséquence ...
}

Si vous voulez compiler Qt dans sa version 64 bits, alors vous devez compiler les outils qu'utilise Qt en 32 bits, ensuite le reste des bibliothèques peut être compilé en mode 64 bits, ce qui vous permettra de construire votre application dans une version 64 bits. Pour ce faire, effectuez les commandes suivantes.

Si vous n'utilisez pas Visual Studio, il faut remplacer la commande nmake par make.

• lancez configure avec les options que vous voulez ;
• cd src\tools && nmake (cela va échouer à l'étape de uic3, c'est normal).

• cd src && nmake (cela va échouer à l'étape de uic3, encore une fois, c'est normal) ;
• cd src\tools\uic3 && qmake ;
• cd src && nmake.

Gardez à l'esprit que vous ne pouvez pas utiliser uic3 dans votre processus de construction, car il est lié à la version 64 bits de Qt. De plus, vous ne pourrez pas exécuter les applications que vous allez créer avec la version 64 bits de Qt sur la machine 32 bits. Vous allez devoir les installer sur une machine 64 bits pour tester.