编写一个接受 lambda 表达式作为参数的函数

Question

我有一个这样的方法

template<typename T, typename U>
map<T,U> mapMapValues(map<T,U> old, T (f)(T,U))
{
    map<T,U> new;
    for(auto it = old.begin(); it != old.end(); ++it)
    {
        new[it->first] = f(it->first,it->second);
    }
    return new; 
}

，想法是你可以这样调用它

BOOST_AUTO_TEST_CASE(MapMapValues_basic)
{
    map<int,int> test;
    test[1] = 1;
    map<int,int> transformedMap = VlcFunctional::mapMapValues(test, 
        [&](int key, int value) -> int
        {
            return key + 1; 
        }
    );
}

但是我收到错误：没有函数模板“VlcFunctional::mapMapValues”的实例与参数列表参数类型匹配：(std::map, std ::allocator>>，__lambda1）

知道我做错了什么吗？ Visual Studio 2008 和英特尔 C++ 编译器 11.1

Answer 1

您的函数需要一个函数指针，而不是 lambda。

在 C++ 中，通常有 3 种类型的“可调用对象”。

1. 函数指针。
2. 函数对象。
3. 拉姆达函数。

如果您希望能够在函数接口中使用所有这些，那么您可以使用 std::function ：

template<typename T, typename U> 
map<T,U> mapMapValues(map<T,U> old, std::function<T(T, U)> f)
{
    ...
}

这将允许使用上述三种类型的可调用对象中的任何一种来调用函数。然而，这种便利的代价是函数调用的少量开销（通常是空指针检查，然后通过函数指针进行调用）。这意味着该函数几乎肯定不是内联的（除非使用高级 WPO/LTO）。

或者，您可以添加额外的模板参数来为第二个参数采用任意类型。这会更有效，但你会失去所使用函数的类型安全性，并可能导致更多的代码膨胀。

template<typename T, typename U, typename F> 
map<T,U> mapMapValues(map<T,U> old, F f) 

Answer 2

您的参数类型声明 T (f)(T,U) 的类型为“自由函数，采用 T 和 U 并返回 <代码>T'。您不能向其传递 lambda、函数对象或除具有该签名的实际函数之外的任何内容。

您可以通过将参数类型更改为 std::function 来解决此问题，如下所示：

template<typename T, typename U> 
map<T,U> mapMapValues(map<T,U> old, std::function<T(T,U)>)
{
}

或者，您可以将函数类型声明为模板参数，如下所示：

template<typename T, typename U, typename Fn> 
map<T,U> mapMapValues(map<T,U> old, Fn fn)
{
  fn(...);
}

Answer 3

我想贡献这个简单但不言自明的例子。它展示了如何将“可调用的东西”（函数、函数对象和 lambda）传递给函数或对象。

// g++ -std=c++11 thisFile.cpp

#include <iostream>
#include <thread>

using namespace std;

// -----------------------------------------------------------------
class Box {
public:
  function<void(string)> theFunction; 
  bool funValid;

  Box () : funValid (false) { }

  void setFun (function<void(string)> f) {
    theFunction = f;
    funValid = true;
  }

  void callIt () {
    if ( ! funValid ) return;
    theFunction (" hello from Box ");
  }
}; // class

// -----------------------------------------------------------------
class FunClass {
public:
  string msg;
  FunClass (string m) :  msg (m) { }
  void operator() (string s) {
    cout << msg <<  s << endl; 
  }
};

// -----------------------------------------------------------------
void f (string s) {
  cout << s << endl;
} // ()

// -----------------------------------------------------------------
void call_it ( void (*pf) (string) ) {
  pf( "call_it: hello");
} // ()

// -----------------------------------------------------------------
void call_it1 ( function<void(string)> pf ) {
  pf( "call_it1: hello");
} // ()

// -----------------------------------------------------------------
int main() {

  int a = 1234;

  FunClass fc ( " christmas ");

  f("hello");

  call_it ( f );

  call_it1 ( f );

  // conversion ERROR: call_it ( [&] (string s) -> void { cout << s << a << endl; } );

  call_it1 ( [&] (string s) -> void { cout << s << a << endl; } );

  Box ca;

  ca.callIt ();

  ca.setFun (f);

  ca.callIt ();

  ca.setFun ( [&] (string s) -> void { cout << s << a << endl; } );

  ca.callIt ();

  ca.setFun (fc);

  ca.callIt ();

} // ()

Answer 4

根据 n3052。然而，这个功能似乎没有在 VC++ 中实现，只有部分在 g++ 中实现，请参阅我的 SO 问题。

Answer 5

这是如何将函数作为参数传递的一些示例

class YourClass
{
void YourClass::callback(void(*fptr)(int p1, int p2))
{
    if(fptr != NULL)
      fptr(p1, p2);
}
};

void dummyfunction(int p1, int p2)
{
   cout << "inside dummyfunction " << endl;
}

YourClass yc;

// using a dummyfunction as callback
yc.callback(&dummyfunction);

// using a lambda as callback
yc.callback( [&](int p1, int p2) { cout << "inside lambda callback function" << endl; } );

// using a static member function 
yc.callback( &aClass::memberfunction );