C++ 将std:：函数与lambda和可变模板一起使用

我在网上找到了一些不错的循环函数，但没能把它变成我自己的。代码没有注释，因此没有帮助

原始代码：

  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
  }

模板结构标识{typedef T type；}；
模板
分别作废（类型名称标识：：类型f）{
//做事
}

我们的目标是从一个类中解包一些数据并在其上应用函数，因为有一个包含对象的管理器，这个对象内部有一些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;
}

#包括
#包括
福班{
模板
每个函数的void（std:：function func）{
std:：cout如果指定
std:：function
作为参数类型，则必须传递
std:：function
。lambda不是
std:：function
，但可用于创建lambda

#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;
}

#包括
#包括
福班{
公众：
模板
每个函数的void（std:：function func）{
标准：：cout基于

目标是从类中解包一些数据并对其应用函数，因为有一个包含该对象的管理器，该对象内部有一些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;
}

#包括
#包括
#包括
福班{
公众：
模板
每个函数的void（std:：function func）{
std:：cout如果计划仅使用非捕获lambda，则可以使用函数指针作为参数，并让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;
}

它可用于捕获和非捕获lambda。
您正在使用的lambda函数可用于构造
std:：function
，但不能用于构造
std:；function@RSahu这是一个从类中解压数据的循环。如果它有帮助的话，我会把它添加到问题中。是的，在我看来，它是，我在看什么ng为。我休息一下，检查一下。谢谢：）想法在那里，但真正的问题仍然存在。我需要一个可变模板。我需要能够为每个
，
为每个
…我会用原始代码更新问题。这不是我真正希望的，但可能会更好。我在考虑cast是隐式的，谢谢你的警告。我以为你要展示一个基于
invoke
的解决方案skypjack；-）@RichardHodges，然后我想OP想知道什么是
t
，以便在函数中使用它。@skypjack我搜索的解决方案是我想的第二个解决方案（不确定操作符+技巧是否适合用于库）。但如果您不介意，我想知道基于
调用
的解决方案是什么（从未听说过）。我将详细检查任何解决方案。无论如何，感谢您一如既往：）@mathieuvanevel@richardhoges还没有出现。：-（…无论如何，（C++标记）很快就会很有趣。：-）
#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;
}

#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;
}