class Interface
{
public:
	virtual void f(int i) = 0;
};

class Foo : public Interface
{
public:
	Foo():s(0){}
	virtual void f(int i)
	{
		if ( i == 1 )
			s = clock();
		else if ( i == 400000000 )
			std::cout<< clock() - s<<"\n";
	}
private:
	clock_t s;
};

int main(int argc, char**)
{
	Foo* foo = new Foo();

	boost::function<void(int)> bf = boost::bind(&Foo::f, foo, _1);
	for(int i = 0; i<400000001*argc; i++)
	{
		bf(i);
	}

	void(Foo::*mf)(int);
	mf = &Foo::f;
	for(int i = 0; i<400000001*argc; i++)
	{
		(foo->*mf)(i);
	}

	Foo sfoo;
	for(int i = 0; i<400000001*argc; i++)
	{
		sfoo.f(i);
	}

	Interface* ifa = foo;
	for(int i = 0; i<400000001*argc; i++)
	{
		ifa->f(i);
	}

	for(int i = 0; i<400000001*argc; i++)
	{
		foo->f(i);
	}

}

4067 //boost function
1811 //member pointer
455 //Foo auf Stack
1519 //Aufruf über Interface
1660 //Direkter Aufruf

Boost ist deutlich am langsamsten, aber dafür ist das Objekt schon dran gebunden.
Aufruf mit Interface oder direkt ist praktisch gleich schnell, aber man muss immer das Objekt haben.
Aufruf mit Memberfunction Pointer ist etwas langsamer und man braucht das Objekt.
Foo auf dem Stack ist am schnellsten. Dürfte wohl das virtual weg optimiert sein. Keine Polymorphie möglich, daher uninteressant.

Gibts noch eine andere und schnellere Möglichkeit, die was ähnliches wie boost function macht?

In der Klasse ist doch auch nur das Objekt und der member pointer enthalten oder
sehe ich das falsch?

Kann evtl. ohne boost etwas wegoptimiert werden? Wenn ja, was?

Dann brauchts ja noch den offset zu Basisklasse.

Steht dieser Offset nicht eh schon in der vtable? Immerhin ist er für alle
Objekte einer Klasse gleich...

Besser wäre es, den Assemblercode zu vergleichen und die benötigten Zyklen zu zählen. Dann gibt es zumindest ein ungefähres Bild, auch wenn in einer realen Anwendung noch andere Effekte eine Rolle spielen können.

Warum braucht die boost-Variante denn länger?

Naja, erstmal hast Du bei boost::function zwei "Weiterleitungen". Du rufst boost::function auf, boost::function ruft eine interne Funktion auf. Die interne Funktion ruft das auf, was Du willst. Dazu kommt jetzt noch, dass Du eine weitere Indirektion dabei hast, weil Deine Funktion f virtuell ist.

Wenn es schnell gehen soll, nimmst Du eben Templates+Funktoren, falls möglich. Das ist dann noch besser bzgl Performance weil der Funktions-Code relativ leicht "ge-inline-t" werden kann.

Dann gibt es noch Dinge wie "The Impossibly Fast C++ Delegates", welche speziell für Elementfunktionen gedacht sind und nicht wie boost::function auch mit anderen Funktoren klarkommt. Der Trick ist dabei Elementfunktionszeiger als Templateparameter zu benutzen.

kk

`1593

1195

664

1062

1195`

Womit der Unterschied zwischen der boost-Methode und der herkömmlichen eigentlich fast schon nicht mehr der Rede wert ist.