Seit ich Boost.Bind entdeckt habe, benutze ich es ununterbrochen. Es ist wohl eines der Boost-Features, welches ich am meisten einsetze.
Wenn ich meinen Code nochmals etwas später anschaue (was logischweise durchaus vorkommt), dann kommt es mir manchmal fast ein wenig so vor, als wäre Boost.Bind ein modernes goto.
Klar man kann wahnsinnig geile Dinge mit Boost.Bind machen. Zum Beispiel verschachtelte Funktionen mit Parametern verzögert aufrufen, finde ich extrem praktisch. Aber kann es sein, dass Boost.Bind ein wenig die Übersicht raubt und einem Richtung Goto-Spaghetti-Code führt?

Wie ist das bei euch so? Wie oft verwendet ihr Boost.Bind? Probiert ihr eher Alternativen zu Boost.Bind zu finden oder nutzt ihr es ungehemmt?

Grüssli

Zum Beispiel verschachtelte Funktionen mit Parametern verzögert aufrufen, finde ich extrem praktisch.

Wie geht das? Beispiel?

Willkommen bei den anonymen Boost.Bindern. Setz dich hin und hör zu, wie die anderen ihre Leidengeschichte erzählen.

Es ist keine Leidensgeschichte, es ist eher eine Droge :p

Anonymer Knüpfer schrieb:

Zum Beispiel verschachtelte Funktionen mit Parametern verzögert aufrufen, finde ich extrem praktisch.

Wie geht das? Beispiel?

Zum Beispiel sowas:

class CThread
{
	// Attributes //
private:
	boost::function3<void, int, int, int> m_Func;

	// Constructors & Destructor //
public:
	CThread(boost::function3<void, int, int, int> Func) : m_Func(Func) { };
	~CThread() { };

	// Methods //
private:
	void run()
	{
		int x = 0, y = 1, z = 2;
		// Mach irgendwas

		if(m_Func)
		{ m_Func(x, y, z); }
	}

public:
	void start() { boost::thread(boost::bind(&CThread::run, this)); };
};

int calc(int y, int z, int o)
{
	// Mach was
	return y + z + o;
}

void end_thread(int x, int y)
{
	// Mach was
	std::cout << "Thread end, x: " << x << " , y: " << y << std::endl;
}

int main()
{
	CThread Thread(boost::bind(&end_thread, _1, boost::bind(&calc, _2, _3, 10)));
	// Bedeutung:
	// Am ende des Threads wird folgender Aufruf ausgeführt:
	// end_thread(x, calc(y, z, 10));

	Thread.start();

	std::cin.sync();
	std::cin.get();

	return 0;
}

Gerade das bind im CThread Konstruktor ist ein bisschen wahnsinnig und ich habe schon extremere erlebt. Aber es geht so viel einfacher und erlaubt einem so viele Möglichkeiten.
Auch eine praktische Sache im Beispiel ist, die einfache Art die private Methode run aufzurufen.

Mit Boost.Bind ist fast alles möglich, womöglich eben zu viel

Grüssli

Doch, ich benutze inzwischen auch sehr häufig Funktionskomposition. Geht schneller als eine neue Funktion zu schreiben, und hilft meiner Meinung nach die Algorithmen (und sei es nur eine Schleife wie diese) von der eigentlichen Aufgabe zu trennen.