External code emitting my Qt signal: is QPrivateSignal the right guard for a public signals section?

The Short Answer

Yes, QPrivateSignal is the correct idiom for preventing compile-time emission of signals by external code. It effectively blocks direct C++ calls to emit mySignal() from outside the class because the caller cannot instantiate the required private token. However, it does not provide a runtime security boundary; it cannot block the Qt Meta-Object System from triggering the signal.

How the Boundary Works

The idiom relies on C++ access control rather than Qt-specific logic. By adding a parameter of a type defined in the private section of your class, you create a dependency that external code cannot satisfy.

What is Blocked

• Direct C++ Calls: Any attempt to call emit mySignal() from an external class will fail at compile time because the compiler cannot find a valid constructor for the QPrivateSignal argument.
• New-Style Connects: connect(&sender, &Sender::mySignal, ... ) continues to work perfectly because the connection only requires a pointer to the member function, not an instance of the arguments.

What is NOT Blocked

• QMetaObject::invokeMethod: Since this operates via the meta-object system at runtime, it bypasses C++ access modifiers and type checks. It can still trigger the signal.
• String-based SIGNAL(): Legacy connections using the SIGNAL() macro resolve names at runtime and will still trigger the signal.

Implementation and Side Effects

To implement this in Qt 5.15 or 6, use the following pattern:

class MyObject : public QObject {
    Q_OBJECT
private:
    struct QPrivateSignal {}; // Token type

public:
    // Signal with a defaulted private token
    signals:
        void dataChanged(int newValue, QPrivateSignal = QPrivateSignal());
};

Critical Considerations

Area	Impact	Result
MOC Signature	Changed	The meta-object system now sees the QPrivateSignal as part of the signature.
Legacy Connects	Broken	Existing connect(..., SIGNAL(dataChanged(int)), ... ) calls will fail because the signature no longer matches.
Private Slots	Accessible	private slots are only private to the C++ compiler; they remain reachable via invokeMethod.

Verification Steps

1. Compile-time check: Attempt to call object->mySignal(10); from a different class. It should trigger a compiler error regarding the private QPrivateSignal struct.
2. Runtime check: Use QMetaObject::invokeMethod(object, "mySignal", ... ). If the signal fires, you have confirmed that the meta-object system bypasses the guard.

Diagnostic Detail Required: Are you currently using any string-based SIGNAL() connections or QMetaObject::invokeMethod calls for these signals? If so, adding the private token will break those connections.