function<double(double)> derivative(function<double(double)> f, double dx) {
  return [=](double x) -> double {
    return (f(x + dx) - f(x)) / dx;
  }
}

ГВ>function<double(double)> derivative(function<double(double)> f, double dx) {
ГВ>  return [=](double x) -> double {
ГВ>    return (f(x + dx) - f(x)) / dx;
ГВ>  }
ГВ>}

class LambdaFunctor {
public:
    LambdaFunctor(function<double(double)> f, double dx) : m_f(f), m_dx(dx) { }
    double operator()(double x) const { return m_f(x + m_dx) - m_f(x)/m_dx; }
private:
    function<double(double)> m_f;
    double m_dx;
};

function<double(double)> derivative(function<double(double)> f, double dx) {
  return LambdaFunctor(f, dx);
  }
}

Lambda Function Object

The compiler creates an anonymous function object upon evaluating a lambda expression.
This function object, created by a lambda expression, may live longer than the block in which it is created. You must ensure that it does not use variables that were destroyed before the function object is used.
The following example shows how a function object created by a lambda expression can outlive the function that creates it.

struct Base {
    virtual bool test(int x) = 0;
};
template<typename F>
struct Derived: Base {
    F f;
    bool test(int x) {return f(x);}
    Derived(F f_) : f(f_) {}
};
template<typename F>
Base* MakeDerived( F f ) {
    return new Derived<F>(f);
}
Base* Foo( int k ) {
    return MakeDerived( [k](int x) {return x%k==3;} );
}
bool Bar() {
    Base* b = Foo(3);
    return b->test(6);
}

In the above example, Bar invokes Foo, which copies the function object generated by a lambda expression into an instance of template class Derived. The lambda expression refers to a local variable k. Although the code destroys k before using the copied function object, the code is safe because k was captured by copy.