代码之家 › 专栏 › 技术社区 › Fabio

使用enable\ if只匹配具有特定静态数据成员且只有特定值的类

template-specialization template-meta-programming boost templates c++

Fabio · 技术社区 · 6 年前

下面的代码说明了这个意图,但是除非我注释掉与 B 中的类 main . 这是因为 code Bx 班级,但是 enable_if 如果模板参数具有 代码 成员变量。我应该如何修改它?

-std=c++03 .

谢谢

#include <iostream>
#include <boost/core/enable_if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/not.hpp>
#include <boost/mpl/bool.hpp>
using std::cout;
using namespace boost;
using namespace boost::mpl;

template <int N> struct A1 { static const int code = N; };
template <int N> struct A2 { static const int code = N; };
// ... other classes with static data member 'code'
template <int N> struct AN { static const int code = N; };

struct B1{};
struct B2{};
// ... other classes potentially passd as argument to the foo function
struct BN{};

template <typename T>
struct Condition : or_<bool_<T::code == 1>, bool_<T::code == 2> > {};


template <typename T>
typename enable_if<not_<Condition<T> >, void>::type
   foo(const T& arg) { cout << "This class does not have a static member code or its value is not 1 or 2\n"; }

template <typename T>
typename enable_if<Condition<T>, void>::type
   foo(const T& arg) { cout << "This class has a static member code and its value is " << T::code << "\n"; }

int main()
{
    foo(A1<0>()); // this should match the 1st version of foo
    foo(A2<1>()); // this should match the 2nd version of foo
    foo(AN<2>()); // this should match the 2nd version of foo
    foo(B1());    // this should match the 1st version of foo
    foo(BN());    // this should match the 1st version of foo
}

2 回复 | 直到 6 年前

max66 6 年前

真正的问题是你需要一个C++ 03解决方案,所以你可以使用SfEAE,但不是所有的语言改进都可以从C++ 11开始。

不管怎样,我建议你一个解决方案,是复杂的像你的(也许更多),但完全没有刺激。

如果定义了一个普通的BoL包装器(它可以粗略地取代C++ 11) std::true_type std::false_type )

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

template <typename, typename = bool_wrapper<true> >
struct cond : public bool_wrapper<false>
 { };

template <typename T>
struct cond<T, bool_wrapper<(1 == T::code) || (2 == T::code)> >
   : public bool_wrapper<true>
 { };

如果你定义一个 enable_if 类型特征(与C++ 11相同) std::enable_if

template <bool, typename = void>
struct enable_if
 { };

template <typename T>
struct enable_if<true, T>
 { typedef T type; };

您可以启用/禁用 foo() 功能

template <typename T>
typename enable_if<false == cond<T>::value>::type foo (T const & arg)
 { std::cout << "no static member code or value not 1 and not 2\n"; }

template <typename T>
typename enable_if<true == cond<T>::value>::type foo (T const & arg)
 { std::cout << "static member code and its value is " << T::code << "\n"; }

#include <iostream>

template <int N> struct A1 { static const int code = N; };
template <int N> struct A2 { static const int code = N; };
// ... 
template <int N> struct AN { static const int code = N; };

struct B1{};
struct B2{};
// ...
struct BN{};

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

template <typename, typename = bool_wrapper<true> >
struct cond : public bool_wrapper<false>
 { };

template <typename T>
struct cond<T, bool_wrapper<(1 == T::code) || (2 == T::code)> >
   : public bool_wrapper<true>
 { };

template <bool, typename = void>
struct enable_if
 { };

template <typename T>
struct enable_if<true, T>
 { typedef T type; };


template <typename T>
typename enable_if<false == cond<T>::value>::type foo (T const & arg)
 { std::cout << "no static member code or value not 1 and not 2\n"; }

template <typename T>
typename enable_if<true == cond<T>::value>::type foo (T const & arg)
 { std::cout << "static member code and its value is " << T::code << "\n"; }

int main ()
 {
   foo(A1<0>()); // match the 1st version of foo
   foo(A2<1>()); // match the 2nd version of foo
   foo(AN<2>()); // match the 2nd version of foo
   foo(B1());    // match the 1st version of foo
   foo(BN());    // match the 1st version of foo
 }

我不知道您使用的boost类,但我想您可以修改您的代码(使其几乎与我的无boost解决方案一样工作),如下所示

template <typename, typename = bool_<true> >
struct Condition : public bool_<false>
 { };

template <typename T>
struct Condition<T, bool_<(1 == T::code) || (2 == T::code)> >
   : public bool_<true>
 { };

--编辑--

行动询问

我不明白它如何适用于案例A1<0>。条件的专门化应该是首选匹配,第二个参数扩展到bool。该类继承自bool,因此,它应该选择错误的foo版本。不管它是怎么工作的。怎么可能?

好。。。当你写作的时候 foo(A1<0>()) ,编译器必须了解 cond<A1<0>>::value true 或 false 启用的第一个版本 foo() 或者第二个。

cond<A1<0>> . 但是没有一个 cond 只接收类型名的模板类。不管怎样,编译器发现

template <typename, typename = bool_wrapper<true> >
struct cond;

使用第二个模板参数的默认值进行匹配。

cond< A<1> > cond< A<1>, bool_wrapper<true> >

现在编译器必须在 cond<typename, typename> (继承自 bool_wrapper<false> bool_wrapper<true> ).

当然匹配主版本,但也匹配专门化?如果匹配也匹配专门化,编译器必须首选专门化。

cond< A<0>, bool_wrapper<true> > 与专业化相匹配。

使用 A<0> T

cond< A<0>, bool_wrapper<(1 == A<0>::code) || (2 == A<0>::code)> >

就是这样

cond< A<0>, bool_wrapper<(1 == 0) || (2 == 0)> >

cond< A<0>, bool_wrapper<false || false> >

就是这样

cond< A<0>, bool_wrapper<false> >

这不匹配 .

所以呢 cond< A<0> > ,即 ,仅与的主版本匹配 条件(&L);typename,typename> bool\u包装器<错误> .

至于 条件(&L);<0>&燃气轮机; 条件 条件(&L);<1>&燃气轮机; 是与第二个 typename 使用默认值。

所以呢是

但是 条件(&L);<1>,bool\u包装器<正确>&燃气轮机; 条件(&L);typename,typename> 还是专业化?

我们可以看到 A<1> 作为 ,专业化成为

cond< A<1>, bool_wrapper<(1 == A<1>::code) || (2 == A<1>::code)> >

就是这样

cond< A<1>, bool_wrapper<(1 == 1) || (2 == 1)> >

就是这样

cond< A<1>, bool_wrapper<true || false> >

就是这样

cond< A<1>, bool_wrapper<true> >

条件(&L);<1>,bool\u包装器<正确>&燃气轮机; .

条件(&L);<1>&燃气轮机; cond< A<1>, bool_wrapper<true> ,两个版本的 条件(&L);typename,typename> 匹配,所以编译器必须选择专门化,所以 条件(&L);<1>&燃气轮机; 继承自 bool\u包装器<正确> .

Fabio 6 年前

基于J。温克的建议,我成功了。

把这两个条件放在一起 and_ code enable_if

#include <boost/tti/has_static_member_data.hpp>

BOOST_TTI_HAS_STATIC_MEMBER_DATA(code)

template <typename T, typename Enable = void>
struct Condition : false_type {};;

template <typename T>
struct Condition<T, typename enable_if<bool_<has_static_member_data_code<T,const int>::value> >::type>
{
    typedef or_<bool_<T::code == 1>, bool_<T::code == 2> > type;
    const static bool value = type::value;
};