Creating QList of multiple object types

Question

I need to make multiple instances of various class types (classA, classB, classC), and store then in a single list. Is is possible to create these objects dynamically and then add them to a single QList? Something like:

QList<QObject> mylist;
mylist.append(classA());
mylist.append(classB());
mylist.append(classC());

This won't compile because the objects are not of type QObject. I could static_cast them to QObject, but will I be able to typeid.name() to determine their origical types? (To cast them back later)?

I found an example here of using a QList< QVariant >, but the compiler complains that:

error: no matching function for call to 'QVariant::QVariant(classA&)'

for this code:

QList<QVariant> mylist;
mylist.append(QVariant(tempObj));

Update:

I got it compiling by creating the object during the append operation, AND using ::fromValue.

mylist.append(QVariant::fromValue(ClassA(1,2,3)));

Not sure this is right. 1 - will this cause a memory leak/problem creating the object in the append statement? 2 - why would I need ::fromValue to make this work? (Does this just make a second copy of the object?)

I put a qDebug in my constructors, and I see that my constructor with parameters is called twice, then the copy constructor is called once, and the default (no parameters) constructor is never called. I don't understand that...

Why not just use a standard container such as std::list<QObject*> or std::list<std::unique_ptr<Object>>, since the objects are not QObjects? — PaulMcKenzie
I see no ways for a possible memory leak. QList will take ownership of the object. — It's Your App LLC
You need to use fromValue because the compiler will fail to find an overload of QList::append that takes a ClassA. — It's Your App LLC
Yeah, this is case where you want c++11 move semantics to cut down on the unnecessary copies. I am not sure but I don't think Qt is doing any move operations here. The code looks right. — It's Your App LLC
You are not using the heap (there are no new calls). You are allocating objects on the stack. They are unnamed meaning they are temporaries that "disappear" as soon as the statement finishes. ClassA constructor gets called once when you invoke it with ClassA(1,2,3). That returns a temporary that fromValue makes a copy of. That puts us at 1 constructor and 1 copy constructor. I am not sure what QList does but presumably its responsible for that final call to constructor that it makes when it "owns" the object. If you have move semantics you don't have to make so many unnecessary copies. — It's Your App LLC

It's Your App LLC It's Your App LLC · Accepted Answer · 2014-08-18T02:32:46

You can use QVariant which can hold any number of different types: QVariant API

To use QVariant with a custom type you need to register it with the metatype system: QMetaType This means using Q_DECLARE_METATYPE(MyClass) Q_DECLARE_METATYPE()

QVariant is designed for holding objects of different types, and is used in all sorts of Qt conventions when the programmer wants to pass around user-defined types through Qt's interfaces when Qt itself has no way of knowing which type the programmer wants to use.

To convert back to the original type use a combination of QVariant::canConvert() and QVariant::value():

QVariant v;

MyCustomStruct c;
if (v.canConvert<MyCustomStruct>())
    c = v.value<MyCustomStruct>();

v = 7;
int i = v.value<int>();                        // same as v.toInt()
QString s = v.value<QString>();                // same as v.toString(), s is now "7"
MyCustomStruct c2 = v.value<MyCustomStruct>(); // conversion failed, c2 is empty

Your custom type must provide:

a public default constructor,
a public copy constructor, and
a public destructor.

The following Message class is an example of an acceptable custom type for use in QVariant

class Message
{
 public:
   Message();
   Message(const Message &other);
   ~Message();

   Message(const QString &body, const QStringList &headers);

   QString body() const;
   QStringList headers() const;

 private:
   QString m_body;
   QStringList m_headers;
};

You could also declare your own "meta-type wrapper" that holds a type and a description of a type. The simplest example:

template <typename T>
class AnyType
{
public:
  enum THE_TYPE { MT_INT, MT_STRING };

  AnyType(T value, THE_TYPE type) : value(value), type(type) { }
  THE_TYPE getType() { return type; }
  T getValue() { return value; }

private:
  T value;
  THE_TYPE type;
}

Creating QList of multiple object types

2 Answers