Qt: Configurer mon propre QWidget dans le droit chemin

Question

Dans Qt, je suis en train de créer ma propre QWidget donc tout devrait fonctionner bonne grâce à la gestion de la mémoire et d'autres choses. Mais je ne peux pas sembler obtenir tout droit avec des pointeurs, tas et pile. J'ai mon MyWidget widget qui ont un QList avec quelques objets. Je ne peux pas comprendre comment mettre en place tout droit.

Vous pouvez voir mon code ci-dessous et j'ai quelques questions à ce sujet:

1. La liste variable instace est créée sur le tas, serait-il préférable de créer sur la pile?

2. Dans ma liste je pointeurs, serait-il préférable de simplement créer l'objet sur la pile et l'ajouter à la liste? (Alors que je n'ai pas des pointeurs dans la liste du tout)

3. Quand j'ajouter les objets à la liste vont-ils obtenir la liste que leurs parents automatiquement? Donc, lorsque je supprime la liste tous les objets à l'intérieur de la liste seront supprimés?

4. pour chaque boucle, je suis en train d'utiliser ne fonctionne pas, je me suis « était prévu un type pointeur / tableau pour cette opération au lieu de « int » »

5. Dans mon code, je veux créer d'autres widgets qui prend l'objet de la liste en tant que paramètres. Est-ce la bonne façon de le faire comme je l'ai? La méthode d'instance de MyOtherWidget ressemble à ceci: MyOtherWidget (MyObject * myObject, QWidget * parent)

Merci pour votre aide! Je suis nouveau à Qt et C ++ donc ce serait bien si vous pouviez me guider dans la bonne direction. Comment puis-je configurer cela dans la bonne façon de le rendre facile, ne pas les fuites de mémoire et d'utiliser aussi peu de mémoire selon les besoins. Comment voulez-vous configurer la même chose?

Ceci est mon code:

MyWidget.h:

class MyWidget : public QWidget
{
Q_OBJECT

public:
    MyWidget(QWidget *parent = 0);
    ~MyWidget();

private:
    QList<MyObject*> *list;
};

MyWidget.cpp:

MyWidget::MyWidget(QWidget *parent)
{
    ui.setupUi(this);

    list = new QList<MyObject*>();
    for (int i = 0; i<10; i++) 
    {
        MyObject *myObject = new MyObject("Hello",this);
        list->append(myObject);
    }

    foreach(MyObject *myObject, list)
    {
        //Lets say I want to create other widgets here and that they takes a MyObject as a parameter
        MyOtherWidget *myOtherWidget = new MyOtherWidget(myObject,this);
    }

}

MyWidget::~MyWidget(){
    delete list;
}

Answer 1

Ad.1. La durée de vie de la liste devrait être la même que la durée de vie de l'instance MyWidget, de sorte que vous pouvez en toute sécurité créer la liste sur la pile.

Ad.2. Vous pouvez le faire, mais MyObject la classe doit avoir un constructeur par défaut, un constructeur de copie et un opérateur d'affectation (voir http://doc.trolltech.com/4.6/containers.html#container-classes pour plus de détails).

Ad.3. La propriété de l'objet est transféré sur append. Tout comme conteneurs STL, les conteneurs Qt ne remet pas supprimer sur les pointeurs stockés. Pour supprimer tous les pointeurs stockés dans QList (ou un autre contenant Qt), vous pouvez utiliser qDeleteAll (liste). L'esprit, que vous ne voulez probablement pas de le faire dans le code affiché: vous passez MyWidget pointeur constructeur MyObject et je suppose qu'il est ensuite utilisé comme parent QObject. Donc, tous les QObjects seront supprimés lorsque MyWidget est supprimé.

Ad.4. Le deuxième argument de macro foreach doit être un conteneur, pointeur ne contenant. Donc, vous devez appeler foreach (MyObject * obj, * liste) si votre variable de liste est un pointeur sur QList.

Ad.5. Vous devriez être bien aussi longtemps que MyOtherWidget ne supprime pas le MyObject passé (parce que le MyWidget est déjà parent de MyObject et vous finirais supprimer le même objet deux fois).

Il est une simplification grossière, mais vous devriez essayer d'écrire votre code de telle sorte que vous ne aurez pas besoin d'appeler supprimer du tout. Créer des choses sur la pile ou compter sur le mécanisme parent-enfant Qt (à savoir les parents supprimer leurs enfants). Plus tard, vous pouvez lire des pointeurs sur les intelligents (QSharedPointer, QScopedPointer, etc.).

EDIT:

Si le parent de MyObject est définie ou non dépend de ce que vous faites dans le constructeur MyObject. Si vous passez argument parent au constructeur QObject, à savoir votre constructeur myObject ressemble à ceci:

MyObject(const QString &text, QObject *parent = 0) : QObject(parent)
{
// more code...
}

le parent sera mis, parce que ce sera fait dans le constructeur QObject, qui sera appelé à cause du code « : QObject (parent) ». Que faire si vous n'avez pas ce fragment? Depuis le MyObject hérite QObject, et vous ne spécifiez pas quel constructeur doit appeler le constructeur par défaut QObject, à savoir QObject (QObject * parent = 0) sera appelée, de sorte que le parent de votre MyObject sera NULL et il ne sera pas supprimé.

Je vais essayer d'éviter la mise en parent explicitement par la méthode SetParent - pour les cas d'utilisation de base de réglage parent dans le constructeur devrait être suffisant

.

Essayez d'utiliser la terminologie correcte (pas de « méthode d'instance », mais « constructeur »), lire la documentation Qt, de bon sens et essayer de ne pas penser que tout se fera automatiquement. Le parent n'est pas réglé « automatiquement » juste parce que vous appelez un argument « parent » - il est défini, car il y a un morceau de code qu'il fait dans le constructeur QObject et il est de votre responsabilité d'appeler passer parent propre au constructeur QObject dans les classes que QObject inherit.

Answer 2

Oui, le problème est que vous supprimez l'objet de votre liste, mais pas ses éléments!

Je vous suggère de jeter un oeil à:

QList<Employee *> list;
list.append(new Employee("Blackpool", "Stephen"));
list.append(new Employee("Twist", "Oliver"));

qDeleteAll(list.begin(), list.end());
list.clear();

Plus d'infos ici

Je voudrais également demander si vous avez vraiment besoin d'un pointeur sur votre liste? Vous pouvez simplement avoir un simple:

QList<MyObject*> list;

Par conséquent, vous avez une fuite de mémoire moins possible!

Espérons que cela aide un peu!

Edit:
3. Vos objets ont myObject « ce » en tant que parents. La liste ne prend pas la propriété des objets lorsque vous traitez avec des pointeurs.
4. Pour la boucle, peut-être vous devriez envisager itérateurs, jetez un oeil ici qthelp:. //com.trolltech.qt.460/qdoc/qlist.html

Answer 3

Vous n'avez pas besoin de stocker les widgets enfants dans une liste, aussi longtemps que vous les faites les parents du widget en cours. (En général, vous créez vos widgets sur la pile avec le nouveau).

Qt a une fonction d'auto-nettoyage, ce qui signifie que, si un widget se retire tous les widgets enfants (widgets dont le parent est le widget qui obtient enlevé) supprimeront à.

La seule chose que vous devez vous assurer (en particulier pour les widgets pop-up temporaires) pour effacer / supprimer le Widget « pop-up » ou comme vous appelez votre widget popup.

Voilà, voilà tout.