我想编写一个聚合对象的包装类(非常多的代理),并将成员函数调用转发给它.这在C 11/14中使用可变参数模板和decltype是微不足道的.我的问题是包含的对象可能支持也可能不支持的成员函数.
我提出了一个似乎有效的解决方案,然而,它看起来非常笨拙,我正在寻求简化.特别是我担心这在编译时可能会非常昂贵(有很多函数要包装).这种笨拙来自需要指定函数的返回类型而不留下decltype要阻塞的东西.
有人会有更好的主意吗?
以下代码也可用live.
#include <iostream>
#include <utility>
/// Compute the result type of a member function call, or void if invalid.
#define RESULT_OF(Name) \
template <typename T> \
class result_impl_ ## Name \
{ \
public: \
/* Type made public to please Clang 3.7. */ \
template <typename C, typename... Args> \
static auto Type(void*) \
-> decltype(std::declval<C>().Name(std::declval<Args>()...)); \
\
template <typename, typename...> \
static void Type(...); \
\
template <typename... Args> \
using type = decltype(Type<T, Args...>(0)); \
}; \
\
template <typename T, typename... Args> \
using maybe_result_of_ ## Name \
= typename result_impl_ ## Name<T>::template type<Args...>
/// Forward to function Name, if is exists.
#define FORWARD(Name) \
template <typename... Args> \
auto Name(Args&&... args) \
-> maybe_result_of_ ## Name<Base, Args...> \
{ \
return base.Name(std::forward<Args>(args)...); \
}
#define DEFINE(Name) \
RESULT_OF(Name); \
FORWARD(Name)
template <typename Base>
struct wrapper
{
Base base;
DEFINE(foo);
DEFINE(bar);
};
#define PING() \
std::cerr << __PRETTY_FUNCTION__ << '\n'
struct foo_no_bar
{
void foo(int) const { PING(); }
int foo(double) const { PING(); return 1; }
int foo(double, double) const { PING(); return 1; }
};
struct foo_and_bar
{
void foo() const { PING(); }
void bar() { PING(); }
};
int main()
{
wrapper<foo_and_bar> f;
f.foo();
f.bar();
wrapper<foo_no_bar> b;
b.foo(1);
b.foo(1.0);
b.foo(1.0, 2.0);
}
最佳答案 所以我把你在宏中做的一堆工作拿出来拿出来.
can_apply_t采用模板< class …>类和一组类型,如果类型可以合法地应用于模板,则为true.
template<class...>struct voider { using type=void; };
template<class...Ts>using void_t=typename voider<Ts...>::type;
template<class...>struct types{ using type=types; };
namespace details {
template<template<class...>class Z, class types, class=void>
struct can_apply : std::false_type {};
template<template<class...>class Z, class...Ts>
struct can_apply<Z, types<Ts...>, void_t< Z<Ts...> > >:
std::true_type
{};
}
template<template<class...>class Z, class...Ts>
using can_apply_t = details::can_apply<Z, types<Ts...>>;
然后我们将为您的宏进行替换.我从方法名称中解耦方法名称,并在几个步骤中完成.对于每种方法,可以在类外部完成这些步骤:
#define CALL_METHOD_RESULT(Name, Method) \
template<class Sig, class=void> \
struct Name {}; \
template<class C, class...Ts> \
struct Name< C(Ts...), void_t< \
decltype( std::declval<C>().Method(std::declval<Ts>()...) ) \
>> { \
using type = decltype( std::declval<C>().Method(std::declval<Ts>()...) ); \
}; \
template<class Sig> \
using Name ## _t = typename Name< Sig >::type
上面定义了Name_t,它是一个traits类,它接受一个Object(Args …),并在SFINAE友好的上下文中告诉你Object.Method(Args …)的返回类型.
接下来,我们使用this和上面的can_apply_t构建一个can_call_Method帮助器模板:
#define CAN_CALL_METHOD( Method ) \
CALL_METHOD_RESULT( call_ ## Method, Method ); \
template<class Sig> \
using can_call_ ## Method = can_apply_t< call_ ## Method ## _t, Sig >
接下来,FORWARD宏为Name生成一对重载,其中一个调用target.Method(Args …),其中Target目标,另一个只考虑第一个不是并且显式=删除调用生成一个可能更好的错误消息.
/// Forward to function Name, if is exists.
#define FORWARD(Name, Method, Target, target) \
template <class... Args> \
auto Name(Args&&... args) \
-> call_ ## Method ## _t<Target(Args...)> \
{ \
return target.Method(std::forward<Args>(args)...); \
} \
template <class...Args> \
std::enable_if_t<!can_call_ ## Method <Target(Args...)>{}> \
Name ( Args&&...) = delete
现在我们在类似的DEFINE宏中包含上面的内容.在这里,我们将所有内容重新回到一个名称:
#define DEFINE(Name) \
CAN_CALL_METHOD(Name); \
FORWARD(Name, Name, Base, base)
如果你愿意,我们也可以让= delete方法做别的事情,比如什么都没做.
但是请注意,如果我们省略整个= delete方法,我们实际上可以在两个子对象之间进行受控调度(即使是优先级!)
当然,更容易实现所有这些
Base* operator->(){ return &base; }
Base const* operator->()const{ return &base; }
它允许您访问Base作为包装器 – > foo(无论如何).它确实暴露了有关Base的一切.