我要求使用模板技巧来检测类是否具有给定签名的特定成员函数。
这个问题与这里引用的问题类似网址：http://www.gotw.ca/gotw/071.htm但并非如此：在萨特的书中，他回答了一个问题，即C类必须提供一个具有特定签名的成员函数，否则程序将无法编译。在我的问题中，如果一个类有这个函数，我需要做一些事情，否则就做"其他事情"。
Boost:：Serialization也遇到了类似的问题，但我不喜欢他们采用的解决方案：一个模板函数，它默认调用一个带有特定签名的自由函数(必须定义)，除非您定义了一个带有特定签名的特定成员函数(在这种情况下，"Serialization"接受两个给定类型的参数)。否则会发生编译错误。即实现侵入式和非侵入式序列化。
我不喜欢这个解决方案有两个原因：
为了不受干扰，您必须重写boost:：serialization命名空间中的全局"serialization"函数，以便在客户端代码中打开命名空间boost和命名空间序列化！
解决这个问题的堆栈mess是10到12个函数调用。
我需要为没有该成员函数的类定义自定义行为，并且我的实体在不同的命名空间中(我不想在另一个命名空间中重写在一个命名空间中定义的全局函数)
你能给我一个提示来解决这个难题吗？
型
这是一个依赖C++ 11特性的可能实现。它可以正确地检测函数，即使它是继承的(不像迈克·金汉在他的答案中观察到的，接受的答案中的解决方案)。
此代码段测试的函数称为serialize：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
| #include <type_traits>
// Primary template with a static assertion
// for a meaningful error message
// if it ever gets instantiated.
// We could leave it undefined if we didn't care.
template<typename, typename T>
struct has_serialize {
static_assert(
std::integral_constant<T, false>::value,
"Second template parameter needs to be of function type.");
};
// specialization that does the checking
template<typename C, typename Ret, typename... Args>
struct has_serialize<C, Ret(Args...)> {
private:
template<typename T>
static constexpr auto check(T*)
-> typename
std::is_same<
decltype( std::declval<T>().serialize( std::declval<Args>()... ) ),
Ret // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>::type; // attempt to call it and see if the return type is correct
template<typename>
static constexpr std::false_type check(...);
typedef decltype(check<C>(0)) type;
public:
static constexpr bool value = type::value;
}; |
。
用法：
1
2
3
4
5
6
7
| struct X {
int serialize(const std::string&) { return 42; }
};
struct Y : X {};
std::cout << has_serialize<Y, int(const std::string&)>::value; // will print 1 |
型
我不确定我是否正确理解您，但是您可以利用sfinae在编译时检测函数是否存在。代码中的示例(测试类是否具有成员函数大小u t used u memory()const)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| template<typename T>
struct HasUsedMemoryMethod
{
template<typename U, size_t (U::*)() const> struct SFINAE {};
template<typename U> static char Test(SFINAE<U, &U::used_memory>*);
template<typename U> static int Test(...);
static const bool Has = sizeof(Test<T>(0)) == sizeof(char);
};
template<typename TMap>
void ReportMemUsage(const TMap& m, std::true_type)
{
// We may call used_memory() on m here.
}
template<typename TMap>
void ReportMemUsage(const TMap&, std::false_type)
{
}
template<typename TMap>
void ReportMemUsage(const TMap& m)
{
ReportMemUsage(m,
std::integral_constant<bool, HasUsedMemoryMethod<TMap>::Has>());
} |
对compileTime成员函数这个问题的公认答案反省虽然很受欢迎，但有一个可以观察到的障碍在以下程序中：好的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| #include <type_traits>
#include <iostream>
#include <memory>
/* Here we apply the accepted answer's technique to probe for the
the existence of `E T::operator*() const`
*/
template<typename T, typename E>
struct has_const_reference_op
{
template<typename U, E (U::*)() const> struct SFINAE {};
template<typename U> static char Test(SFINAE<U, &U::operator*>*);
template<typename U> static int Test(...);
static const bool value = sizeof(Test<T>(0)) == sizeof(char);
};
using namespace std;
/* Here we test the `std::` smart pointer templates, including the
deprecated `auto_ptr<T>`, to determine in each case whether
T = (the template instantiated for `int`) provides
`int & T::operator*() const` - which all of them in fact do.
*/
int main(void)
{
cout << has_const_reference_op,int &>::value;
cout << has_const_reference_op<unique_ptr<int>,int &>::value;
cout << has_const_reference_op<shared_ptr<int>,int &>::value << endl;
return 0;
} |
用GCC4.6.3构建，程序输出110——通知我们T = std::shared_ptr不提供int & T::operator*() const。好的。
如果你还不明白这一点，那就看看收割台中的std::shared_ptr将发光。在那实现，std::shared_ptr是从基类派生的它继承了以东十一〔六〕年。所以模板实例化SFINAE构成"查找"运算符的U = std::shared_ptr不会发生，因为std::shared_ptr没有operator*()本身的权利和模板实例化没有"继承"。好的。
这个障碍不影响著名的sfinae方法，使用"sizeof()技巧"，仅用于检测T是否具有某些成员功能mf(参见这个答案和评论)。但是确定T::mf的存在往往是(通常是？)不够好：你可以还需要确定它具有所需的签名。这就是图示技术得分。所需签名的指针化变量在必须满足的模板类型的参数中&T::mf为斯芬纳探测器成功。但是这个模板正在实例化当T::mf被继承时，技术给出了错误的答案。好的。
一种用于T::mf编译时自省的安全sfinae技术必须避免在模板参数中使用&T::mf来实例化一个类型，在该类型上函数模板分辨率取决于。相反，sfinae模板函数解析只能依赖于使用的完全相关的类型声明作为重载sfinae探测函数的参数类型。好的。
为了回答这个约束条件下的问题，我将说明E T::operator*() const的编译检测，用于任意T和E。同样的模式将在必要的修改后适用。探测任何其他成员方法签名。好的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
| #include <type_traits>
/*! The template `has_const_reference_op<T,E>` exports a
boolean constant `value that is true iff `T` provides
`E T::operator*() const`
*/
template< typename T, typename E>
struct has_const_reference_op
{
/* SFINAE operator-has-correct-sig :) */
template<typename A>
static std::true_type test(E (A::*)() const) {
return std::true_type();
}
/* SFINAE operator-exists :) */
template <typename A>
static decltype(test(&A::operator*))
test(decltype(&A::operator*),void *) {
/* Operator exists. What about sig? */
typedef decltype(test(&A::operator*)) return_type;
return return_type();
}
/* SFINAE game over :( */
template<typename A>
static std::false_type test(...) {
return std::false_type();
}
/* This will be either `std::true_type` or `std::false_type` */
typedef decltype(test<T>(0,0)) type;
static const bool value = type::value; /* Which is it? */
}; |
在这个解决方案中，重载的sfinae探测函数test()被"调用"递归地(当然，它根本没有被调用；它只是编译器解决的假设调用的返回类型。)好的。
我们需要调查至少一个和最多两个信息点：好的。
- T::operator*()是否存在？如果没有，我们就完了。
- 鉴于T::operator*()存在，其签名是EDOCX1？18？
我们通过评估单个呼叫的返回类型得到答案。至test(0,0)。这是通过：好的。
1
| typedef decltype(test<T>(0,0)) type; |
此调用可能会解决/* SFINAE operator-exists :) */过载问题。或者可以解决/* SFINAE game over :( */的过载问题。它不能解决/* SFINAE operator-has-correct-sig :) */过载问题，因为这只需要一个论点，而我们要传递两个。好的。
我们为什么要过两个？只是为了迫使决议排除/* SFINAE operator-has-correct-sig :) */。第二个论点没有其他意义。好的。
对test(0,0)的调用将解决/* SFINAE operator-exists :) */的问题。如果第一个参数0满足该重载的第一个参数类型，它是decltype(&A::operator*)，和A = T。0将满足该类型以防万一。好的。
让我们假设编译器对此表示同意。那它就跟/* SFINAE operator-exists :) */需要确定返回类型函数调用，在这种情况下是decltype(test(&A::operator*))。-对test()的另一个调用的返回类型。好的。
这次，我们只传递一个论点，&A::operator*，我们现在知道存在，否则我们就不会在这里。打电话给test(&A::operator*)可能向/* SFINAE operator-has-correct-sig :) */或再次决议可能会解决/* SFINAE game over :( */。电话会匹配的以防万一以防万一该过载的单参数类型，即E (A::*)() const，与A = T一起。好的。
如果T::operator*具有所需的签名，编译器将在这里说是，然后再次评估重载的返回类型。不再"递归"现在：它是std::true_type。好的。
如果编译器没有为调用test(0,0)或不选择/* SFINAE operator-has-correct-sig :) */。对于调用test(&A::operator*)，则在任何情况下，它都与/* SFINAE game over :( */，最终返回类型为std::false_type。好的。
下面是一个测试程序，显示生成预期不同案例样本的答案(GCC第4.6.3条)。好的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
| // To test
struct empty{};
// To test
struct int_ref
{
int & operator*() const {
return *_pint;
}
int & foo() const {
return *_pint;
}
int * _pint;
};
// To test
struct sub_int_ref : int_ref{};
// To test
template<typename E>
struct ee_ref
{
E & operator*() {
return *_pe;
}
E & foo() const {
return *_pe;
}
E * _pe;
};
// To test
struct sub_ee_ref : ee_ref<char>{};
using namespace std;
#include <iostream>
#include <memory>
#include <vector>
int main(void)
{
cout <<"Expect Yes" << endl;
cout << has_const_reference_op,int &>::value;
cout << has_const_reference_op<unique_ptr<int>,int &>::value;
cout << has_const_reference_op<shared_ptr<int>,int &>::value;
cout << has_const_reference_op<std::vector<int>::iterator,int &>::value;
cout << has_const_reference_op<std::vector<int>::const_iterator,
int const &>::value;
cout << has_const_reference_op<int_ref,int &>::value;
cout << has_const_reference_op<sub_int_ref,int &>::value << endl;
cout <<"Expect No" << endl;
cout << has_const_reference_op<int *,int &>::value;
cout << has_const_reference_op<unique_ptr<int>,char &>::value;
cout << has_const_reference_op<unique_ptr<int>,int const &>::value;
cout << has_const_reference_op<unique_ptr<int>,int>::value;
cout << has_const_reference_op<unique_ptr<long>,int &>::value;
cout << has_const_reference_op<int,int>::value;
cout << has_const_reference_op<std::vector<int>,int &>::value;
cout << has_const_reference_op<ee_ref<int>,int &>::value;
cout << has_const_reference_op<sub_ee_ref,int &>::value;
cout << has_const_reference_op::value << endl;
return 0;
} |
这个想法有新的缺陷吗？它能再普通一次吗与它避免的障碍物相撞？好的。好啊。
以下是一些用法片段：*所有这些的胆量都在进一步下降。
检查给定类中的成员x。可以是var、func、class、union或enum:
1
2
| CREATE_MEMBER_CHECK(x);
bool has_x = has_member_x<class_to_check_for_x>::value; |
检查成员函数void x()：
1
2
3
| //Func signature MUST have T as template variable here... simpler this way :\
CREATE_MEMBER_FUNC_SIG_CHECK(x, void (T::*)(), void__x);
bool has_func_sig_void__x = has_member_func_void__x<class_to_check_for_x>::value; |
检查成员变量x：
1
2
| CREATE_MEMBER_VAR_CHECK(x);
bool has_var_x = has_member_var_x<class_to_check_for_x>::value; |
检查成员类x：
1
2
| CREATE_MEMBER_CLASS_CHECK(x);
bool has_class_x = has_member_class_x<class_to_check_for_x>::value; |
检查是否有会员工会x：
1
2
| CREATE_MEMBER_UNION_CHECK(x);
bool has_union_x = has_member_union_x<class_to_check_for_x>::value; |
检查成员枚举x：
1
2
| CREATE_MEMBER_ENUM_CHECK(x);
bool has_enum_x = has_member_enum_x<class_to_check_for_x>::value; |
检查是否有任何成员函数x，不考虑签名：
1
2
3
4
5
6
7
| CREATE_MEMBER_CHECK(x);
CREATE_MEMBER_VAR_CHECK(x);
CREATE_MEMBER_CLASS_CHECK(x);
CREATE_MEMBER_UNION_CHECK(x);
CREATE_MEMBER_ENUM_CHECK(x);
CREATE_MEMBER_FUNC_CHECK(x);
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value; |
或
1
2
| CREATE_MEMBER_CHECKS(x); //Just stamps out the same macro calls as above.
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value; |
细节和核心：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| /*
- Multiple inheritance forces ambiguity of member names.
- SFINAE is used to make aliases to member names.
- Expression SFINAE is used in just one generic has_member that can accept
any alias we pass it.
*/
//Variadic to force ambiguity of class members. C++11 and up.
template <typename... Args> struct ambiguate : public Args... {};
//Non-variadic version of the line above.
//template <typename A, typename B> struct ambiguate : public A, public B {};
template<typename A, typename = void>
struct got_type : std::false_type {};
template<typename A>
struct got_type<A> : std::true_type {
typedef A type;
};
template<typename T, T>
struct sig_check : std::true_type {};
template<typename Alias, typename AmbiguitySeed>
struct has_member {
template<typename C> static char ((&f(decltype(&C::value))))[1];
template<typename C> static char ((&f(...)))[2];
//Make sure the member name is consistently spelled the same.
static_assert(
(sizeof(f<AmbiguitySeed>(0)) == 1)
,"Member name specified in AmbiguitySeed is different from member name specified in Alias, or wrong Alias/AmbiguitySeed has been specified."
);
static bool const value = sizeof(f<Alias>(0)) == 2;
}; |
宏(el diablo！)：
创建成员检查：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| //Check for any member with given name, whether var, func, class, union, enum.
#define CREATE_MEMBER_CHECK(member) \
\
template<typename T, typename = std::true_type> \
struct Alias_##member; \
\
template<typename T> \
struct Alias_##member < \
T, std::integral_constant<bool, got_type<decltype(&T::member)>::value> \
> { static const decltype(&T::member) value; }; \
\
struct AmbiguitySeed_##member { char member; }; \
\
template<typename T> \
struct has_member_##member { \
static const bool value \
= has_member< \
Alias_##member> \
, Alias_##member<AmbiguitySeed_##member> \
>::value \
; \
} |
创建成员变量检查：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| //Check for member variable with given name.
#define CREATE_MEMBER_VAR_CHECK(var_name) \
\
template<typename T, typename = std::true_type> \
struct has_member_var_##var_name : std::false_type {}; \
\
template<typename T> \
struct has_member_var_##var_name< \
T \
, std::integral_constant< \
bool \
, !std::is_member_function_pointer<decltype(&T::var_name)>::value \
> \
> : std::true_type {} |
创建成员检查：
1
2
3
4
5
6
7
8
9
10
11
12
13
| //Check for member function with given name AND signature.
#define CREATE_MEMBER_FUNC_SIG_CHECK(func_name, func_sig, templ_postfix) \
\
template<typename T, typename = std::true_type> \
struct has_member_func_##templ_postfix : std::false_type {}; \
\
template<typename T> \
struct has_member_func_##templ_postfix< \
T, std::integral_constant< \
bool \
, sig_check<func_sig, &T::func_name>::value \
> \
> : std::true_type {} |
创建u成员u类u检查：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| //Check for member class with given name.
#define CREATE_MEMBER_CLASS_CHECK(class_name) \
\
template<typename T, typename = std::true_type> \
struct has_member_class_##class_name : std::false_type {}; \
\
template<typename T> \
struct has_member_class_##class_name< \
T \
, std::integral_constant< \
bool \
, std::is_class< \
typename got_type<typename T::class_name>::type \
>::value \
> \
> : std::true_type {} |
创建成员联合检查：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| //Check for member union with given name.
#define CREATE_MEMBER_UNION_CHECK(union_name) \
\
template<typename T, typename = std::true_type> \
struct has_member_union_##union_name : std::false_type {}; \
\
template<typename T> \
struct has_member_union_##union_name< \
T \
, std::integral_constant< \
bool \
, std::is_union< \
typename got_type<typename T::union_name>::type \
>::value \
> \
> : std::true_type {} |
创建成员枚举检查：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| //Check for member enum with given name.
#define CREATE_MEMBER_ENUM_CHECK(enum_name) \
\
template<typename T, typename = std::true_type> \
struct has_member_enum_##enum_name : std::false_type {}; \
\
template<typename T> \
struct has_member_enum_##enum_name< \
T \
, std::integral_constant< \
bool \
, std::is_enum< \
typename got_type<typename T::enum_name>::type \
>::value \
> \
> : std::true_type {} |
创建成员检查：
1
2
3
4
5
6
7
8
9
10
11
12
| //Check for function with given name, any signature.
#define CREATE_MEMBER_FUNC_CHECK(func) \
template<typename T> \
struct has_member_func_##func { \
static const bool value \
= has_member_##func<T>::value \
&& !has_member_var_##func<T>::value \
&& !has_member_class_##func<T>::value \
&& !has_member_union_##func<T>::value \
&& !has_member_enum_##func<T>::value \
; \
} |
创建成员检查：
1
2
3
4
5
6
7
8
| //Create all the checks for one member. Does NOT include func sig checks.
#define CREATE_MEMBER_CHECKS(member) \
CREATE_MEMBER_CHECK(member); \
CREATE_MEMBER_VAR_CHECK(member); \
CREATE_MEMBER_CLASS_CHECK(member); \
CREATE_MEMBER_UNION_CHECK(member); \
CREATE_MEMBER_ENUM_CHECK(member); \
CREATE_MEMBER_FUNC_CHECK(member) |
型
如果您知道所期望的成员函数的名称，这就足够了。(在这种情况下，如果没有成员函数，那么函数bla将无法实例化(编写一个无论如何都有效的函数是很困难的，因为缺少函数部分专门化)。您可能还需要使用类模板)另外，启用结构(类似于启用_if)也可以在您希望它作为成员的函数类型上进行模板化。
1
2
3
4
5
6
7
8
9
10
11
| template <typename T, int (T::*) ()> struct enable { typedef T type; };
template <typename T> typename enable<T, &T::i>::type bla (T&);
struct A { void i(); };
struct B { int i(); };
int main()
{
A a;
B b;
bla(b);
bla(a);
} |
号
下面是对迈克·金汉的回答的简单理解。这将检测继承的方法。它还将检查准确的签名(不像jrok允许参数转换的方法)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| template <class C>
class HasGreetMethod
{
template <class T>
static std::true_type testSignature(void (T::*)(const char*) const);
template <class T>
static decltype(testSignature(&T::greet)) test(std::nullptr_t);
template <class T>
static std::false_type test(...);
public:
using type = decltype(test<C>(nullptr));
static const bool value = type::value;
};
struct A { void greet(const char* name) const; };
struct Derived : A { };
static_assert(HasGreetMethod<Derived>::value,""); |
可运行示例
要实现这一点，我们需要使用：
根据方法是否可用，使用不同返回类型的函数模板重载
为了与type_traits头中的元条件保持一致，我们希望从重载返回true_type或false_type。
声明true_type重载，期望int和false_type重载，期望使用可变参数："重载分辨率中省略号转换的最低优先级"
在定义true_type函数的模板规范时，我们将使用declval和decltype来检测函数，而不依赖于方法之间的返回类型差异或重载。
你可以在这里看到一个活生生的例子。但我也会在下面解释：
我想检查是否存在一个名为test的函数，它采用可从int转换的类型，然后我需要声明这两个函数：
1
2
| template <typename T, typename S = decltype(declval<T>().test(declval<int>))> static true_type hasTest(int);
template <typename T> static false_type hasTest(...); |
- decltype(hasTest(0))::value为true(注：不需要创建特殊功能来处理void a::test()过载，接受void a::test(int))
- decltype(hasTest(0))::value为true(因为int可转换为doubleint b::test(double)可接受，与返回类型无关)
- decltype(hasTest(0))::value是false(c没有名为test的方法接受可从int转换的类型，因此不接受)
此解决方案有两个缺点：
需要一对函数的每方法声明
创建名称空间污染，特别是如果我们要测试相似的名称，例如，我们将如何命名一个要测试test()方法的函数？
因此，这些函数必须在一个详细的名称空间中声明，或者理想情况下，如果它们只与一个类一起使用，那么它们应该由该类私下声明。为此，我编写了一个宏来帮助您抽象这些信息：
1
2
3
| #define FOO(FUNCTION, DEFINE) template <typename T, typename S = decltype(declval<T>().FUNCTION)> static true_type __ ## DEFINE(int); \
template <typename T> static false_type __ ## DEFINE(...); \
template <typename T> using DEFINE = decltype(__ ## DEFINE<T>(0)); |
您可以这样使用：
1
2
3
4
| namespace details {
FOO(test(declval<int>()), test_int)
FOO(test(), test_void)
} |
随后调用details::test_int::value或details::test_void::value将产生用于内联代码或元编程的true或false。
型
我自己也有同样的问题，发现这里提出的解决方案很有趣…但需要一个解决方案：
百万千克1检测继承的函数；百万千克1百万千克1与非C++ 11就绪编译器兼容(所以没有解密)百万千克1
基于一个提振讨论，找到了另一个类似这样的建议。下面是根据boost:：has_ux类的模型，将建议的解决方案概括为两个traits类的宏声明。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
| #include <boost/type_traits/is_class.hpp>
#include <boost/mpl/vector.hpp>
/// Has constant function
/** \param func_ret_type Function return type
\param func_name Function name
\param ... Variadic arguments are for the function parameters
*/
#define DECLARE_TRAITS_HAS_FUNC_C(func_ret_type, func_name, ...) \
__DECLARE_TRAITS_HAS_FUNC(1, func_ret_type, func_name, ##__VA_ARGS__)
/// Has non-const function
/** \param func_ret_type Function return type
\param func_name Function name
\param ... Variadic arguments are for the function parameters
*/
#define DECLARE_TRAITS_HAS_FUNC(func_ret_type, func_name, ...) \
__DECLARE_TRAITS_HAS_FUNC(0, func_ret_type, func_name, ##__VA_ARGS__)
// Traits content
#define __DECLARE_TRAITS_HAS_FUNC(func_const, func_ret_type, func_name, ...) \
template \
< typename Type, \
bool is_class = boost::is_class<Type>::value \
> \
class has_func_ ## func_name; \
template<typename Type> \
class has_func_ ## func_name<Type,false> \
{public: \
BOOST_STATIC_CONSTANT( bool, value = false ); \
typedef boost::false_type type; \
}; \
template<typename Type> \
class has_func_ ## func_name<Type,true> \
{ struct yes { char _foo; }; \
struct no { yes _foo[2]; }; \
struct Fallback \
{ func_ret_type func_name( __VA_ARGS__ ) \
UTILITY_OPTIONAL(func_const,const) {} \
}; \
struct Derived : public Type, public Fallback {}; \
template <typename T, T t> class Helper{}; \
template <typename U> \
static no deduce(U*, Helper \
< func_ret_type (Fallback::*)( __VA_ARGS__ ) \
UTILITY_OPTIONAL(func_const,const), \
&U::func_name \
>* = 0 \
); \
static yes deduce(...); \
public: \
BOOST_STATIC_CONSTANT( \
bool, \
value = sizeof(yes) \
== sizeof( deduce( static_cast<Derived*>(0) ) ) \
); \
typedef ::boost::integral_constant<bool,value> type; \
BOOST_STATIC_CONSTANT(bool, is_const = func_const); \
typedef func_ret_type return_type; \
typedef ::boost::mpl::vector< __VA_ARGS__ > args_type; \
}
// Utility functions
#define UTILITY_OPTIONAL(condition, ...) UTILITY_INDIRECT_CALL( __UTILITY_OPTIONAL_ ## condition , ##__VA_ARGS__ )
#define UTILITY_INDIRECT_CALL(macro, ...) macro ( __VA_ARGS__ )
#define __UTILITY_OPTIONAL_0(...)
#define __UTILITY_OPTIONAL_1(...) __VA_ARGS__ |
。
这些宏扩展到具有以下原型的traits类：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| template<class T>
class has_func_[func_name]
{
public:
/// Function definition result value
/** Tells if the tested function is defined for type T or not.
*/
static const bool value = true | false;
/// Function definition result type
/** Type representing the value attribute usable in
http://www.boost.org/doc/libs/1_53_0/libs/utility/enable_if.html
*/
typedef boost::integral_constant<bool,value> type;
/// Tested function constness indicator
/** Indicates if the tested function is const or not.
This value is not deduced, it is forced depending
on the user call to one of the traits generators.
*/
static const bool is_const = true | false;
/// Tested function return type
/** Indicates the return type of the tested function.
This value is not deduced, it is forced depending
on the user's arguments to the traits generators.
*/
typedef func_ret_type return_type;
/// Tested function arguments types
/** Indicates the arguments types of the tested function.
This value is not deduced, it is forced depending
on the user's arguments to the traits generators.
*/
typedef ::boost::mpl::vector< __VA_ARGS__ > args_type;
}; |
那么，我们能用它做什么呢？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| // We enclose the traits class into
// a namespace to avoid collisions
namespace ns_0 {
// Next line will declare the traits class
// to detect the member function void foo(int,int) const
DECLARE_TRAITS_HAS_FUNC_C(void, foo, int, int);
}
// we can use BOOST to help in using the traits
#include <boost/utility/enable_if.hpp>
// Here is a function that is active for types
// declaring the good member function
template<typename T> inline
typename boost::enable_if< ns_0::has_func_foo<T> >::type
foo_bar(const T &_this_, int a=0, int b=1)
{ _this_.foo(a,b);
}
// Here is a function that is active for types
// NOT declaring the good member function
template<typename T> inline
typename boost::disable_if< ns_0::has_func_foo<T> >::type
foo_bar(const T &_this_, int a=0, int b=1)
{ default_foo(_this_,a,b);
}
// Let us declare test types
struct empty
{
};
struct direct_foo
{
void foo(int,int);
};
struct direct_const_foo
{
void foo(int,int) const;
};
struct inherited_const_foo :
public direct_const_foo
{
};
// Now anywhere in your code you can seamlessly use
// the foo_bar function on any object:
void test()
{
int a;
foo_bar(a); // calls default_foo
empty b;
foo_bar(b); // calls default_foo
direct_foo c;
foo_bar(c); // calls default_foo (member function is not const)
direct_const_foo d;
foo_bar(d); // calls d.foo (member function is const)
inherited_const_foo e;
foo_bar(e); // calls e.foo (inherited member function)
} |
。
型
您可以使用std:：is_member_function_pointer
1
2
3
4
5
6
| class A {
public:
void foo() {};
}
bool test = std::is_member_function_pointer<decltype(&A::foo)>::value; |
型
为了不受干扰，还可以通过Koenig查找将serialize放在要序列化的类或存档类的命名空间中。有关更多详细信息，请参阅命名空间以获取自由函数重写。：-)
打开任何给定的名称空间来实现自由函数都是错误的。(例如，您不应该为自己的类型打开命名空间std来实现swap，而是应该使用koenig查找。)
型
可以。第二次尝试。如果你也不喜欢这个，没关系，我在找更多的主意。
Herb Sutter的文章谈到了特性。因此，您可以有一个traits类，它的默认实例化具有回退行为，对于存在成员函数的每个类，traits类都专门用于调用成员函数。我相信Herb的文章提到了这样做的一种技巧，这样就不需要大量的复制和粘贴。
不过，正如我所说的，也许您不希望在实现该成员的"标记"类中进行额外的工作。在这种情况下，我正在寻找第三种解决方案……
没有C + +的支持(11 decltypethis might work)：P＞＜／sscce
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| #include <iostream>
using namespace std;
struct A { void foo(void); };
struct Aa: public A { };
struct B { };
struct retA { int foo(void); };
struct argA { void foo(double); };
struct constA { void foo(void) const; };
struct varA { int foo; };
template<typename T>
struct FooFinder {
typedef char true_type[1];
typedef char false_type[2];
template<int>
struct TypeSink;
template<class U>
static true_type &match(U);
template<class U>
static true_type &test(TypeSink<sizeof( matchType<void (U::*)(void)>( &U::foo ) )> *);
template<class U>
static false_type &test(...);
enum { value = (sizeof(test<T>(0, 0)) == sizeof(true_type)) };
};
int main() {
cout << FooFinder<A>::value << endl;
cout << FooFinder<Aa>::value << endl;
cout << FooFinder::value << endl;
cout << FooFinder<retA>::value << endl;
cout << FooFinder::value << endl;
cout << FooFinder<constA>::value << endl;
cout << FooFinder<varA>::value << endl;
} |
恩hopefully工程知识
AAa和Bclases，问题是在那一个特殊的人，Aathe looking for the inherits我们的成员。P＞＜／
茶和茶FooFindertrue_typefalse_typeare the替换for the C++类意味着11。也理解模板元编程for the of the Very他们揭示的基础上，sfinae of the - sizeof戏法。P＞＜／
TypeSinkis the that is used to struct模板库后sizeofthe result of the积分算子模板实例化to form into a A型。P＞＜／
一sfinae matchfunction is the kind of that is left without a模板counterpart GENERIC。因此，它可以被实例化，if only be the type of its type argument for the matches恩是专业。P＞＜／
testboth the the枚举函数在一起最后宣言，中央sfinae形态模式。在一个使用Generic there is that the false_type安ellipsis归来》和counterpart Arguments to take with more特异值优先。P＞＜／
to be to the test阿贝尔函数模板实例化与Targument of the function，matchmust be as its实例化，实例化类来返回TypeSinkargument is the。但是&U::foois that the function argument的幸福中，骨膜，is not to argument from within a，所有成员的专业模板，我需要知道inherited lookup广场。P＞＜／
如果你使用Facebook，他们放开，are out of the box宏帮助你：P＞＜／
1
2
3
4
5
6
7
8
9
| #include <folly/Traits.h>
namespace {
FOLLY_CREATE_HAS_MEMBER_FN_TRAITS(has_test_traits, test);
} // unnamed-namespace
void some_func() {
cout <<"Does class Foo have a member int test() const?"
<< boolalpha << has_test_traits<Foo, int() const>::value;
} |
虽然is the same the implementation details with the previous答案是简单的内部，使用图书馆。P＞＜／
型
我相信你要找的答案就在这里。
http://www.martinecker.com/wiki/index.php？title=在编译时检测u运算符的存在
这里有一个稍微充实一点的例子
http://pastie.org/298994
我使用这项技术来检测相关类上支持的Ostream运算符的存在，然后根据不同的代码位生成不同的代码。
我不相信在找到关联的解决方案之前是可能的，但这是一个非常巧妙的技巧。花时间理解代码，这是非常值得的。
布拉德
