Question

我在互联网上找到了一些不错的循环功能，但是无法将其变为我自己的循环功能。并且代码被取消注释，因此没有帮助。

原始代码：

  template <typename T> struct identity { typedef T type; };

  template <typename ... Components>
  void each(typename identity<std::function<void(Base base, Components&...)>>::type f) {
    //do stuff
  }

目标是从类中解压缩一些数据并在其上应用函数，Foo有包含该对象的管理器，并且该对象里面有一些int成员。我希望它足够清楚。

我想实现类似的目标：

#include <functional>
#include <iostream>

class Foo {

  template < typename ... T >
  void  for_each(std::function<void(T&...)> func) {
    std::cout << "for_each" << std::endl;
  }
};

int main() {

  Foo  test;
  test.for_each<int>([](int& data) {
    std::cout << "main" << std::endl;
  });
  return 0;
}

但我有这个错误：

Test.cpp: In function ‘int main()’:
Test.cpp:17:4: error: no matching function for call to ‘Foo::for_each(main()::<lambda(int&)>)’
   });
    ^
Test.cpp:7:9: note: candidate: template<class ... T> void Foo::for_each(std::function<void(T& ...)>)
   void  for_each(std::function<void(T&...)> func) {
         ^~~~~~~~
Test.cpp:7:9: note:   template argument deduction/substitution failed:
Test.cpp:17:4: note:   ‘main()::<lambda(int&)>’ is not derived from ‘std::function<void(T& ...)>’
   });
    ^

似乎这个代码存在一些错误，我希望不再是这种情况了。如果你有一些建议让这段代码有效，那么你就会让一个人开心。

Answer 1

如果指定std::function作为参数类型，则必须传递std::function。 lambda不是std::function，但它可用于创建一个。

#include <functional>
#include <iostream>

class Foo {

  public:
  template < typename ... T >
  void  for_each(std::function<void(T&...)> func) {
    std::cout << "for_each" << std::endl;
  }
};

int main() {

  Foo  test;
  test.for_each<int>(std::function<void(int&)>([](int& data) {
    std::cout << "main" << std::endl;
  }));
  return 0;
}

这可能不是你想要的（目前，我只能猜测），这个编辑至少允许这个例子进行编译。

Answer 2

基于

目标是从类中解压缩一些数据并在其上应用函数，Foo是包含该对象的管理器，并且该对象内部有一些int成员

我认为你正在寻找类似的东西：

#include <functional>
#include <iostream>
#include <vector>

class Foo {

   public:

      template < typename T >
         void  for_each(std::function<void(T&)> func) {
            std::cout << "for_each" << std::endl;
            for ( int i : data)
            {
               func(i);
            }
         }

      std::vector<int> data;
};

int main() {

  Foo test;
  test.data = {1, 2, 3, 4, 5};

  test.for_each<int>([](int& data) {
    std::cout << "In main, data:" << data << std::endl;
  });
  return 0;
}

Answer 3

如果您打算仅使用非捕获lambdas，可以使用函数指针作为参数，让lambda衰减为这种类型。
它遵循一个最小的工作示例：

#include <iostream>

class Foo {
public:
  template < typename ... T>
  void  for_each(void(*func)(T&...)) {
    std::cout << "for_each" << std::endl;
  }
};

int main() {
  Foo  test;
  test.for_each(+[](int& data) {
    std::cout << "main" << std::endl;
  });
  return 0;
}

如果您可以处理类模板，另一种可能的方法是：

#include <functional>
#include <iostream>

template < typename ... T >
class Foo {
public:
  void  for_each(std::function<void(T&...)> func) {
    std::cout << "for_each" << std::endl;
  }
};

int main() {
  Foo<int> test;
  test.for_each([](int& data) {
    std::cout << "main" << std::endl;
  });
  return 0;
}

请注意，如果您实际上对类型T不感兴趣，则可以使用泛型类型并使用它：

#include <iostream>

class Foo {
public:
  template<typename F>
  void  for_each(F &&func) {
    std::cout << "for_each" << std::endl;
  }
};

int main() {
  Foo  test;
  test.for_each([](int& data) {
    std::cout << "main" << std::endl;
  });
  return 0;
}

它适用于捕获和非捕获lambda。

将std :: function与lambda和variadic模板一起使用

3 个答案: