#include <functional>

template<class R, class T>
unspecified mem_fn(R T::* pm)

Erzeugt ein Funktionsobjekt für eine Methode f, die über einen T-Objektzeiger aufgerufen wird.

Rückgabewert: ein Funktor.

bind(), Funktionsadapter, Lambda-Ausdruck.

mem_fn.cpp

#include <functional>
#include <iostream>
#include <string>
 
int main()
{
  auto f = std::mem_fn(&std::string::size);
 
  std::string woerter[] = { "Ein", "Test" };
  for(auto e : woerter)
  {
    std::cout << e << " : " << f(e) << '\n';
  }
 
  // === überladene Methoden mit cast spezifiziert:
 
  // std::string& (std::string::*member)(const std::string&)> = 
  auto member = 
    static_cast<std::string& (std::string::*)(const std::string&)>(&std::string::append);
 
  auto fn = std::mem_fn(member);
 
  // std::function<std::string&(std::string&)> 
  auto binder = std::bind(fn, std::placeholders::_1, " and bind");
 
  // === bind() auch ohne mem_fn() möglich:
 
  // std::function<std::string&(std::string&, const std::string&)> 
  auto binder2 = std::bind(member, std::placeholders::_1, std::placeholders::_2);
 
  // === oder Lambda-Ausdruck:
 
  auto lambda = [](std::string& s, const std::string& appendix) 
    -> std::string& 
    {
      return s.append(appendix);
    };
  // trailing return type needed here, otherwise std::function<> cannot resolve
 
  // std::function<std::string&(std::string&, const std::string&)> 
  auto f = std::function<std::string&(std::string&, const std::string&)>(lambda);
 
  std::string s = "Hello";
  (s.*member)(" world");
  fn(s, " of mem_fn");
  binder(s);
  binder2(s, " with placeholders"); 	
  lambda(s, " or lambda");
  f(s, " as function");
 
  std::cout << s << '\n';
}