Esempio di <em>Lambda Expression/Function</em> (C++0x)…

Finalmente sono riuscito a mettere le mani sul G++ 4.5, così da poter testare anche su questo compilatore le “lambda function/expression” introdotte nel futuro standard C++0x (cfr. post precedente).

Partiamo subito col dire che le “lambda” sono una new-entry del nuovo standard e, nonostante usarle non sia indispendabile, rappresentano comunque un’aggiunta interessante per una serie di motivi che vedremo immediatamente.

Per chi ha fretta: le lambda sono un modo rapido per definire in fretta delle funzioni-oggetto senza nome, definendole eventualmente proprio dove servono (“in place”), cioè al momento di invocarle.

Dall’ultimo draft dello standard (N3092, Marzo 2010):

5.1.2 Lambda expressions

Lambda expressions provide a concise way to create simple function objects.

Un esempio “canonico”: una funzione f(g()) che accetta come parametro un’altra funzione o un functor g() (“callback”). In un modo o nell’altro, prima di invocare f(), bisognerà aver già definito g().

Le lambda permettono di definire proprio quella g(), dove la si dovrebbe anche invocare.

Sintassi

Devo ammettere che la sintassi è un po’ raccapricc… ehm esteticamente poco piacevole (se paragonata a quelle delle Boost Libs, ad esempio), però ha il pregio di apparire molto simile a quelle delle funzioni scritte in modo “canonico”:

[]( *PARAMETERS* ){ *FUNCTION-BODY* };

La parte strana non sono nè i parametri nè il corpo della funzione, ma quella coppia di parentesi quadre nota come lambda-introducer, che serve appunto a marcare l’inizio della “funzione senza nome“.

Probabilmente scritta come una “funzione”, l’analogia è più evidente:

[]( *PARAMETERS* )
{ 
	*FUNCTION-BODY*
};

In realtà il lambda introducer è stato scelto perchè consente di specificare il modo di accesso alle variabili esterne, permettendo quindi di ottenere delle funzioni in grado di operare su variabili definite nell’”ambiente circostante” (“closure“, “chiusura” in italiano).

Vediamo rapidamente i vantaggi delle lambda.

1. Funzioni dentro funzioni e closure

Con la sintassi “standard” non è possibile definire delle funzioni dentro altre funzioni, questo perchè il C++ non dispone di first-class function, cioè le funzioni non sono oggetti a differenza di altri linguaggi (questo ovviamente a meno di creare dei functor che sono oggetti a tutti gli effetti).

Le lambda colmano questa “lacuna” (alcuni la percepiscono così): le lambda non solo possono essere definite all’interno di funzioni scritte con la sintassi “canonica” ma possono perfino accedere alle (“catturare”) variabili locali delle funzioni che le contengono.

In questo caso si parla di “closure” e il lambda-introducer permette di definirne l’eventuale accesso selettivo alle variabili esterne.

Un ottimo esempio tratto dal blog del Team di Visual C++:

#include <algorithm>
#include <iostream>
#include <ostream>
#include <vector>

using namespace std;

int main() {

    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(i);
    }

    int sum = 0;
    int product = 1;
    int x = 1;
    int y = 1;

    for_each(v.begin(), v.end(), [=, &sum, &product](int& r) mutable {
        sum += r;
        if (r != 0) {
            product *= r;
        }

        const int old = r;

        r *= x * y;
        x = y;
        y = old;
    });

    for_each(v.begin(), v.end(), [](int n) { cout << n << " "; });
    cout << endl;

    cout << "sum: " << sum << ", product: " << product << endl;
    cout << "x: " << x << ", y: " << y << endl;
}

In questo caso il l’introducer della prima lambda, [=, &sum, &product], mostra le sue potenzialità: due variabili verranno “catturate” e usate by reference (il simbolo “&” denota questo fatto) mentre tutto il resto verrà “catturato” by value (simbolo “=”).

Un introducer vuoto, [], indica invece che la lambda non “catturerà” nessuna variabile esterna.

L’esempio include anche la parola-chiave mutable, che rende “modificabile” la lambda: senza questa keyword, le lambda sono non-mutabili per default, cioè const.

Sempre dal draft:

The closure type for a lambda-expression has a public inline function call operator (13.5.4) whose parameters and return type are described by the lambda-expression’s parameter-declaration-clause and trailing return-type respectively. This function call operator is declared const (9.3.1) if and only if the lambda expression’s parameter-declaration-clause is not followed by mutable.

In altre parole una lambda viene “tradotta” nell’equivalente di un functor il cui operator() è marcato public inline e const.

2. Funzioni-oggetto

Come detto poc’anzi le lambda sono degli “oggetti”, delle funzioni-oggetto scritte in modo particolare.

The evaluation of a lambda-expression results in a prvalue temporary (12.2). This temporary is called the closure object. A lambda-expression shall not appear in an unevaluated operand (Clause 5). [ Note: a closure object behaves like a function object (20.8).—end note ]

Ciò permette di trattare le lambda come dei functor: è possibile salvarle in variabili e perfino usarle come parametri di default!

Sempre dall’ultimo draft:

auto x1 = [](int i){ return i; }; // OK: return type is int

[...]

void f2() 
{
	int i = 1;
	void g1(int = ([i]{ return i; })()); // ill-formed
	void g2(int = ([i]{ return 0; })()); // ill-formed
	void g3(int = ([=]{ return i; })()); // ill-formed
	void g4(int = ([=]{ return 0; })()); // OK
	void g5(int = ([]{ return sizeof i; })()); // OK
}

