Wikilivres

Programmation Qt/Un premier programme

< Programmation Qt
Développer pour Windows 64 bits Développer pour Windows 64 bits
Signaux et slots Signaux et slots

Ce chapitre propose de créer un premier programme et de le compiler en utilisant des lignes de commandes, afin de se familiariser rapidement aux mécanismes de compilation de Qt.

Annexes

[ Modifier le sommaire ]

Développer pour Windows 64 bits Développer pour Windows 64 bits
Signaux et slots Signaux et slots

Afficher un bouton

modifier

Ce premier programme crée un bouton et l'affiche dans une fenêtre automatiquement créée par Qt.

Fichier

modifier
  HelloWorld.cpp
Programme simple affichant un bouton "Hello world!" 
#include <QApplication>
#include <QPushButton>

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    QPushButton hello("Hello world!");
    hello.resize(100,30);
    hello.show();
    return app.exec();
}


Compilation

modifier

Pour compiler le programme :

  1. Ouvrez une fenêtre de commande et assurez vous d'avoir le répertoire du compilateur C++ et celui de Qt dans le PATH :
    • Si vous avez installé la version binaire de QtSDK, lancez la console pour Qt :
      • Sous Windows : Démarrer > Tous les programmes > Qt DSK > Desktop > Qt version for Desktop (compilateur)
    • Sinon, configurez la variable d'environnement PATH puis lancer une console de commandes.
  2. Créez le fichier projet Qt HelloWorld.pro :
qmake -project
  2. Créez le fichier Makefile à partir du fichier projet :
qmake
  2. Construisez le programme en utilisant le compilateur C++ (GCC, Visual C++, MinGW, ...) :
  • Pour GCC :
make
  • Pour Visual C++ :
nmake
  • Pour MinGW :
mingw32-make

Si aucune erreur ne se produit, deux sous-répertoires debug et release ont été créés, et le fichier exécutable a été créé dans l'un d'eux :

  • HelloWorld.exe sous Windows
  • HelloWorld ou a.out sous Unix, Linux

Dans le cas contraire :

  • vérifiez que vous avez bien tapé le code source ci-dessus,
  • vérifiez que vous avez bien utilisé les mêmes noms de fichier,
  • vérifiez que vous avez bien tapé les commandes de compilation,
  • vérifiez l'installation du compilateur C++ et de Qt.

Exécution

modifier

Au lancement du programme, une fenêtre s'affiche avec un bouton "Hello world!" au centre de celle-ci.

 

Code source expliqué

modifier

Voici le détail du code source expliqué :

En-têtes

modifier 
#include <QApplication>
#include <QPushButton>

Inclusion des fichiers d'en-tête définissant les deux classes utilisées dans le programme.

Fonction principale

modifier 
int main(int argc, char* argv[])
{
    //Code
}

Déclaration standard de la fonction principale lançant l'application.

Notez que l'on peut aussi le trouver écrit comme cela, bien que la version précédente soit plus complète : 

int main()
{
    //Code
}

Application Qt

modifier 
    QApplication app(argc, argv);

Création de l'instance unique de la classe QApplication définissant la configuration par défaut des éléments graphiques.

Les arguments de la ligne de commande sont passés au constructeur pour qu'il interprète certaines options. Les options reconnues et traitées sont retirées du tableau au retour du constructeur pour que l'application ne les traitent pas à son tour. Parmi les options traitées :

Nom du programme argv[0]
Le nom du programme (sans extension .exe sous Windows) est utilisé comme nom par défaut pour l'application et comme titre par défaut pour les fenêtres.
-display
(X11 seulement) Sélectionne le display ($DISPLAY par défaut)
-style style
Sélectionne le style utilisé par les éléments de l'interface.

Pour plus de détails sur les options traitées, voir https://qt-project.org/doc/qt-4.7/qapplication.html

Bouton

modifier 
    QPushButton hello("Hello world!");

Création d'un bouton dont le texte "Hello world!" est passé en paramètre du constructeur.

Configuration du bouton

modifier 
    hello.resize(100,30);

Redimensionne le bouton à 100 pixels de largeur et 30 de hauteur.

Afficher

modifier 
    hello.show();

Affiche le bouton dans une fenêtre créée pour le contenir.

Boucle de traitement des évènements

modifier 
    return app.exec();

Lancement l'exécution de la boucle traitant des évènements. La méthode exec() retourne le code de retour du programme.

Fin

modifier 
}

Fin de la fonction principale.

Un second programme

modifier

Voici un programme très simple qui permettra l'affichage d'une fenêtre, plus précisément la fenêtre principale.

Cette fois-ci le fichier projet sera créé manuellement. Celui-ci définit le modèle de programme à produire (app pour une application), et la liste des fichiers sources et en-têtes.

  essais.pro
