什么是C++；等效于java.util.function.Consumer？

例如，我有以下Java代码：

import java.util.function.Consumer;

public class Main {
  public static void main(String[] args) {
    Consumer<String> c = (x) -> System.out.println(x.toLowerCase());
    c.accept("Java2s.com");
  }
}

import java.util.function.Consumer；
公共班机{
公共静态void main（字符串[]args）{
consumerc=（x）->System.out.println（x.toLowerCase（））；
c、 接受（“Java2s.com”）；
}
}

C++等价物是什么？

< P>使用<代码> STD:：函数< /C> > /P> 您可以从函数指针或lambdas初始化此实例，例如：

void foo(const std::string &s) {
    std::cout << s << std::endl;
}

// later
std::function<void(const std::string &)> c = foo;
c("Java2s.com");

void foo（const std:：string&s）{
std:：cout我大胆猜测，您需要的功能是基于lambda expression提供的功能

C++11提供了对lambda表达式的支持，下面的代码在更一般的级别上提供了您发布的代码的功能

auto algorithm = [&]( double x, double m, double b ) -> double
   {
   return m*x+b;
   };

int a=algorithm(1,2,3), b=algorithm(4,5,6);

如果您确实错过了
接受
。您还可以实现：

#include <functional>
#include <iostream>
#include <string>

template <class Food>
class Consumer {
 private:
  std::function<void(Food)> consume_;

 public:
  template <class Eater>
  Consumer<Food>(Eater consume) : consume_(consume){};

  void accept(Food food) { consume_(food); }
};

// Usage
int main() {
  Consumer<const std::string&> consumer([](
      const std::string& out) { std::cout << out << '\n'; });
  consumer.accept("My lovley string.");
  consumer.accept("Will be eaten!");
}

#包括
#包括
#包括
模板
阶级消费者{
私人：
std：：函数消耗；
公众：
模板
消费者（食者消费）：消费（消费）{}；
无效接受（食物）{消费（食物）}
};
//用法
int main（）{
消费者（[](
const std:：string&out）{std:：cout让我们先看一个更完整的示例，说明如何在Java中使用
使用者

与Java代码类似，我们可以使用lambda表达式定义操作：

preOrderTraverse(rootNode, [](auto node) { std::cout << node->getText(); });

preOrderTraverse（rootNode，[]（自动节点）{std:：cout getText（）；}）；

作为一个简单的经验法则，假设C++中任何参数的使用都是错误的，函数的<或代码>是错误的。对于这种情况，应该将类型作为模板参数传递。我们需要接受像对象这样的函数，存储它，然后在以后调用它。参数类型仍然应该是模板参数，但是我们存储它的对象可以合理地是
std:：function



1.由于虚拟函数不能是模板，如果您需要将这样的通用函数传递给必须是虚拟函数的函数，那么几乎您唯一真正的选择是使用
std:：function
（或者自己生成类似的函数，这不太可能是真正的改进）。
对您来说，这似乎是一件非常复杂的事情，您需要一个等价物吗？也许？
std:：function c=[]（auto s）{/*…*/}；
@Galik:Perfect，但我想您也可以在这两个位置使用“auto”：auto c=[]（auto x）{std:：cout@DaveDoknjas我想是的，但是如果lambda希望这样，那么您必须指定
std:：string
作为调用参数，否则它可能会得到
const char*
@Galik:不，这是一个新的通用lambda。它将同时接受
std:：string
和
const char*
，以及任何其他prin表类型。主要的例外是
std:：function
作为
virtual
函数的参数，因为这些函数不能是模板。@MSalters:Hmm……是的，我想我应该提一下。
template <class Food>
class Consumer {
 public:
  std::function<void(Food)> accept;

  template <class Eater>
  Consumer<Food>(Eater consume) : accept(consume){};
};

import java.util.function.Consumer;

public static void preOrderTraversal(TreeViewItem treeNode,               
                                     Consumer<TreeViewItem> action) {
    action.accept(treeNode);
    for (TreeViewItem child : treeNode.getItems()) {
        preOrderTraversal(child, action);
    }
}

// Call that code with
preOrderTraversal(rootNode, (TreeViewItem node) -> System.out.println(node.getText()));

template <class Item, class Consumer>
void preOrderTraverse(Item i, Consumer action) { 
    action(item);
    for (auto & child : item->getChildren())
        preOrderTraverse(child, action);
}

preOrderTraverse(rootNode, [](auto node) { std::cout << node->getText(); });