A voir également:
- QT
- Qt sdk - Télécharger - Langages
- Qt web - Télécharger - Navigateurs
- Qt tab bar - Télécharger - Personnalisation
- QT sous windows ✓ - Forum Programmation
- MessageBox avec QT ✓ - Forum C++
9 réponses
J'ai répondu à cette question, il y a moins d'une semaine...
Toute classe dérivant de 'QObject' possède un pointeur vers une classe QMetaObject (obtenu par la méthode 'QMetaObject * QObject::metaObject ()')qui possède une méthode 'const char * className ()' qui permet de savoir à tout instant à quelle classe appartient l'objet que l'on manipule.
Bonne continuation.
Toute classe dérivant de 'QObject' possède un pointeur vers une classe QMetaObject (obtenu par la méthode 'QMetaObject * QObject::metaObject ()')qui possède une méthode 'const char * className ()' qui permet de savoir à tout instant à quelle classe appartient l'objet que l'on manipule.
Bonne continuation.
Ah ben tu es mal car au final tu ne stockes qu'un pointeur. Donc à moins de stocker dans ta QList... une structure qui encapsule par exemple le pointeur et un entier qui permettra de savoir en quoi caster le pointeur, tu es mal barré.
Voici une idée de code que tu peux adapter pour ton problème.
Bonne chance
Voici une idée de code que tu peux adapter pour ton problème.
// Headers QT
#include <list>
#include <iostream>
typedef enum item_type_enum{
LINE_ITEM,
RECT_ITEM
} item_type_t;
// Ma liste encapsule des couples pointeur/entiers
// On accède au premier élément d'une paire via le champ 'first'
// et au second champ via 'second'.
typedef std::list<std::pair<void *,item_type_t> my_list_t;
int main(){
// Préparation de la liste (ici une std::list au lieu de la QList car je n'ai pas le
// mental pour aller dans la doc voir comment on remplit une QList)
// Je laisse volontairement des '...' dans les constructeurs des objets QT.
my_list_t my_list;
my_list.push_back(std::make_pair(new QGraphicsLineItem(....),LINE_ITEM);
my_list.push_back(std::make_pair(new QGraphicsRectItem(....),RECT_ITEM);
QGraphicsLineItem *pline;
QGraphicsRectItem *prect;
// Parcours de la liste
my_list_t::const_iterator
lit (my_list.begin()),
lend(my_list.end());
for(;lit!=lend;++lit){
switch(lit->second){
case LINE_ITEM: // L'item courant est un LineItem
pline = static_cast<QGraphicsLineItem *>(lit->first);
break;
case RECT_ITEM:
prect = static_cast<QGraphicsRectItem *>(lit->first);
break;
default:
std::cerr << "unknown item" << std::endl;
}
}
// Désallouer chaque élément alloué par new dans la liste
my_list_t::iterator
lit2 (my_list.begin()),
lend2(my_list.end());
for(;lit2!=lend2;++lit2) delete lit2->second;
// Fin
return 0;
}
Bonne chance
merci,
je suis nouveau dans le c ++ que signifie "typedef std::list<std::pair<void *,item_type_t> my_list_t"
et pourquoi std::make_pair?
merci bien
je suis nouveau dans le c ++ que signifie "typedef std::list<std::pair<void *,item_type_t> my_list_t"
et pourquoi std::make_pair?
merci bien
Euh alors la std::list c'est l'équivalent de ta QList. La std::pair tu peux la remplacer par un truc du genre :
Du coup tu manipules un QList<data_t>, et quand tu parcours tes éléments de QList, tu récupères le pointeur vers l'objet QT via le champ pQtItem et l'identifiant qui permettra de déterminer son type via le champ iType.
D'ailleurs dans mon message précédent au lieu d'utiliser un void * autant utiliser un QGraphicsItem * puisque les deux types QGraphicsLineItem et QGraphicsRectItem semblent en dériver.
Bonne chance
struct data_t{
QGraphicsItem * pQtItem; /**< pointe sur l'item QT */
item_type_t iType; /**< LINE_ITEM ou RECT_ITEM */
};
Du coup tu manipules un QList<data_t>, et quand tu parcours tes éléments de QList, tu récupères le pointeur vers l'objet QT via le champ pQtItem et l'identifiant qui permettra de déterminer son type via le champ iType.
D'ailleurs dans mon message précédent au lieu d'utiliser un void * autant utiliser un QGraphicsItem * puisque les deux types QGraphicsLineItem et QGraphicsRectItem semblent en dériver.
Bonne chance
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
Ah je connaissais pas ! Si effectivement QT propose ce genre de chose avec ses objets, on aurait tort de s'en priver. Du coup la méthode que j'ai proposé n'a d'intérêt que pour des objets non QT et qui ne proposent pas un mécanisme comparable.
Et oui, l'intérêt des méthodes virtuelles et des listes de pointeurs. Je suis étonné que tu n'y es pas pensé mamiemando ;-)
Ce n'est pas vraiment une histoire de méthode virtuelle, ca supposait de savoir que toutes les classes QT dérivent d'un objet parent qui file l'information, et ça dépend de l'implémentation. Je ne savais pas que QT avait prévu ça. Mais ça prouve une chose, c'est que QT, c'est bien fait... et qu'on en apprend tous les jours ;-)
Difficile de tout connaître de Qt ? Effectivement avec environ 500 classes... il y en a des tas que je n'ai jamais utilisées, alors de temps en temps il faut avoir la curiosité de lire un peu de doc, et c'est là aussi une richesse de Qt, la doc y est complète et, pour ma part, je la considère très bien faite.
Bonne continuation.
Bonne continuation.
Tout à fait d'accord, sauf que la dernière fois que j'ai eu besoin de QT c'était il y a 5 ans :-) Mais j'avais beaucoup aimé, c'est juste que depuis je n'en ai plus eu le besoin.
Il y a 10 ans au moins, j'avais commencé par choisir 'GTK' pour gérer l'interface de mes programmes. Puis il y a 7 ans, j'ai découvert Qt et j'ai été convaincu; il faut dire, qu'à l'époque, GTK était utilisé avec le 'C' alors que Qt nécessitait 'C++'. Depuis j'en suis un adepte farouche -;) Par exemple, je n'utilise plus les standards du C++ comme les containers car, même si ceux de Qt sont réputés plus lents (mais avec les programmes que j'écris: je n'ai jamais des millions d'éléments), ils sont tellements plus faciles à mettre en oeuvre et à gérer.
A chaque programme écrit, je remercie les concepteurs de Qt d'avoir mis cette bibliothèque en 'GPL' et quand bien même le morceau est gros à avaler, le jeu en vaut la chandelle.
Bonne soirée.
A chaque programme écrit, je remercie les concepteurs de Qt d'avoir mis cette bibliothèque en 'GPL' et quand bien même le morceau est gros à avaler, le jeu en vaut la chandelle.
Bonne soirée.