将具有继承同一类的不同类型的对象存储在容器中

Question

I have the following classes:

class ActivityItem : public QGraphicsItem;
class DeadTimeItem : public QGraphicsItem;

I am at a point where I need to store both objects of type ActivityItem and DeadTimeItem in the same container so I can work with them together.

What have I tried?

I tried creating a QVector that stores QGraphicsItem type, but I got the result that it cannot store abstract class types. What should I do?

My plan

My plan is to store these elements into QVector<T> member of a class timeline , because they will create a timeline. For example:

class timeline : public QGraphicsScene // is this a good idea? to inherit QGraphicsScene?
{
private:
    QVector<QGraphicsItem*> items;
    int left_offset; // this is for putting the items next to each other
public:
    timeline();
    void add_item( QGraphicsItem *item );
    ~timeline();
}

My timeline should look like the sketch below:

So, when the user calls add_item() method,

Timeline *timeline;
timeline->add_item( new ActivityItem( /* parameters */ ) ); // timeline->left_offset += 150;
timeline->add_item( new DeadTimeItem( /* parameters */ ) ); // timeline->left_offset += 100;

the left_offset increases depending on the type of the inserted item.

I know my post is quite long, but please read it completely, because I really need your help! Thank you!

As you've already guessed, I am using Qt. I can also use boost if it is really necessary.

Answer 1

You cannot create an instance of an abstract class, which is fortunate, because trying to assign a derived class to a base class provokes slicing or misbehaves in other interesting ways.

Due to the above restriction, no standard container for base can store a derived. You can circumvent this limitation by using pointers to base, either raw (non-owning) pointers or some smart-pointer type.

The answer using the standard library would be something like:

std::vector<std::shared_pointer<QGraphicsItem>> v;

Using QT classes:

QVector<QSharedPointer<QGraphicsItem>> qv;

Answer 2

Assuming

• QGraphicsItem objects are part of the same scene and have a parent
• The list is tightly tied to the scene (member variable of the same class which owns the scene, or member variable of a scene subclass).

Then you should use this:

    QList<QGraphicsItem*> items; // or QVector or std::list, nearly same

These are raw pointers, they will not automatically delete the object when removed from list, nor will they get notified when item is deleted. Still, I don't know of a smart pointer type, which would work with QGraphicsItem , so raw pointers are what you must use. So if you need to also remove items dynamically, read on:

---

First of all, when you delete item, you need to also remove the pointer from this list, to avoid having dangling pointer. As an example, you may want to use something like QList::indexOf() and QList::removeAt() methods for this (also, if removal is very common and there are many items in the list, you may need to rethink the approach, as removing from an big array is slow). You need to be careful that item doesn't get deleted by some Qt code without you having a chance to remove it from the list.

Things get more complicated, if you may have items in the list, which also have their children in the list. If you just delete an item, it will delete it's children, so if your list has pointers to these and your list will end up with dangling pointers to those children. So, you need to do deletion very carefully. There are at least 3 different ways to go about this I can think of (recursive deletion in your own code, removing from list in item destructors, using event filter to catch item removals), so I can expand the answer, if this situation can happen in your code.

Final note: when the entire scene is deleted, it will delete all its children. Only thing you need to do here is make sure the pointers to deleted items in the list don't ever get used, for example simply by clearing the list.