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

我有一个

.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;
        };
    };

---

在我的

struct

的

ADD:：comp（）

函数中，如何知道传递的参数是否是特定类的实例（例如

LIT

）？这些参数可以按任何顺序传递（例如，所有参数都可以是

LIT

，或者仅第二个参数）

---

注意：除了

VAL\u x

、

LIT

、

BOUND

和

ADD

之外，还有其他结构。您可以这样做：

#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;
    };
};

#包括
...
模板
结构添加{
静态内联内部组件b（内部v）{
//在这里检查A级是否亮起或VAL_x
标准：：cout选项#1
为每个感兴趣的类模板引入一个单独的特性（C++03在这里帮助不大）


选项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;
    }
};

模板结构标记{}；
模板
结构添加
{
静态内联内部组件b（内部v）
{
返回comp_b（v，tag
您是指模板中的一个参数，对吗？不是
comp（）
的参数。这里最好举一个简单的例子：您的示例不起作用，因为您缺少
某物的模板参数
@Dani我很抱歉，因为我试图更改名称，但忘记了它…我现在将更新它以使其更易于理解。@gsamaras@Dani我已更新了我的代码。谢谢@marialena，此
模板
的目的是什么？我已更新了my代码；我的
VAL_x
struct也在类似
LIT
的模板中。我正在尝试添加
add
struct您建议的第一个解决方案，但是
VAL_x
需要模板参数。如果
VAL_x
我知道参数。但是如果
LIT
我不知道。这是我尝试过的，但有一个e缺少模板参数时出错。
bool isLIT=typeid（A）==typeid（VAL_x）；isLIT？“true”：“false”；printf（“%s\n”，isLIT）；
@marialena这很有意义，不是吗？：）此检查是在编译时进行的，因此您也应该提供参数。例如，VAL_x将起作用，但您的意思是明天可能是4，对吗（这两个不一样）？是的。这当然有意义。我在main中给出的公式可以是任何东西。例如，
LIT
可以是第一个参数，
VAL\ux
可以是最后一个参数。或者两者都可以是
LIT
或
VAL\ux
。我只想在
ADD
@marialena中检查它们的类，Piotr的答案也有意义，请检查它是否正确ut！！谢谢你的支持。Piotr，太棒了！！我不知道你是否支持我的答案，但这更好，值得我更多的支持！请你解释一下你的解决方案好吗？至少有一个。：）我尝试了第一个选项。正如我所见，你的示例受到结构模板参数数量的影响。所以我已经为我的结构输入了正确数量的参数。我没有想到这会有什么关系。如果你能向我解释一下你的例子是如何工作的，我可以修改它，使它适合我的情况。改变的是，
ADD
需要三个参数，
LIT
需要2个参数。但是在
ADD
结构中，我只想要检查第一个和第二个模板参数的类。我不关心第三个。@marialena我认为您试图实现的是一个模板化的AST，对吗？如果我是对的，您不需要对模板参数类型进行“分支”，它们已经提供了更改实现的点，最多您需要传递一个“环境"参数不需要100%的百分率。我想是的…我是C++模板的新手，所以我只是想学习模板是如何工作的以及它们是如何相互作用的。@达里奥，不，你误解了我。这只是一个小部分。我只是简化了代码中的细节。我只想知道我是否。可以识别参数的类别。但当然，解决方案需要一个完整的示例才能应用于我的案例。对于由此造成的不便，我深表歉意。我将尝试查看Piotr的更新选项。谢谢大家。
#include <type_traits>
...
if (std::is_same<A, VAL_x>::value)
    std::cout << "they are same!\n";

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;
    }
};

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;
    }
};

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;
    }
};