背景

对于初学者，我已经定义了一个空基Message类，其唯一目的是继承并创建具体TMessage实现。在Qt中，虽然可以将信号连接到仿函数（而不是Qt槽），但是信号不能是模板函数，所以我的解决方案是模拟Message类的关系，创建一个抽象Messenger类，带有void signal_Message(Message)信号和template <typename T> void slot_T(TMessage<T>)。然后我遇到了这个问题，使用不受支持的类型时，偶数代码在编译时失败，并显示一条错误消息： invalid initialization of reference of type Messenger<double>& from expression of type MessengerBag<int, char>

问题

考虑到我们使用6种不同类型，int，float，char，double，一些enum和struct。这产生了sizeof96个字节！但是，考虑到所需的用法是用于具有超过50个用户定义类型的地方，每个地方都有自己独立维护的信号和插槽容器，看起来我的解决方案可以在大约相同的开销下执行相同的任务，但旁边没有维护费用。除了不再需要维护24个独立功能的明显好处之外，在复杂的继承方案的情况下甚至可能更多，这种方法是否存在缺点？做了一些初步测试后，我发现了MessengerBag基本上与钻石图案相反。每个析构函数都会相应调用，因此与复合结构相比，我几乎看不到任何缺点，复合结构需要另一个级别（我认为是不必要的和混淆的）间接。Qt本质上鄙视虚拟继承，并且在直接继承QObject的类中禁止它：因此我不能像我希望的那样使Mock虚拟化。

例

// Message.h
struct Message {};
template <typename T> struct TMessage {
    T t
};

// Messenger.h
struct Messenger : public QObject {
    Q_OBJECT
public:
    template <typename T> void slot_doSomethingWithMsg(const Message& msg){
        const auto& tmsg = static_cast<const TMessage<T>&>(msg);
        qDebug() << tmsg.t;
        // do something else... this is just example usage
    }
signals:
    void signal_sendMsg(const BaseMsg& msg);

// MessengerBag.h

template <typename T, typename... Args>
struct MessengerBag : TMessenger<T>, MessengerBag<Args...>{};

template <typename T> struct MessengerBag<T> : TMessenger<T>{};

// Manager.h

MessengerBag<int, char> messengerBag;

Manager(){
    QObject::connect(static_cast<TMock<int>*>(messengerBag),
                     &Mock::signal_sendMsg, 
                     static_cast<TMock<int>*>(messengerBag),
                     &Mock::slot_doSomethingWithMsg<int>);

    QObject::connect(static_cast<TMock<char>*>(messengerBag),
                     &Mock::signal_sendMsg, 
                     static_cast<TMock<char>*>(messengerBag),
                     &Mock::slot_doSomethingWithMsg<char>);

template <typename T> void slot_sendMsg(const TMessage<T>& msg){
    TMessenger<T>& messenger = messengerBag;
    messenger.signal_sendMsg(msg);
}

// main.cpp

auto* manager = new Manager();

TMessage<int> imsg{5};
TMessage<char> cmsg{'f'};

manager->slot_sendMsg(imsg);
manager->slot_sendMsg(cmsg);

正如所料，上面的例子输出5和'f'，从而颠覆了模板信号和插槽的问题。但是，我在将来遇到任何可能的问题时遇到一些麻烦。一个问题当然QObject是无法访问的，因为它QObject仍然是未知的，组合解决方案可能会进行调解（使TMessenger委托Messenger，并在空的专业化中MessengerBag继承。，请对代码本身发表任意评论。

tl;dr

Qt信号调用函子，但信号不能是模板。QObject为了通过使用基Message类创建模板样式信号，让对象继承多个派生的模板类是否有任何缺点？这Message是信号的参数（因此信号和模板仿函数具有基本版本（之后仿函数将其转换为正确的类型T）。结构将像一包这些模板类一样，继承所有这些模板类。为了允许在任何时候向正确的模板类进行向上转换。