轻量级QObject-兼容的基类

Question

QObject's versatilty causes it to be fairly large.

I want to use it only for static properties (essentially just QMetaObject), without incurring the massive 120 byte penalty for inheriting from QObject.

Is there a lightweight equivalent?

---

Edit

Here are the profiling results - it's painful to have ~30MB wasted for a mid-size task (some can be ~20x larger). Note the b-written ratio - the QObject constructor sets a lot of state that is almost never inspected.

==10302== ======== ORDERED BY decreasing "max-bytes-live": top 10 allocators ========
==10302==
==10302== -------------------- 1 of 10 --------------------
==10302== max-live:    31,264,224 in 229,884 blocks
==10302== tot-alloc:   31,264,224 in 229,884 blocks (avg size 136.00)
==10302== deaths:      none (none of these blocks were freed)
==10302== acc-ratios:  0.01 rd, 1.16 wr  (459,768 b-read, 36,321,672 b-written)
==10302==    at 0x4C275C0: operator new(unsigned long) (in /usr/lib64/valgrind/vgpreload_exp-dhat-amd64-linux.so)
==10302==    by 0x53E1551: QObject::QObject(QObject*) (in /usr/lib64/qt4/libQtCore.so.4.8.5)
==10302==    by 0x50465CA: Util::Util() (util.h:84)

Answer 1

You could take a look at Q_GADGET (Relevant for Qt versions < 5.5)

Use Q_GADGET instead of Q_OBJECT to enable the meta object system's support for enums in a class that is not a QObject subclass. Q_GADGET makes a class member, staticMetaObject, available. staticMetaObject is of type QMetaObject and provides access to the enums declared with Q_ENUMS. Q_GADGET is provided only for C++.

You can also set/get Q_FLAGS and Q_CLASSINFO this way, but you can't use Q_PROPERTY, you simply need to derive from QObject for that.

Edit:

Qt 5.5 added the following extra functionality:

Qt Core: You can now have Q_PROPERTY and Q_INVOKABLE within a Q_GADGET, and there is a way to query the QMetaObject of such gadget using the QMetaTYpe system.

Answer 2

A QObject is not a value class. It is meant to be used for its behaviors. It can often act as a facade to non-object instances. For example, a single object instance can act as an event filter for multiple other objects. Thus, even in fairly complex systems, you won't have very many QObject instances. Its "weight" then isn't that much of a concern.

An object's size depends on how it's used. An object without connections or dynamic properties takes less space than one with connections or dynamic properties. The space requirement must be determined by instrumenting the memory allocator or inspecting the code. A QObject is a handle class and by itself has a size of two pointers (a d-pointer and a vtbl-pointer). The PIMPL takes additional memory, as does the pimpl extension that doesn't get allocated by default.

For a sense of perspective, the size of an otherwise empty class instance with virtual methods is 8 bytes on a 64 bit system. A QObject that's merely an order of magnitude larger than a pointer is, I'd say, a steal . Calling it heavy is IMHO preposterous :) On my machine, an empty std::map<std::string, QVariant> is 1/3 the size of a QObject .

If all you want is a static metamethod mechanism, you're probably trying too hard to leverage moc. You could use a code generator, like, say, the excellent gsl and make your own. If your memory requirements are so critical, you'll need a custom solution anyway. You better had performance and profiling information to back up your desire not to re-use QObject , though. If you wish to build gsl using qmake, here's a qmake project for it .