QT

Fermé
lil - 20 oct. 2009 à 15:31
mamiemando Messages postés 33446 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 décembre 2024 - 22 oct. 2009 à 18:36
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

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 33446 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 décembre 2024 7 812
20 oct. 2009 à 18:34
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
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 33446 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 décembre 2024 7 812
20 oct. 2009 à 19:03
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 33446 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 décembre 2024 7 812
20 oct. 2009 à 21:22
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 9813 Date d'inscription vendredi 23 avril 2004 Statut Contributeur Dernière intervention 3 octobre 2023 1 298
21 oct. 2009 à 10:07
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 33446 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 décembre 2024 7 812
21 oct. 2009 à 18:08
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
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 33446 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 décembre 2024 7 812
21 oct. 2009 à 19:01
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
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 33446 Date d'inscription jeudi 12 mai 2005 Statut Modérateur Dernière intervention 20 décembre 2024 7 812
22 oct. 2009 à 18:36
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