Lambda kifejezések
A C++ bevezeti a név nélküli függvényeket a következő szintaxissal:
[](int x, int y) { return x + y; }
Látható, hogy visszatérési érték típusát sehol nem adtuk meg. Ebben az esetben azért, mert egyértelmű. A visszatérési értéket nem kötelező megadni, ha az a függvény törzsében található return kifejezés típusából kikövetkeztethető. Ha nincs visszaadott érték, a visszatérési típus void lesz.
A lambda kifejezések fel tudják használni a definíciójuk helyén látható változókat is. Ezeket a [] jelek között sorolhatjuk fel. A paraméter-átadás érték szerinti, hacsak nem jelöljük & jellel:
std::vector<int> someList;
int total = 0;
std::for_each(someList.begin(), someList.end(), [&total](int x) {
total += x
});
std::cout << total;
A fenti példa kiírja a tömbben található értékek összegét. A környezetből átvett változókat sem muszáj felsorolni (kivétel a this, amelyet explicit át kell adni), ha megadjuk az alapértelmezett paraméter-átadási módot: [&] a referencia szerinti, [=] az érték szerinti. Ezt felülbírálhatjuk, ha a változót explicit kiírjuk. Pl: [&, value] illetve [=, &ref]. Ekkor a value érték szerint, a ref referencia szerint adódik át.
std::vector<int> someList;
int total = 0;
std::for_each(someList.begin(), someList.end(), [&](int x) {
total += x
});
std::cout << total;
Ha ilyen lambda kifejezést eltárolunk, és nem a definiálás helyén hívjuk meg, a viselkedés definiálatlan.
Suffix return-type szintaxis
A C++-ban a template függvények visszatérési értékének megadása sokszor problémás: Azt szeretnénk kifejezni, hogy a visszatérési érték függ a többi típusparamétertől, de azokkal nem feltétlenül egyezik meg. Egyetlen lehetőség, hogy egy újabb típusparaméterként a ezt is megadjuk:
template<typename Ret, typename LHS, typename RHS>
Ret AddingFunc(const LHS &lhs, const RHS &rhs) { return lhs + rhs; }
A C++ új függvény szintaxist vezet be, amelyben használható a decltype kulcsszó is a visszatérési érték kiszámítására:
template<typename LHS, typename RHS>
auto AddingFunc(const LHS &lhs, const RHS &rhs) -> decltype(lhs+rhs)
{ return lhs + rhs; }
Az új szintaxist természetesen nem csak sablonokban használhatjuk:
struct SomeStruct
{
auto FuncName(int x, int y) -> int;
};
auto SomeStruct::FuncName(int x, int y) -> int
{
return x + y;
}