C++ function 指针

Question

I'm experimenting with c++ as an excerise. I'm implementing a template class "MioVettore" that implements different reordering algorithms.

I'm implementing ShellSort and I want to be able to tell what kind of numerical series to use. To do that I thought it was a good a idea to assign a different function to a function pointer depending on the option selected by the user.

template <class T>
class MioVettore
{
private :
    std::vector<T> data;

    int SerieKnuth(const int &h) {
        return h * 3 + 1;
    }
    int SerieSequenza(const int& h) {
        return 0;
    }
    int SerieSedgewick(const int& h) {
        return 0;
    }

public:
    MioVettore() {};

    enum SerieType { KNUTH, SEQUENZA, SEDGEWICK };

    void ShellSort(SerieType t) {

        int (*evaluateH) (const int&);

        switch ((int)t)
        {

        case (int)KNUTH:
            evaluateH = SerieKnuth;
            break;

        case (int)SEDGEWICK:
            evaluateH = SerieSedgewick;
            break;

        case (int)SEQUENZA:
            evaluateH = &SerieSequenza;
            break;

        default:
            std::cout << "valore serie non riconosciuto" << std::endl;
            return;
    }

    /* ... */
}

When I try to assign a function to evaluateH I got some errors that I have a hard time understanding, like:

'operator' : illegal operation on bound member function expression
The compiler found a problem with the syntax to create a pointer-to-member.

As I know a function pointer is defined as,

int f(int a) {return a;}

int (*pf) (int) = f;

So I can't understand where is the error.

Answer 1

There are two ways to approach this issue.

1. State that the member variables are static .
2. Say where the function pointers are pointed to (to which class).

For the first option,
When looking at the three functions, we can see that it doesn't do anything/ doesn't have anything to do with the member variables. It performs calculations using the arguments. This means that specifying it as static wouldn't be an issue and this is how it would look like,

template <class T>
class MioVettore
{
private:
    std::vector<T> data;

    static int SerieKnuth(const int& h) {
        return h * 3 + 1;
    }
    static int SerieSequenza(const int& h) {
        return 0;
    }
    static int SerieSedgewick(const int& h) {
        return 0;
    }

public:
    MioVettore() {};

    enum SerieType { KNUTH, SEQUENZA, SEDGEWICK };

    void ShellSort(SerieType t) {

        int (*evaluateH) (const int&);

        switch (t)
        {

        case KNUTH:
            evaluateH = SerieKnuth;
            break;

        case SEDGEWICK:
            evaluateH = SerieSedgewick;
            break;

        case SEQUENZA:
            evaluateH = SerieSequenza;
            break;

        default:
            std::cout << "valore serie non riconosciuto" << std::endl;
            return;
        }

        /* ... */
    }
};

For the second option,
We can specify where to take the function pointer from, or in other words, which class contains the function pointers. This is how you can implement this.

template <class T>
class MioVettore
{
private:
    std::vector<T> data;

    int SerieKnuth(const int& h) {
        return h * 3 + 1;
    }
    int SerieSequenza(const int& h) {
        return 0;
    }
    int SerieSedgewick(const int& h) {
        return 0;
    }

public:
    MioVettore() {};

    enum SerieType { KNUTH, SEQUENZA, SEDGEWICK };

    void ShellSort(SerieType t) {

        int (MioVettore<T>::*evaluateH) (const int&);

        switch (t)
        {

        case KNUTH:
            evaluateH = &MioVettore<T>::SerieKnuth;
            break;

        case SEDGEWICK:
            evaluateH = &MioVettore<T>::SerieSedgewick;
            break;

        case SEQUENZA:
            evaluateH = &MioVettore<T>::SerieSequenza;
            break;

        default:
            std::cout << "valore serie non riconosciuto" << std::endl;
            return;
        }

        // This is how to call it.
        (this->*(evaluateH))(1);

        /* ... */
    }
};

This advantage of using this over the other is that we can access member variables from the member functions which we cant do if we specify the functions as static .

Note: You don't have to say (int)t and (int)SEDGEWICK in the switch and case statements as the compiler does that implicitly. enum s are basically integer constants which has a name to make it easier for developers to group them.