Dlaczego lambdy mogą być lepiej zoptymalizowane przez kompilator niż zwykłe funkcje?

Powodem jest to, że lambda są obiektami funkcyjnymi , więc przekazanie ich do szablonu funkcji spowoduje utworzenie nowej funkcji specjalnie dla tego obiektu. Kompilator może więc trywialnie wbudować wywołanie lambda.

Dla funkcji, z drugiej strony, stosuje się stare zastrzeżenie: funkcja Wskaźnik jest przekazywana do szablonu funkcji, a Kompilatory tradycyjnie mają wiele problemów z wywołaniem za pomocą wskaźników funkcji. Mogą teoretycznie być inlined, ale tylko wtedy, gdy funkcja otoczenia jest inlined, jak również.

Jako przykład rozważ następujący szablon funkcji:

template <typename Iter, typename F>
void map(Iter begin, Iter end, F f) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}

Nazywając to lambdą w ten sposób:

int a[] = { 1, 2, 3, 4 };
map(begin(a), end(a), [](int n) { return n * 2; });

Wyniki tej instancji (stworzonej przez kompilator):

template <>
void map<int*, _some_lambda_type>(int* begin, int* end, _some_lambda_type f) {
    for (; begin != end; ++begin)
        *begin = f.operator()(*begin);
}

... kompilator zna _some_lambda_type::operator () i potrafi wywoływać do niego trywialnie. (I wywołanie funkcji map z dowolnym innym lambda utworzyłoby nową instancję map ponieważ każda lambda ma odrębną Typ.)

Ale gdy wywołane ze wskaźnikiem funkcji, instancja wygląda następująco:

template <>
void map<int*, int (*)(int)>(int* begin, int* end, int (*f)(int)) {
    for (; begin != end; ++begin)
        *begin = f(*begin);
}

... i tutaj f wskazuje na inny adres dla każdego wywołania do map i dlatego kompilator nie może wywoływać inline do f, chyba że wywołanie otaczające do map zostało również wbudowane tak, że kompilator może rozwiązać f do jednej konkretnej funkcji.