Bonjour,
je suis débutant avec Qt 5.0 mon probleme c'est que #include<QtGui> ne suffit pas. je dois appeler toutes classes que j'utilise !!
Bonjour,
je suis débutant avec Qt 5.0 mon probleme c'est que #include<QtGui> ne suffit pas. je dois appeler toutes classes que j'utilise !!
Vous souhaitez participer aux rubriques Qt (tutoriels, FAQ, traductions) ou HPC ? Contactez-moi par MP.
Créer des applications graphiques en Python avec PyQt5
Créer des applications avec Qt 5.
Pas de question d'ordre technique par MP !
ce que j'ai appris c'est que on n'a pas besoin de faire plusieurs includes puisque #include <QtGui> englobe tous ce n'est pas le cas pour moi.....autrement dit si je fais #include <QtGui> et j'utilise QPushButton Qt creator ne change pas sa couleur je dois faire #include <QPushButton> et comme j'ai besoin d'utiliser beaucoup de classes ce n'est pas logique de faire touse les includes
salam 3alikom,
ça ne marche plus aussi pour moi (comme qt ne voit pas mon inclusion), Qt m'oblige d'ajouter tous alors que normalement #include <QtGui> ou #include <QtGui/QtGui> ajoute tous pour ne pas se fatiguer à inclure bcp.
pas une solution ?
Salut,
De toutes manières, d'après mon expérience personnelle:
- Tu auras rarement besoin de l'ensemble de ce que peut proposer un module comme QtGui
- S'il existe un fichier d'en-tête qui inclut l'intégralité d'un module, il est largement conseillé de l'éviter comme la peste
Comme ces assertions peuvent sembler quelque peu abruptes, je vais quand même prendre la peine de les expliquer un tout petit peu
(1) QtGui fournit un nombre tout bonnement faramineux de classes pour la simple et bonne raison... qu'il y a énormément de possibilités qui rentrent dans le terme "Graphical User Interface".
Il n'est pas exclu que tu aies besoin d'un certain nombre des classes que ce module offre, mais, de là à te retrouver, sur un seul "formulaire", avec ne serait-ce qu'un seul objet de chaque type, j'ai un doute très sérieux.
(2) Il semble plus qu'utile de se rappeler la manière de fonctionner de C++ et de sa chaine de compilation.
Dans cette chaine de compilation, le premier outil qui est utilisé est... le préprocesseur.
C'est un outil finalement tout à fait idiot qui va simplement appliquer certaines actions "simples".
Ainsi, lorsqu'il va rencontrer la directive #include, il va, tout simplement, remplacer la directive en question par... le contenu du fichier indiqué.
Seulement, il va le faire de manière récursive, ce qui fait que, si dans le contenu du fichier qu'il vient d'ajouter, il trouve une autre directive #include, il la remplacera de nouveau par le contenu du fichier indiqué, et ainsi de suite.
A tire d'exemple, la simple inclusion du fichier <iostream> occasionne l'ajout de près de 18000 lignes du fait des inclusions en cascade!!!
Le problème, c'est que les outils qui viennent après (parser, lexer, générateur d'instructions assembleur et assembleur) vont devoir traiter toutes ces lignes.
Le résultat est sans appel: plus tu inclus de fichiers (que ce soit de manière directe ou indirecte du fait de l'inclusion en cascade), plus les différents outils mettront du temps à gérer toutes les lignes rajoutées.
En plus, tout ce travail d'inclusion de fichiers en cascade et de traitement de leur contenu est effectué pour chaque fichier *.cpp que l'on va rencontrer!
Si tu en viens, en incluant un seul fichier d'en-tête, à inclure l'intégralité des fichiers d'en-tête d'un module, les différents outils risquent de se retrouver dans une situation où ils devront gérer 50, 100 ou 200 000 (et peut etre encore d'avantage) lignes de code, alors qu'une "infime partie" seulement de toutes ces lignes de code ne serait nécessaire à leur bon fonctionnement.
Ce n'est, décidément, pas pour rien que les développeurs de Qt eux-même conseillent ardemment de recourir aux déclarations anticipées à chaque fois que faire se peut dans les fichiers d'en tête !
Cela permet d'éviter un maximum de se retrouver avec tant et plus de fichiers inclus alors que l'on n'aurait un besoin effectif des déclarations qu'ils fournissent.
En limitant au maximum les différents fichiers inclus, on gagne énormément en temps de compilation.
Bien sur, sur un projet simple d'une fenêtre composée de quelque boutons, le gain restera peu représentatif, mais, si tu viens un jour à travailler sur un projet composé de plusieurs centaines (milliers?) de fichiers, tu remarqueras une très nette différence
A méditer: La solution la plus simple est toujours la moins compliquée
Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
Compiler Gcc sous windows avec MinGW
Coder efficacement en C++ : dans les bacs le 17 février 2014
mon tout nouveau blog
Rajoute
dans ton fichier pro et ça va rouler
Code : Sélectionner tout - Visualiser dans une fenêtre à part greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
À partir de Qt 5.0 il faut inclure QtWidgets pour pouvoir utiliser la classe QWidget ainsi que toute sa descendance. Pour ce faire, il ne faut pas oublier d'ajouter dans ton fichier .pro la ligne de code que t'a passé Txiki.
De retour, plus sportif mais toujours aussi moche.
_____________
Pro: Programmation en C/C++ (embarqué ou non)
Loisir: Programmation en C++11/14/17 avec la STL ou Qt 5
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Partager