Making default constructor private in Qt custom object

I'm reading this Qt doc page about custom types, and it states the following:

The default constructor, copy constructor and destructor are all required, and must be public, if the type is to be integrated into the meta-object system.

Suppose I have an object that needs to be built with some required parameters, because it has no sense to be built using the default constructor, for example:

struct IntPair
{    
    IntPair(int first, int second);
    ~IntPair();
};

To make it available in the Qt Meta Object system, as the doc states, it requires the default constructor. But practically, it has no sense to give the opportunity to build an IntPair object without a pair of integer numbers (sorry for the ugly example).

Is there a way to achieve this without implementing the default constructor? I'm thinking about a sort of friendship between my object and the Qt Meta Object system...

Basically, I cannot understand why the default constructor is needed.

Solution

There are two parts to the question:

Achieving a custom Meta Object without implementing a default ctor.
Understanding why a default ctor is required by Qt in this case.

Other respondents have addressed (2) already.

I wish to address (1).

I wrote a class, and I intend for users of this class to call a ctor I wrote which requires several arguments. However, because of the Qt-related requirements, I am forced to add a zero-argument constructor.

It would make me happy to at least make the zero-arg ctor private, so that I could enforce that all user code EXCEPT moc-generated "magic" code will be barred from using that ctor.

Hello, happiness! It is possible.

You can indeed use friendship to make the default ctor private and still use Qt Metatype.

It looks something like this:

class MyClass {
  Q_GADGET

  Q_PROPERTY(QString text READ text)

 public:
  MyClass(QString text, bool sometruth, int someint);

  QString text() const { return text_; }

 private:
  // Works in my project using Qt 5.12. (see hints below if it fails for you)
  friend struct QtMetaTypePrivate::QMetaTypeFunctionHelper<MyClass, true>;
  // Prefer the ctor that takes arguments. This ctor only exists to satisfy Qt.
  MyClass();

  QString text_;
};

There are two ways you can solve the problem of figuring out WHAT to befriend.

You can mark the ctor private, try to recompile, and scrutinize the compiler error to figure out what other type is trying to access the ctor of your class.

Or, you can put an assert(false); in the body of your ctor, create a binary with debug symbols (including Qt debug symbols), then look at the stack in the debugger when the assertion fails. The stack will show the Qt-internal member-function or free function that called into your ctor. Friend whatever that caller is.

This last method (using the debugger) is what worked for me. (I wasn't fluent enough in compiler-ese to discern which type from the output of the gigantic compiler error was what I needed to add as my friend.)