Description du projet Qt 
TEMPLATE = app
SOURCES  = main.cpp \
           mainwindow.cpp
HEADERS  = mainwindow.h


Un fichier projet possède une syntaxe similaire à celle des fichiers Makefile. Différentes variables sont définies (=) ou complétées (+=) :

  • TEMPLATE : Modèle d'exécutable à générer (app pour une application autonome, lib pour une bibliothèque ou un plug-in).
  • SOURCES : Listes des fichiers sources (*.cpp) du projet.
  • HEADERS : Listes des fichiers d'en-tête (*.h) du projet.
  • FORMS : Listes des formulaires Qt Designer (*.ui) du projet.
  • DEFINES : Listes des symboles définis lors de la compilation du projet.


  main.cpp
Fonction principale de lancement de l'application 
#include <QApplication>
#include "mainwindow.h"

int main ( int argc, char *argv[] )
{
    QApplication app(argc, argv);
    MainWindow mainWin;
    mainWin.show();
    return app.exec();
}


La fenêtre principale est allouée pour l'exemple sur la pile d'appel. Cependant, dans le cas où plusieurs instances de cette fenêtre (pour ouvrir plusieurs fichiers par exemple) sont créées et ouvertes, ou fermées (dont probablement la première instance créée), il est préférable d'allouer la première instance sur le tas (utiliser un pointer et allouer avec new) et d'utiliser l'option Qt::WA_DeleteOnClose.


  mainwindow.h
En-tête pour la classe de la fenêtre principale 
#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QWidget>

class MainWindow : public QWidget
{
    Q_OBJECT

public:
    MainWindow();

};

#endif


Cette fenêtre dérive de la classe QWidget comme tout objet Qt pour l'interface graphique. Il s'agit avant tout d'un conteneur de widget plutôt que la fenêtre elle-même. La macro Q_OBJECT est utilisée avec toute classe Qt pour définir les informations sur la classe.


  mainwindow.cpp
Implémentation de la classe de la fenêtre principale 
#include <QtGui>
#include "mainwindow.h"

MainWindow::MainWindow()
{
}


Compiler le programme

modifier

La compilation s'effectue de la même façon que pour le programme précédent, excepté que la première commande (qmake -project) n'est plus nécessaire puisque l'on a déjà un fichier projet (essais.pro). Le nom de ce fichier projet détermine également le nom de l'exécutable (essais.exe sous Windows).

Exécution

modifier

Les bibliothèques de Qt sont nécessaires à l'exécution de tout programme Qt :

  • Par défaut, celles-ci sont compilées en mode liaison dynamique (.dll sous Windows, .so sous Unix/Linux). Cela signifie que les bibliothèques utilisées par l'application doivent de situer :
    • soit dans le même répertoire que l'exécutable,
    • soit dans un répertoire du PATH (sous Windows) ou de LD_LIBRARY_PATH (Unix/Linux).
  • Si les bibliothèques ont été compilées en mode liaison statique (configure -static), celle-ci sont directement intégrées à l'exécutable produit à la compilation.

Les bibliothèques en question sont en général :

  • QtCore4.dll et QtGui4.dll pour Qt (ou avec un d comme suffixe QtCore4d.dll et QtGui4d.dll en mode debug) ;
  • mingwm10.dll pour MinGW. Cependant celle-ci n'est pas toujours requise.

En exécutant le programme, on obtient une fenêtre vide.

Analyse

modifier
  • Le fichier essais.pro répertorie les différents fichiers du projet.
  • On déclare app objet de la classe QApplication et mainWin objet de la classe MainWindow.
  • MainWindow est une classe dérivée de QWidget à laquelle on ne va pour l'instant rien ajouter.

Explications

modifier
  essais.pro
Description du projet Qt 
TEMPLATE = app
SOURCES  = main.cpp \
           mainwindow.cpp
HEADERS  = mainwindow.h

Dans ce fichier, on met tous les fichiers et les headers utilisés.

  main.cpp
Fonction principale de lancement de l'application 
#include <QApplication>
#include "mainwindow.h"

int main ( int argc, char *argv[] )
{
    QApplication app(argc, argv);
    MainWindow mainWin;
    mainWin.show();
    return app.exec();
}

#include <QApplication>

On inclue la création de fenêtres. 

#include "mainwindow.h"

On inclue notre header. Attention de ne pas oublier les guillemets ! 

int main ( int argc, char *argv[] )
{
    //Code
}

On créé notre fonction principale. 

    QApplication app(argc, argv);

On créé l'application. 

    MainWindow mainWin;
    mainWin.show();

On appelle une fenêtre de type MainWindow et on l'affiche. 

    return app.exec();

Exécution de l'application.

Notes et références

modifier
Récupérée de « https://fr.wikibooks.org/w/index.php?title=Programmation_Qt/Un_premier_programme&oldid=634737 »