QT

lil -  
mamiemando Messages postés 34243 Date d'inscription   Statut Modérateur Dernière intervention   -
Bonjour,

J ai une liste de ce type QList<QGraphicsItem*> itemList ou est est enregistre les objects de type
QGraphicsLineItem*, QGraphicsrectItem*...
En parcourant la liste comment savoir si j ai a faire a un QGraphicsLineItem*, QGraphicsrectItem*...?
Merci
A voir également:

9 réponses

loupius
 
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.
1
mamiemando Messages postés 34243 Date d'inscription   Statut Modérateur Dernière intervention   7 898
 
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.

// 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
0
lil
 
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
0
mamiemando Messages postés 34243 Date d'inscription   Statut Modérateur Dernière intervention   7 898
 
Euh alors la std::list c'est l'équivalent de ta QList. La std::pair tu peux la remplacer par un truc du genre :

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
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
mamiemando Messages postés 34243 Date d'inscription   Statut Modérateur Dernière intervention   7 898
 
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.
0
Char Snipeur Messages postés 10112 Date d'inscription   Statut Contributeur Dernière intervention   1 299
 
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 ;-)
0
mamiemando Messages postés 34243 Date d'inscription   Statut Modérateur Dernière intervention   7 898
 
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 ;-)
0
loupius
 
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.
0
mamiemando Messages postés 34243 Date d'inscription   Statut Modérateur Dernière intervention   7 898
 
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.
0
loupius
 
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.
0
mamiemando Messages postés 34243 Date d'inscription   Statut Modérateur Dernière intervention   7 898
 
Bah la STL ça s'utilise bien et ça dépote :-) C'est ce que j'utilise en pratique. Mais sinon c'est clair que QT c'est bien, et les containers de QT (QList et autres) sont sans doute plus simples à prendre en main. En tout cas merci pour les précisions que tu as apporté sur QT.
0