我如何确定模板参数参数是否是模板内结构中另一个类的实例？ C++

Question

我有一个 .h 文件，其中包含我的所有模板，还有一个 .cpp 文件，其中包含我的主文件。

.h 模板的一部分：

   template<int N, int P>
    struct BOUND {
        static inline int eval(int v) {
            //...
            return 1; 
        };
    };

    template<class K>
    struct VAL_x {
        static inline int eval(int v) {
            //...
            return 1;
        };
    };

    template<int L, class K>
    struct LIT {
        static inline int eval(int v) {
            //...
            return 1;
        };
    };

    template<class A, class B, class K>
    struct ADD {
        static inline int comp_b(int v){
            // HERE check if class A is LIT  or VAL_x
            //...
            return 2;
        };
    };

这是我在 main() 这个模板中的调用方式：

int main() {

    typedef ADD<VAL_x<BOUND<2,3> >, LIT<2, BOUND<2,3> >, BOUND<2,3> > FORM;
    FORM exec_form;

    int y = 2;

    int bounds = exec_form.comp_b(y);

    return 0;
}

---

我如何知道我的struct 的ADD::comp() 函数中传递的参数是否是特定类的实例（例如LIT<>）？这些参数可以按任何顺序传递（例如，所有参数都可以是LIT，或者只有第二个）

注意：除了VAL_x、LIT、BOUND和ADD之外，还有其他结构。

Answer 1

选项 #1

为每个感兴趣的类模板引入一个单独的特征（C++03 在这里没有多大帮助）。

template <bool B> struct bool_constant { static const bool value = B; };
template <bool B> const bool bool_constant<B>::value;

template <typename T>   struct is_LIT : bool_constant<false> {};
template <int L, int M> struct is_LIT<LIT<L, M> > : bool_constant<true> {};

template <typename T> struct is_VAL_x : bool_constant<false> {};
template <int K>      struct is_VAL_x<VAL_x<K> > : bool_constant<true> {};

template <class A, class B>
struct ADD 
{
    static inline int comp_b(int v)
    {
        if (is_LIT<A>::value && is_VAL_x<B>::value)
        {

        }

        return 2;
    }
};

DEMO

选项 #2

使用通用的自定义特征，其特化检测传递的类型是否是指定模板模板参数的实例化（如果特化匹配，即T是类模板X的实例化）：

template <template <int> class X, typename T>
struct is_template { static const bool value = false; };

template <template <int> class X, int N>
struct is_template<X, X<N> > { static const bool value = true; };

template <typename A, typename B>
struct ADD 
{
    static inline int comp_b(int v)
    {
        if (is_template<VAL_x, A>::value && is_template<LIT, B>::value)
        {
        }

        return 2;
    }
};

DEMO 2

选项#3

使用标签调度，可能为返回true/false的其他类模板添加重载，使其类似于选项#1。此解决方案还依赖于重载解决方案，它更喜欢更专业的函数模板，而不是那些限制较少/通用的。

template <typename T> struct tag {};

template <typename A, typename B>
struct ADD 
{
    static inline int comp_b(int v)
    {
        return comp_b(v, tag<A>(), tag<B>());
    }

    template <int M, int N>
    static inline int comp_b(int v, tag<LIT<M> >, tag<VAL_x<N> >)
    {
        return 1;
    }

    template <typename T, typename U>
    static inline int comp_b(int v, tag<T>, tag<U>)
    {
        return 2;
    }
};

DEMO 3

Answer 2

你可以这样做：

#include <typeinfo>
...
template<class A, class B>
struct ADD {

    static inline int comp_b(int v){
        // HERE check if class A is LIT  or VAL_x
        std::cout << ( typeid(A)==typeid(VAL_x) ) << '\n';
        return 2;
    };
};

我在哪里使用std::type_info，它将打印 1，以进行真正的评估。

或者，使用c++11，您可以这样做：

#include <type_traits>
...
if (std::is_same<A, VAL_x>::value)
    std::cout << "they are same!\n";

---

但是，您可以重载函数等。确保你阅读了这个：How do I check my template class is of a specific classtype? 和这个How to check for the type of a template parameter?