Store functions in classes

If I understand the statement well, the exercise consists of a class that, given a function, shows it in n steps in a closed interval between a and b , for this it is necessary:

  

A constructor that is passed as a parameter a function y=f(x) , a interval [a,b] , and the number of samples n .

So, you will need to pass a function that returns a value and receives a value, assuming that both the return and the parameter are of double , we are talking about functions that have the same signature as this:

double funcion(double parametro) {
    double resultado;

    // hacer cosas...

    return resultado;
}

With parametro the value of x and the return of funcion the value of y .

Function pointers.

C ++ is a strong typing language and static , this implies (among other things) that everything (including functions) has an underlying type, the types of C ++ functions follow the following format: retorno([parámetros...]) , so the type of a function that receives a double and returns a double would be double(double) .

Once we know the type we want to work with, we can use it as a parameter, this is an example of an object that has a function:

struct funcion
{
    // Tipo de la funcion que recibe y devuelve double
    using tipo_funcion = double(double);

    // El constructor recibe una funcion que recibe y devuelve double
    funcion(tipo_funcion *parametro) :
        miembro{parametro}
    {}

    // El miembro almacena una funcion que recibe y devuelve double
    tipo_funcion *miembro;
};

You can use it like this 1 :

int main()
{
    // Instancia que recibe la funcion coseno
    funcion f(std::cos);

    // Muestra 1 ya que es el valor de coseno de 0.
    std::cout << f.miembro(.0);

    return 0;
}

Function object .

As an alternative to the function pointer, a function object can be used:

struct funcion
{
    // El constructor recibe un OBJETO FUNCION que recibe y devuelve double
    funcion(std::function<double(double)> parametro) :
        miembro{parametro}
    {}

    // El miembro es un OBJETO FUNCION que recibe y devuelve double
    std::function<double(double)> miembro;
};

The advantage of the function object with respect to the function pointer is that it can store lambdas and < a href="https://es.wikipedia.org/wiki/Funtor"> functors , which the pointer to function 2 can not do, can be used like this:

int main()
{
    struct funtor
    {
        double operator()(double d) { return d+d; }
    };

    funcion f([](double d){return d*d;});
    funcion g(funtor{});

    // Muestra .25 (.5 al cuadrado de la lambda) y 1 (el doble de .5 del funtor)
    std::cout << f.miembro(.5) << ' ' << g.miembro(.5);

    return 0;
}

Your case.

To finish complying with the statement, you will need three additional parameters (two for the interval and one for the sampling):

struct funcion
{
    funcion(std::function<double(double)> parametro, double inicio, double fin, double muestras) :
        miembro{parametro}
    {
        const double rango = fin - inicio;
        const double paso = rango / muestras;

        for (double a = inicio; a <= fin; a+= paso)
            muestreo.push_back(miembro(a));
    }

    std::function<double(double)> miembro;
    std::vector<double> muestreo{};
};

You can see the code working in [Wandbox] 三 へ (へ ਊ) へ ハ ッ ハ ッ .

1 Function passed but pointer stored, functions have implicit conversion to pointer-to-function.

2 If (and only if) the lambda does not capture values, it can be stored in pointer-to-function.