Wenn ich eine memberfunktion überlade, dass sie einmal ein einzelnes Element und einmal einen vector von Elementen annehmen kann, wieso kann ich dann nicht die einzelfunktion mit for_each aufrufen?

class Foo {
   void bar(const baz&) { do_something(); }
   void bar(const std::vector<baz>& vec) { std::for_each(vec.begin(), vec.end(), std::bind1st(&Foo::bar, this)); }
};

g++ 4.4.0 meint dazu:
error: no matching function for call to ‘bind1st(<unresolved overloaded function type>, Foo* const)’

Ideen?

error: no matching function for call to ‘mem_fun(<unresolved overloaded function type>)’

Mit Überladungen haben Funktionsobjekte so ihre Schwierigkeiten. Bei &Foo::bar ist ja nicht ohne Weiteres klar, welche Funktion gemeint ist. So funktioniert z.B. auch std::tr1::bind() nicht.

Ich denke, um eine gute alte Schleife wirst du nicht herumkommen, wenn die Methoden gleich heissen sollen.

void bar(const std::vector<int>& vec) 
   {
      void (Foo::*first)(const int&) = &Foo::bar;
	  std::for_each(vec.begin(), vec.end(), std::tr1::bind(first, this, _1));
   }

Da ich std::bind1st hasse und es verbuggt ist, bin ich mir nicht sicher, ob es damit auch geht. Aber tr1::bind ist eh besser.

Ich revidiere obige Aussage zu folgender:
"Boah wie ich das hasse. C++/STL hat soooo viele tolle Features, aber wenn man sie mal so richtig nutzen will, muss man Code produzieren, den kein Mensch mehr lesen kann."

Was es halt für dich schwer zu lesen macht ist die Tatsache, dass da in der Zeile sehr viel drin steckt. Schreib das mal auf "deine" Art aus und dann merkst du, dass da eigentlich sehr viel eleganz drin ist das in einer Zeile zu machen. Und es wird dir dann auch jeder bestätigen, dass der Einzeiler sehr viel klarer ist, als irgendwelche Schleifengebastlereien, wo jeder Leser zuerst alles anschauen muss, bis er überhaupt verstehen kann, was es macht.
Hier habe ich genau diese eine Zeile angeschaut und wusste, was sie machen sollte. Bei einem Schleifenkonstrukt hätte ich zuerst mal die Bedingung anschauen müssen, wann/wo inkrementiert wird und schlussendlich noch den eigentlichen Code. Wenn das mal keine Zeitersparnis ist.

"Boah wie ich das hasse. C++/STL hat soooo viele tolle Features, aber wenn man sie mal so richtig nutzen will, muss man Code produzieren, den kein Mensch mehr lesen kann."

Du findest einen Memberfunktionszeiger unlesbar? Wahrscheinlich nur, weil du noch nicht oft damit gearbeitet hast. Dabei ist das etwas ziemlich Zentrales, wenns in Richtung STL und funktionales Programmieren geht. Die drei Möglichkeiten für Callables sind nämlich Funktionszeiger, Memberfunktionszeiger und Funktionsobjekte. Für effizientes Arbeiten mit den STL-Algorithmen würde ich deren Kenntnis voraussetzen.

Bedenke ausserdem, dass der gezeigte Code sehr kompakt ist. Da die beiden Methoden gleich heissen, brauchst du eine Zusatzinformation, um sie auseinanderzuhalten. Und das ist eben die Signatur von bar , welche in den Typ des Funktionszeigers einfliesst.

void bar(const std::vector<int>& vec, int i = 0)
   {
      std::for_each(vec.begin(), vec.end(), std::tr1::bind(&foo::bar, this, _1));
   }

Obwohl ich das ein wenig merkwürdig finde, dass es funktioniert (MSVC).
Würde sogar behaupten, dass das ein Bug ist, da sich die Funktion eigentlich gleich verhalten müsste, als ob da kein Parameter ist. Wäre mal etwas, um mal wieder den Standard zu wälzen.