如何使这些std ::函数参数明确? [英] How to make these std::function parameters unambiguous?
问题描述
传递lambda时,以下函数重载是不明确的。我发现 std :: function
可以从大多数可调用类型构造< a>,即使他们的签名不匹配。所以编译器不能告诉使用哪个函数。
The following function overloads are ambiguous when passing a lambda. I found out that std::function
can be constructed from most callable types, even if their signature does not match. So the compiler can't tell which function to use.
template <typename T> void each(std::function<void(T)> iterator);
template <typename T> void each(std::function<void(T, id)> iterator);
template <typename T> void each(std::function<void(T&)> iterator);
template <typename T> void each(std::function<void(T&, id)> iterator);
这里有一些类似的问题,但是没有一个可以解决我的问题。如何在不改变用法的情况下解决模糊?更多,当时我必须明确提及模板类型。
There are some similar questions out here, but none of them could solve my problem. How can I resolve the ambiguity without changing the usage? Morever, at the time I have to explicitly mention the template type. Is there a way around this?
推荐答案
其中一半是 LWG问题2132 ,删除 std :: function
的构造函数,除非参数实际上是可调用的参数类型指定。这需要表达式SFINAE支持来实现,VC ++没有。
One half of this is LWG issue 2132, removing std::function
's constructor from overload resolution unless the argument is actually callable for the argument types specified. This requires expression SFINAE support to implement, which VC++ doesn't have.
问题的另一半是重载解析:
The other half of the issue is overload resolution:
#include<functional>
#include<iostream>
struct id {};
template <typename T> void each(std::function<void(T)> ){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
template <typename T> void each(std::function<void(T, id)> ){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
template <typename T> void each(std::function<void(T&)> ){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
template <typename T> void each(std::function<void(T&, id)> ){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
int main() {
each<int>([](int, id){});
}
使用实现LWG2132的库,这段代码打印,可能会令人惊讶:
With a library that implements LWG2132, this code prints, perhaps surprisingly:
void each(std::function<void(T&, id)>) [with T = int]
b $ b
为什么?首先,可以从 [](int,id){...构造一个
。毕竟,后者可以用类型 std :: function< void(T& id)>
} int
的左值调用。
Why? First, it is possible to construct a std::function<void(T&, id)>
from [](int, id){}
. After all, the latter can be called with a lvalue of type int
just fine.
Second,in
Second, in
template <typename T> void each(std::function<void(T, id)>);
template <typename T> void each(std::function<void(T&, id)>);
第二个是比第一个更专门的功能模板的部分排序规则,通过重载解析。
The second is more specialized than the first by the partial ordering rules for function templates, so it's always chosen by overload resolution.
一个可能的解决方案是通过操作lambda的 operator()
:
A possible solution is to extract the signature by manipulating the type of the lambda's operator ()
:
template<class T>
struct mem_fn_type;
template<class R, class C, class... T>
struct mem_fn_type<R(C::*)(T...)> {
using type = std::function<R(T...)>;
};
template<class R, class C, class... T>
struct mem_fn_type<R(C::*)(T...) const> {
using type = std::function<R(T...)>;
};
// optional extra cv-qualifier and ref-qualifier combos omitted
// since they will never be used with lambdas
// Detects if a class is a specialization of std::function
template<class T>
struct is_std_function_specialization : std::false_type {};
template<class T>
struct is_std_function_specialization<std::function<T>> : std::true_type{};
// Constrained to not accept cases where T is a specialization of std::function,
// to prevent infinite recursion when a lambda with the wrong signature is passed
template<class T>
typename std::enable_if<!is_std_function_specialization<T>::value>::type each(T func) {
typename mem_fn_type<decltype(&T::operator())>::type f = func;
each(f);
}
这不适用于通用lambdas(其 operator()
是一个模板)或任意函数对象(可能有任意多个 operator()
重载)。
This won't work for generic lambdas (whose operator()
is a template) or for arbitrary function objects (which may have arbitrarily many operator()
overloads).
这篇关于如何使这些std ::函数参数明确?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!