Templates 单个模板类的可变模板包

具有以下示例：

/* Signal Container */
template <typename Ret> class Signal;

template <typename Ret, typename... Args>
class Signal< Ret (Args...) >
{
    /* Following Implementation... */
};

/* Emitter Type */
template < template <typename Ret, typename... Args> Signal< Ret (Args...) > ... Sig>
class Emitter
{
    // using Signals = std::tuple<Sig...>;

    /* Following Implementation... */
};

/* Signals */
using Signal_A = Signal<void()>;
using Signal_B = Signal<void(int)>;
using Signal_C = Signal<void(int, float)>;

/* Desired Usage */
class MyType : public Emitter<Signal_A, Signal_B, Signal_C>
{

};

如果有人能澄清这一点或提供一个有效的解决方案，我将不胜感激

---

可用的编译器：MinGW GCC 4.9.2（也是5.1.0）

您不必匹配类模板

发射器中
信号的所有内部类型。您只需声明它是一个接收参数的模板。在此之后，您将需要在应用程序中重复出现最多可允许的最小数量的
信号。假设最小值为1，这里有一个解决方案

/* Signal Container */
template <typename Ret>
class Signal;

template <typename Ret, typename... Args>
class Signal<Ret(Args...)> {};

/* Emitter Type */
template <typename... Args>
class Emitter;

template <typename T>
class Emitter<Signal<T> > {
    // definition of class with single signal
};

template <typename T, typename... Args>
class Emitter<Signal<T>, Args...> {
    // definition of class with MORE THAN one signal
};

/* Signals */
using Signal_A = Signal<void()>;
using Signal_B = Signal<void(int)>;
using Signal_C = Signal<void(int, float)>;

/* Desired Usage */
class MyType : public Emitter<Signal_A, Signal_B, Signal_C> {};

int main() {
    MyType x;
}

/*信号容器*/
模板
类信号；
模板
类信号{}；
/*发射器类型*/
模板
类发射器；
模板
类发射器{
//单信号类的定义
};
模板
类发射器{
//具有多个信号的类的定义
};
/*信号*/
使用信号_A=信号；
使用信号_B=信号；
使用信号_C=信号；
/*预期用途*/
类MyType:公共发射器{}；
int main（）{
myx型；
}
在C++11或C++14中，您不能简单地实现自己的目标。概念可能会给我们一些东西，但现在您的模板参数必须是类型、类模板或值。在您的情况下，您需要一组信号，这些信号只能指定为：

template <typename... Sigs>
class Emitter;

您必须为
is\u signal
编写一个类型特征，并为
all\u true
提供一个元函数。后者的一个例子可以找到
我将此作为一个答案发布，因为它确实满足了问题中的要求。尽管我做了一个正确的回答。我认为发布我的最终方法是合适的

#include <iostream>

/* Signal Container */
template <typename Ret> class Signal;

template <typename Ret, typename... Args>
class Signal< Ret (Args...) >
{
    /* Following Implementation... */
};

namespace {
    /* Signal Type Traits */
    template < typename T >
    struct IsSignal { static constexpr bool Value = false; };

    template < typename T >
    struct IsSignal< Signal< T > > { static constexpr bool Value = true; };

    /* Signal Validation */
    template < bool V, typename... Args >
    struct AreSignals
    {
        static constexpr bool Value = V;
    };

    template < bool V, typename T, typename... Args >
    struct AreSignals< V, T, Args... >
    {
        static constexpr bool Value = AreSignals< V && IsSignal< T >::Value, Args... >::Value;
    };

}

/* Emitter Type */
template < typename... Args >
class Emitter
{
    // Block unsupported signals
    static_assert( AreSignals<true, Args...>::Value, "Unsupported signal type" );

    using Signals = std::tuple<Args...>;

    /* Following Implementation... */
};

using Signal_A = Signal<void()>;
using Signal_B = Signal<void(int)>;
using Signal_C = Signal<void(int, float)>;

class MyType : public Emitter<Signal_A, Signal_B, Signal_C>
{

};

int main(int argc, char **argv)
{
    std::cout << AreSignals<true, Signal_A, Signal_B, Signal_C>::Value << "\n"; // 1 (true)

    std::cout << AreSignals<true, Signal_A, int, Signal_B, Signal_C>::Value << "\n"; // 0 (false)

    return EXIT_SUCCESS;
}

#包括
/*信号容器*/
模板类信号；
模板
类信号
{
/*在执行之后*/
};
名称空间{
/*信号类型特征*/
模板
struct IsSignal{static constexpr bool Value=false；}；
模板
struct IsSignal{static constexpr bool Value=true；}；
/*信号验证*/
模板
结构信号
{
静态constexpr布尔值=V；
};
模板
结构信号
{
静态constexpr bool Value=AreSignals：Value，Args…>：Value；
};
}
/*发射器类型*/
模板<类型名。。。Args>
类发射器
{
//阻止不支持的信号
静态断言（AreSignals:：Value，“不支持的信号类型”）；
使用Signals=std:：tuple；
/*在执行之后*/
};
使用信号_A=信号；
使用信号_B=信号；
使用信号_C=信号；
类MyType:公共发射器
{
};
int main（int argc，字符**argv）
{
我不能谢谢你。这就是我最终得到的。我只想对模板包中收到的类型进行一次简单的验证。
static_assert(all_true<is_signal<Sigs>::value...>::value, "Emitter must use only Signals");

#include <iostream>

/* Signal Container */
template <typename Ret> class Signal;

template <typename Ret, typename... Args>
class Signal< Ret (Args...) >
{
    /* Following Implementation... */
};

namespace {
    /* Signal Type Traits */
    template < typename T >
    struct IsSignal { static constexpr bool Value = false; };

    template < typename T >
    struct IsSignal< Signal< T > > { static constexpr bool Value = true; };

    /* Signal Validation */
    template < bool V, typename... Args >
    struct AreSignals
    {
        static constexpr bool Value = V;
    };

    template < bool V, typename T, typename... Args >
    struct AreSignals< V, T, Args... >
    {
        static constexpr bool Value = AreSignals< V && IsSignal< T >::Value, Args... >::Value;
    };

}

/* Emitter Type */
template < typename... Args >
class Emitter
{
    // Block unsupported signals
    static_assert( AreSignals<true, Args...>::Value, "Unsupported signal type" );

    using Signals = std::tuple<Args...>;

    /* Following Implementation... */
};

using Signal_A = Signal<void()>;
using Signal_B = Signal<void(int)>;
using Signal_C = Signal<void(int, float)>;

class MyType : public Emitter<Signal_A, Signal_B, Signal_C>
{

};

int main(int argc, char **argv)
{
    std::cout << AreSignals<true, Signal_A, Signal_B, Signal_C>::Value << "\n"; // 1 (true)

    std::cout << AreSignals<true, Signal_A, int, Signal_B, Signal_C>::Value << "\n"; // 0 (false)

    return EXIT_SUCCESS;
}