如何为模板化的operator()编写最好的is_callable特征
我有这样定义的 is_callable 特征：
#ifndef IS_CALLABLE_HPP
#define IS_CALLABLE_HPP
#include <type_traits>
namespace is_callable_detail
{
struct no {};
struct yes { no x[2]; };
template<bool CallableArgs, typename Callable, typename ReturnType, typename ...Args>
struct check_return
{
static const bool value = std::is_convertible<decltype(std::declval<Callable>()(std::declval<Args>()...)), ReturnType>::value;
};
template<typename Callable, typename ReturnType, typename ...Args>
struct check_return<false, Callable, ReturnType, Args...>
{
static const bool value = false;
};
}
template<typename Callable, typename Function>
struct is_callable;
template<typename Callable, typename ReturnType, typename ...Args>
struct is_callable<Callable, ReturnType(Args...)>
{
private:
template<typename T>
static is_callable_detail::yes check(decltype(std::declval<T>()(std::declval<Args>()...)) *);
template<typename T>
static is_callable_detail::no check(...);
static const bool value_args = sizeof(check<Callable>(nullptr)) == sizeof(is_callable_detail::yes);
static const bool value_return = is_callable_detail::check_return<value_args, Callable, ReturnType, Args...>::value;
public:
static const bool value = value_args && value_return;
};
#endif // IS_CALLABLE_HPP
我的问题是如何检测没有参数且仅返回类型 T 的模板化运算符（）
template<typename T>
T operator()()
{
// ...
}
，或者
template<typename T, typename U>
auto operator()() -> decltype(std::declval<T>() + std::declval<U>())
{
// ...
}
我知道这种情况很少见，但我想问是否有任何方法可以检测存在不带参数且带有一个或多个模板参数的模板化运算符()。
I have is_callable trait defined like this:
#ifndef IS_CALLABLE_HPP
#define IS_CALLABLE_HPP
#include <type_traits>
namespace is_callable_detail
{
struct no {};
struct yes { no x[2]; };
template<bool CallableArgs, typename Callable, typename ReturnType, typename ...Args>
struct check_return
{
static const bool value = std::is_convertible<decltype(std::declval<Callable>()(std::declval<Args>()...)), ReturnType>::value;
};
template<typename Callable, typename ReturnType, typename ...Args>
struct check_return<false, Callable, ReturnType, Args...>
{
static const bool value = false;
};
}
template<typename Callable, typename Function>
struct is_callable;
template<typename Callable, typename ReturnType, typename ...Args>
struct is_callable<Callable, ReturnType(Args...)>
{
private:
template<typename T>
static is_callable_detail::yes check(decltype(std::declval<T>()(std::declval<Args>()...)) *);
template<typename T>
static is_callable_detail::no check(...);
static const bool value_args = sizeof(check<Callable>(nullptr)) == sizeof(is_callable_detail::yes);
static const bool value_return = is_callable_detail::check_return<value_args, Callable, ReturnType, Args...>::value;
public:
static const bool value = value_args && value_return;
};
#endif // IS_CALLABLE_HPP
My question is how to detect templated operator() which doesn't have arguments and has only return type T
template<typename T>
T operator()()
{
// ...
}
or
template<typename T, typename U>
auto operator()() -> decltype(std::declval<T>() + std::declval<U>())
{
// ...
}
I know that this situations are rare, but I wanted to ask is there any way to detect presence of templated operator() with no arguments and with one or more template arguments.
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（2）
如果你事先知道
operator()不会被重载，你可以尝试获取它的地址。如果operator()可能重载，则正结果意味着存在operator()，但负结果意味着存在要么不存在operator()，要么至少存在两个重载。请注意，模板将（如预期）带来
operator()的多个重载。但是，如果您确实知道非默认模板参数的数量，则可以尝试获取operator()的地址（对于某些T类型，< em>希望不会触发 SFINAE）。最后一点，我建议不要花太多时间尝试在不知道要传递哪些参数的情况下检查仿函数（或成员函数，出于同样的原因），就像您已经拥有的参数一样。 C++11 使得编写和使用在表达式级别运行的通用代码变得非常容易。
If you know in advance
operator()is not going to be overloaded, you can try to take its address. Ifoperator()is possibly overloaded, then a positive result would mean that there is anoperator()present but a negative result would mean that either nooperator()is present, or at least two overloads are.Notice that a template will (as expected) bring several overloads of
operator(). However, if you do know the number of template parameters that are not defaulted you can try taking the address ofoperator()<T>(for some typeTthat hopefully won't trigger SFINAE).As a final note, I'd suggest not trying to spend too much time trying to inspect functors (or member functions, for the same reasons) without knowing what arguments to pass, just like what you already have. C++11 makes it very easy to write and use generic code that functions at the expression level.
您正在尝试检测具有非推导模板参数的
operator()成员函数模板，这根本不是真正的“可调用”，而且也是毫无意义的 - 函数模板应该具有一个真实的名字，因为你的例子确实没有抓住整个operator的要点。但无论如何，我们还是要解决你的问题。请允许我用一个我正在开发的库解决方案的插件作为序言，名为 CallableTraits（同样，一项正在进行的工作）。
虽然您的情况不是由 CallableTraits 处理的，但该库确实采用了我将要描述的技术来解决非常相似的问题。该技术完全是一种黑客技术，但它符合标准，并且适用于以下平台：
注意：Visual Studio 2015 Update 2 已损坏，因为它不正确在部分专业化中推导出 std::index_sequence...我提交了一份错误报告。请参阅此处了解说明。
注意：如果您的标准库实现还没有
std::disjunction那么您可以使用示例实现 这里 代替。我将该技术称为模板蠕虫。这在元编程中相当于往一口又深又黑的井里吐口水，只是为了听听它需要多长时间才能溅出来。
什么是模板蠕虫？
decltype包围顶级表达式时才能使用它，就像std::declval() 一样。模板蠕虫将自己扭动到不应该去的地方，并坚持它能找到的第一个具体类型。以类似的方式，真正的蠕虫会在七月的任何一个下午粘在混凝土上。
为了解决您的问题，我们将从无参数开始，然后递归地工作到任意限制 10。我们尝试通过函数式调用传递模板蠕虫来调用（潜在的）函数对象， AND 通过模板类型参数（根据您的要求）。
此代码不考虑 INVOKE 语义，因为这需要更多的时间代码。如果您需要它与成员函数指针和成员数据指针一起使用，您可以为此推出自己的实现。
我可能没有涵盖所有运算符，也可能没有正确实现它们，但您会明白这一点。
最后一件事：
我知道一个渔获。 返回类型不能依赖于依赖名称（除了 。
编辑：此外，调用/模板实例化需要 SFINAE 友好（即没有
static_assert）言归正传，这是您的独立解决方案（尽管您可能希望自己没有问过）：
You are trying to detect an
operator()member function template with non-deduced template parameters, which isn't really "callable" at all, and also is kind of pointless - the function template should instead have a real name, because your example really misses the point of the wholeoperatorthing. But let's solve your problem anyway.Allow me to preface this with a plug for a library solution I'm working on, called CallableTraits (again, a work in progress).
While your case is not handled by CallableTraits, the library does employ a technique I'm about to describe to solve a very similar problem. The technique is a total hack, but it's standard compliant, and works for me on the following platforms:
Note: Visual Studio 2015 Update 2 is broken, because it incorrectly deduces
std::index_sequence<I...>in partial specializations... I filed a bug report. See here for a description.Note: If your standard library implementation doesn't have
std::disjunctionyet then you can use the sample implementation here instead.I call the technique the template worm. It's the metaprogramming equivalent of spitting into a deep, dark well, just to hear how long it takes to splash.
What is a template worm?
decltypesurrounds the top-level expression, just likestd::declval<T>().A template worm wiggles itself into places it isn't supposed to be, and sticks to the first concrete type it can find. In a similar fashion, a real worm will stick to the concrete on any afternoon in July.
To solve your problem, we will start with no arguments, then recursively work up to an arbitrary limit of 10. We try to make the call to the (potential) function object by trying to pass the template worm by by function-style invocation, AND by template type argument (per your requirements).
This code doesn't account for INVOKE semantics, because that takes signifcantly more code. If you need this to work with pointers-to-member-functions and pointers-to-member-data, you can roll your own implementation for that.
I might not have covered all the operators, and I might not have implemented them all correctly, but you'll see the point.
One last thing:
I know of one catch. The return type can't depend on a dependent name (other than member operators).
Edit: Also, invocation/template instantiation needs to be SFINAE-friendly (i.e. no
static_asserts).Without further ado, here is your standalone solution (although you might wish you hadn't asked):