Fichiers d'un projet
Types de fichiers
Un projet en C ou C++ fait le plus souvent appel à de nombreux fichiers :
- fichier du projet : il contient les paramètres nécessaires au compilateur; .pro sous QTCreator, .cbproj sous C++Builder
- fichier source : il contient les codes C du programme; .cpp pour la plupart des EDI
- fichier entête : il contient la description (le prototype) des fonctions; .h pour la plupart des EDI
- fichier ressource : il contient les ressources (images, sons) du programme s'il y en a; .qrc sous QTCreator, .res sous C++Builder
- fichiers formulaires : description des fenêtres (formulaires) si elles existent; .ui sous QTCreator, .dfm sous C++Builder)
Remarque : les fichiers de description des formulaires sont liées a des fichiers sources et entêtes
Principe de gestion des fichiers
Il est de bonne pratique de "découper" un grand programme en plusieurs sections associées chacune à un fichier source et d'entête. Cela facilite la gestion et la maintenance du projet.
Le fichier source (.cpp) est toujours accompagné d'un fichier d'entête (.h).
Explications par l'exemple avec QTCreator
On souhaite démarrer un programme simple disposant d'une fenêtre.
On pourrait choisir de créer un projet intégrant directement une fenêtre (Application Qt avec Widget) mais pour bien montrer les différents éléments et étapes de la composition du projet, nous choisissons une construction manuelle.
Attention a bien placer le projet dans un dossier spécifique afin de ne pas mélanger ses fichiers avec d'autres
Après validation, le fichier projet est créé, mais il est vide :
.
Création du fichier principal
: main.cpp
L'étape suivante consiste à créer le fichier source principal que l'on appellera toujours main.cpp.
Remarque : main.cpp est créé automatiquement si on utilise l'assistant de création de projet QT
- Choisir C++/C++Source file
- Veiller à intégrer le fichier main.cpp au projet courant
L'assistant insère automatiquement les références à main.cpp dans le fichier de projet
Le fichier main.cpp est lui aussi vide.
Selon ce qu'on veut faire, le contenu de ce fichier sera bien sûr très différent.
Dans notre application qui fait appel à une fenêtre appelée mainwin, on pourra placer le code suivant :
#include <QApplication>
#include "mainwin.h"
int main(int argc, char* argv[])
{
QApplication app(argc, argv);
mainwin fenetre; //on créé une instance de l'objet mainwin
fenetre.show(); //et on l'affiche
return app.exec();
}
#include <QApplication> : spécifie que l'on va utiliser la classe QApplication parce que notre application sera une instance de cette classe (comme la plupart des applications Qt).
#include "mainwin.h" : précise que l'on utilisera un code externe décrit dans mainwin.h. Ce sera la description de notre fenêtre
int main(int argc, char* argv[]) {...} : c'est le point d'entrée du programme. Dans Qt, le main se résumera à l'initialisation. Le code principale sera spécifié dans d'autres paires de fichiers cpp/h.
QApplication app(argc, argv) ; app est l'instance de QApplication. argc et argv sont des arguments qui permettent la gestion de l'application en lien avec le système d'exploitation. Le développeur n'a le plus souvent pas besoin de les utiliser.
mainwin fenetre : création d'une instance (fenetre) de la classe mainwin.
fenetre.show() : Un widget (fenêtre, etc...) n'est jamais visible à la création. Il faut pour cela appeler la méthode show().
return app.exec() : cette ligne permet réellement l’exécution du programme
Ce point est traité plus en détail dans le chapitre QT Designer : dessiner une fenêtre.
Rappelez vous qu'il faut :
- placer les 3 fichiers (mainwin.h, mainwin.cpp et mainwin.ui) dans le même dossier que le projet.
- lier le formulaire au projet
mainwin.h et mainwin.cpp disposent automatiquement d'un code de base qui décrit la base de la fenêtre.
mainwin.h
#ifndef MAINWIN_H
#define MAINWIN_H
#include <QMainWindow>
namespace Ui {
class mainwin;
}
class mainwin : public QMainWindow
{
Q_OBJECT
public:
explicit mainwin(QWidget *parent = 0);
~mainwin();
private:
Ui::mainwin *ui;
};
#endif // MAINWIN_H
#ifndef MAINWIN_H #define MAINWIN_H ......#endif : ces directives empêchent le compilateur d'inclure plusieurs fois ce fichier. Tout le code de mainwin.h doit être placer après #define MAINWIN_H et avant #endif.
#include <QMainWindow> : On va utiliser la class QMainWindow car notre fenêtre en héritera
namespace Ui {class mainwin } : permet de lier Ui (User Interface) avec mainwin.
class mainwin : public QMainWindow {.....} : Il s'agit de la déclaration de la classe mainwin qui hérite de QMainWindow
Q_OBJECT : il s'agit d'une macro indispensable dans la gestion des événements et de la mémoire.
mainwin.cpp
#include "mainwin.h"
#include "ui_mainwin.h"
mainwin::mainwin(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::mainwin)
{
ui->setupUi(this);
}
mainwin::~mainwin()
{
delete ui;
}
#include "ui_mainwin.h" : la création de la fenêtre mainwin a conduit aussi à la création de ui_mainwin.h par le designer. Il est nécessaire de faire figurer cette ligne dans le programme pour que la gestion des fenêtres fonctionne.
mainwin::mainwin.... : il s'agit de la construction de la fenêtre. On y placera les connexions de gestion d'évènement etc....
mainwin::~mainwin() : c'est la méthode de destruction de la fenêtre
Remarque :
Le rajout de la fenêtre mainwin a modifié également le fichier de projet. Il faut rajouter manuellement la ligne QT += widgets pour que le compilateur cherche les widgets
QT += widgets //à rajouter
SOURCES += \
main.cpp \
mainwin.cpp
FORMS += \
mainwin.ui
HEADERS += \
mainwin.h
La présence des fichiers principaux permet à présent d'avancer dans la programmation.
On pourra à ce niveau là ajouter des widgets grâce au designer et changer le code source dans mainwin.cpp. On peut aussi ajouter des widgets directement dans le code source.
Voir aussi :