C++11 Lambda 函数隐式转换为 bool 与 std::function

Question

考虑这个简单的示例代码：

#include <functional>
#include <iostream>

void f(bool _switch) {
    std::cout << "Nothing really" << std::endl;
}

void f(std::function<double (int)> _f) {
    std::cout << "Nothing really, too" << std::endl;
}

int main ( int argc, char* argv[] ) {
    f([](int _idx){ return 7.9;});
    return 0;
}

编译失败：

$ g++ --std=c++11 main.cpp
main.cpp: In function ‘int main(int, char**)’:
main.cpp:15:33: error: call of overloaded ‘f(main(int, char**)::<lambda(int)>)’ is ambiguous
main.cpp:15:33: note: candidates are:
main.cpp:6:6: note: void f(bool)
main.cpp:10:6: note: void f(std::function<double(int)>)

但是，如果我用引用参数替换第二个函数，它编译得很好。如果它被 const 引用替换，它再次失败。

所以我对这个例子有一些疑问：

• 为什么 lambda 函数首先可以隐式转换为 bool？
• 为什么采用 std::function 引用可以解决歧义？
• 对我来说最重要的是，如何避免这个问题？我需要第二个函数来获取（a 的副本）std::function 或对它的 const 引用。

Answer 1

可以将不带捕获的 lambda 函数转换为常规函数指针，然后将其标准转换为布尔值。

如果您通过非常量引用获取std::function，则将其排除为候选对象，因为将 lambda 转换为 std::function 需要一个临时对象，而临时对象不能绑定到非常量引用。这样就只剩下f(bool) 作为候选人，所以没有歧义。

有很多方法可以避免歧义。例如，您可以先创建一个std::function 变量：

std::function<double(int)> g = [](int _idx){ return 7.9;};
f(g);

或者你可以转换 lambda：

f(std::function<double(int)>([](int _idx){return 7.9;}));

你可以有一个辅助函数：

template<typename T>
std::function<T> make_function(T *f) { return {f}; } 

int main ( int argc, char* argv[] ) {
    f(make_function([](int _idx){ return 7.9;}));
    return 0;
}  

或者您可以获取您感兴趣的特定功能：

int main ( int argc, char* argv[] ) {
    void (*f_func)(std::function<double(int)>) = f;
    f_func([](int _idx){ return 7.9;});
    return 0;
}

Answer 2

namespace details{
  template<class Sig,class=void>
  struct invoke {};
  template<class F, class...Args>
  struct invoke<F(Args...),decltype(void(
    std::declval<F>()(std::declval<Args>()...)
  ))>{
    using type=decltype(std::declval<F>()(std::declval<Args>()...));
  };
}
template<class Sig>struct invoke:details::invoke<Sig>{};

template<typename Sig, typename T, typename=void>
struct invoke_test:std::false_type {};
template<typename R, typename...Args, typename T>
struct invoke_test<R(Args...), T,
  typename std::enable_if<
    std::is_convertible<
      typename invoke<T(Args...)>::type,
      R
    >::value
  >::type
>:std::true_type {};
template<typename...Args,typename T>
struct invoke_test<void(Args...),T,
  decltype( void( typename invoke<T(Args...)>::type ) )
>:std::true_type{};
template<typename Sig, typename T>
constexpr bool invokable() {
  return invoke_test<Sig,T>::value;
}

这给了我们一个伪概念invokable。

然后我们可以像这样使用它：

template<typename F>
typename std::enable_if<invokable<double(int),F>()>::type
f(F&&){
  std::cout << "can be invoked\n";
}
void f(bool) {
  std::cout << "is bool\n";
}

鲍勃是你的叔叔。

真正的问题是std::function<double(int)> 的构造函数没有做类似的测试，而是声称（错误地）它可以由任何东西构造。这是标准中的一个缺陷，我怀疑一旦概念标准化就会修复。

Answer 3

您可以通过创建帮助类来摆脱隐式转换

#include <functional>
#include <iostream>

struct Boolean { 
    bool state; 
    Boolean(bool b):state(b){} 
    operator bool(){ return state; } 
};
void f(Boolean _switch) {
    std::cout << "Nothing really " << _switch << std::endl;
}

void f(std::function<double (int)> _f) {
    std::cout << "Nothing really, too" << std::endl;
}

int main ( int argc, char* argv[] ) {
    f([](int _idx){ return 7.9;});
    f(true);
    return 0;
}

如果你想用例如打电话给f。一个指针并期望它调用第一个重载，您必须将其强制转换为 bool 或添加相应的构造函数/强制转换到辅助类。

Answer 4

Vaughn Cato's answer 的另一个选项：

template<typename F>
void f(F _f) {
    std::cout << "Nothing really, too: " << _f(3) << std::endl;
}

现在第二个重载是一个模板，所以它被选择用于 lambda（或任何东西），第一个被选择用于 bool。所以调用f 并不比需要的复杂。

但是，这样做的一个问题是如果您想添加更多重载，另一个问题是只有在与 bool 完全匹配时才会调用第一个重载。