Nella prima parte dell’esempio, la lambda viene “salvata” in una variabile che poi può essere riusata più avanti con la sintassi di una funzione (es: x1(100);).

Nella seconda parte vengono dichiarate delle funzioni che usano delle lambda come parametri di default (si noti il simbolo “=” ed il lambda-introducer vuoto, usato per indicare che i paremtri verranno passati per copia e non by-reference).

3. Codice più compatto

La possibilità di definire funzioni dove servono è estremamente comoda, soprattutto nel caso di codice che fa abbondante uso di “callback”: se per ogni chiamata f() è necessario specificare la sua apposita funzione “standalone” g(), da passarle come parametro, c’è il rischio di avere miriadi di piccole funzioni create appositamente per quello scopo. Questo tendere a rendere il codice anche più leggibile perchè trovo la “funzione” esattamente dove la dovrei usare e non in separata sede.

4. Possibilità di maggiori ottimizzazioni

Una “lambda” è in pratica una funzione anonima che può essere definita ed usata solo in un punto preciso del codice: in quel caso il compilatore ha quindi molte più informazioni per ottimizzare il codice perchè ha la certezza che la “funzione” sarà invocata solamente una volta in quel punto.

Sempre dall’ultimo draft:

The type of the lambda-expression (which is also the type of the closure object) is a unique, unnamed nonunion class type — called the closure type — whose properties are described below. This class type is not an aggregate (8.5.1).

Codice di esempio

Il seguente codice riprende l’esempio di Wikipedia e mostra alcuni usi delle lambda.

Ho testato il codice sia col G++ 4.5 che con Visual C++ 2010 su Windows.

Spero vi piaccia.

Ciau!

/**
 *	FILE      : LambdaExample.cpp
 *	AUTHOR    : Gian Paolo "JP" Ghilardi (http://rejex.wordpress.com)
 *	LICENSE   : released under the terms of GPL v2.0 ("only")
 *	COMPILE   : g++ -Wall -Winline -pedantic -std=c++0x
 *	            LambdaExample.cpp -o LambdaExample.cpp
 *	PURPOSE   : simple C++0x example showing the new lamba-expression support
 *
 *	TESTED ON :
 *	- Windows XP SP3, x86 32-bit, G++ 4.5.0
 *	- Windows XP SP3, x86 32-bit, Visual C++ 2010
 *
 *	REFERENCES:
 *	[1]: http://en.wikipedia.org/wiki/Lambda_expression
 *  [2]: http://en.wikipedia.org/wiki/C%2B%2B0x#Lambda_functions_and_expressions
 *  [3]: http://en.wikipedia.org/wiki/Closure_%28computer_science%29
 *	[4]: http://gcc.gnu.org/gcc-4.5/cxx0x_status.html
 *	[5]: http://en.wikipedia.org/wiki/C%2B%2B0x#Type_inference
 *	[6]: http://en.wikipedia.org/wiki/C%2B%2B0x#Initializer_lists
 *	[7]: http://en.wikipedia.org/wiki/C%2B%2B0x#Uniform_initialization
 *	[8]: http://www.cplusplus.com/reference/algorithm/for_each/
 */

#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>

using namespace std;

namespace
{
	int gtotal = 0;
	void sum (int x) // used in the first for_each() [8]
	{
		gtotal += x;
	}
}

/**
 * This simple example shows a lamdda expression instead of a "standard" function.
 * That may allow for further compiler optimization as the lambda is a
 * "in place"-defined anonymous function used only in that position.
 *
 * So the new lambda-expression syntax allows for defining "function inside functions",
 * something that's forbidden with the "standard" function syntax.
 *
 * Moreover the example show lambdas "capturing" and using variables from the
 * surrounding environment (by reference) => "closure" [3]
 */
int main(int argc, char ** argv)
{
	cout << "\nC++0x EXAMPLE:" << endl;
	cout << "Simple example showing C++0x lambda functions and expressions" << endl << endl;

    vector<int> v = { 1, 2, 5, 7 }; // [6, 7] (doesn't work in VC2010. Use push_back())

    // 1. without using a lambda (using an external function)
    for_each(v.begin(),       // 1st param
             v.end(),         // 2nd param
             sum              // 3rd param: function
    );
    cout << "1. No lambda: " << gtotal << endl;


    // 2. with a lambda expression
    int ltotal = 0;
    for_each(v.begin(),        // 1st param
             v.end(),          // 2nd param
             [&ltotal](int x)  // 3rd param: lambda
             {
                 ltotal += x;  // capturing variable "ltotal" => "closure" [3]
             }
    );
    cout << "2. With lambda: " << ltotal << endl;


    // 3. with a stored lambda expression
    int ltotal2 = 0;
    auto lambda = [&ltotal2](int x) // stored lambda
		          {
					  ltotal2 += x;   // capturing variable "ltotal2" => "closure" [3]
			      };

	for_each(v.begin(),       // 1st param
			 v.end(),         // 2nd param
			 lambda           // 3rd param: stored lambda
	);
    cout << "3. With stored lambda: " << ltotal2 << endl;


    // 4. with a lambda expression defining variables
    for_each(v.begin(),       // 1st param
			 v.end(),         // 2nd param
             [&v](int x)      // 3rd param: lambda expression
             {
				static int  ltotal3 = 0;    // defining a variable
				static auto it = v.begin(); // defining a variable [5]

                ltotal3 += x;
                if(++it == v.end()) // if we've reached the last item...
                	cout << "4. With lambda defining variables: " << ltotal3 << endl;
             }
	);

    return EXIT_SUCCESS;
}

Il codice in esecuzione