如何从构造函数传递给作为成员函数的谓词

Question

I have the following code :

template <class T>
class GenericGeneticSolver
{
public:
    GenericGeneticSolver(IGenticSolverHelper<T>& helper, int generationSize) : mSolverHelper(helper), mGenerationSize(generationSize)
    {
        mCurrentGeneration.resize(mGenerationSize);
        for(int i=0;i<mGenerationSize;i++)
        {
            mSolverHelper.GenerateRandomSolution(mCurrentGeneration[i]);
        }

        sort(mCurrentGeneration.begin(),mCurrentGeneration.end(), solutionComparer);
    }
    void Evolve(int numberOfGenerations = 1)
    {
        //sort(mCurrentGeneration.begin(),mCurrentGeneration.end(), solutionComparer);
    }
private :
    int mGenerationSize;
    vector<T> mCurrentGeneration;
    IGenticSolverHelper<T>& mSolverHelper;

    bool solutionComparer (T first,T second) { return (mSolverHelper.Cost(first)<mSolverHelper.Cost(second)); }
};

In the constructor I'm filling a vector with members, and then I'm trying to sort this vector by passing a predicate to the Sort function, the predicate is a member function called `solutionComparer.

Unfortunately it does not compile, the compiler is not happy with using pointer to member functions in the constructor, i tried the same line in the "Evolve" function, and it does compile.

The error i get is :

error C3867: 'GenericGeneticSolver<T>::solutionComparer': function call missing argument list; use '&GenericGeneticSolver<T>::solutionComparer' to create a pointer to member

I tried to do what the error suggested but it didn't compile either (some random error in the sort function).

Why can't i use pointer to a member function in the constructor ?

Answer 1

std::sort requires a comparator which can simply be called as compare(a,b) . A (pointer to a) member function isn't suitable, since it requires an object to be called on, so you'll need a wrapper to bind the member function to an object and make it callable with just the two values to compare.

In C++11, you can bind a member function to an object:

sort(mCurrentGeneration.begin(),mCurrentGeneration.end(),
    std::bind(&GenericGeneticSolver::solutionComparer, this, 
         std::placeholders::_1, std::placeholders::_2));

or you can use a lambda:

sort(mCurrentGeneration.begin(),mCurrentGeneration.end(),
    [this](T first,T second) { return solutionComparer(first, second); });

Historically, you would have to make your own functor, perhaps along the lines of:

struct SolutionComparer {
    IGenticSolverHelper<T>* helper;

    SolutionComparer(IGenticSolverHelper<T>& helper) : helper(&helper) {}

    bool operator()(T first,T second) {
        return helper->Cost(first) < helper->Cost(second);
    }
};

sort(mCurrentGeneration.begin(),mCurrentGeneration.end(),
    SolutionComparer(mSolverHelper));

Answer 2

使用c ++ 11，这将工作：

std::sort( mCurrentGeneration.begin(), mCurrentGeneration.end(), std::bind( &GenericGeneticSolver< T >::solutionComparer, this, std::placeholders::_1, std::placeholders::_2 ) );

Answer 3

The answer from @Mike-Seymour shows how to make your program work. But it seems you are interested to understand why a member function does not work.

As the terminology indicates a "member" function is different from a free function. Member functions are associated with an object. While a member function is executing there is a "this" pointer available. The "this" pointer refers to the instance of the object associated with the member function.

The this pointer is used to access the member variables while executing the member function. For example, the solutionComparer function refers to the member variable mSolverHelper . Accessing mSolverHelper is a convenience to the programmer in reality, the compiler is executing this->mSolverHelper .

The this pointer is provided to the member function as an extra parameter that is not shown or indicated to the programmer. The signature for bool solutionComparer (T first,T second) is really understood by the compiler to be bool solutionComparer (GenericGeneticSolver* this, T first,T second) .

Therefore when a member function is called an object is also required. For example: MySolver->solutionComparer(…).

The comparator function signature to the sort function does not understand how to apply an object to the member function. The comparator function requires a free function (or it's moral equivalent). You'll notice that all of the solutions offered provide an object in order to call solutionComparer .

A second question occurs: why does the call to sort, compile if the sort function is called in a member function. The answer is it doesn't really compile and is related to template instantiation.

Template instantiate is lazy. The compiler will only compile the enough of a template class that is required. I believe this has to do with SFINAE . Your test program likely instantiates an instance of the class. eg GenericGeneticSolver solver. This causes the compiler to compile GenericGeneticSolver but only enough of the class is compiled to satisfy the linker. That is the constructor.

If you add a call to Evolve() then the compiler will also fail:

GenericGeneticSolver<MyType> solver;
solver.Evolve();

The description of SFINAE should help to describe how and why the compiler works in this fashion.

All of these machinations are meant to be hidden from you, as you typically don't need to know. However, in cases like this it is useful to understand the underpinnings of the language and compiler in order to understand how to solve the problem.