绑定返回的C ++函子的类型

Question

I'm currently programming a chess program in C++. The algorithm for searching is alphaBeta, that's why I sort the moves before going through them and evaluating them. My main class is the class Position, that does all the searching and also contains a function to compare two Moves.

class Position{

    private:
    //This vector holds the moves of the current line, to be evaluated

    vector<Move> currentSearch(4000);

    // This function uses internal fields of class Position to determine, whether move1 or move2 should be searched first

    bool compare(const Move& move1, const Move& move2);

    int alphaBeta(int ply, int depth, int alpha, int beta);

}

Now to sort the moves in currentSearch, I always call in alphaBeta

sort(currentSearch.begin(), currentSearch.end(), bind(mem_fn(&Position::compare),this,_1,_2));

So this generating of a functor with bind(mem_fn(&Position::compare),this,_1,_2)); is done several times inside one search to generate the same functor.

I would like to have a member of class Position that is initialized to bind(mem_fn(&Position::compare),this,_1,_2)); But what type that member must have, or what is the correct way to design this?

Answer 1

I guess you are using c++11 because std::bind is not available in previous editions.

From http://en.cppreference.com/w/cpp/utility/functional/bind :

template< class F, class... Args >
/*unspecified*/ bind( F&& f, Args&&... args );

Obviously the standard committee does not want to hard code the implementation details into the standard.

So if you really need to store the functor somewhere, the best choice is write your own functor class instead of using lambda or std::bind . The second best choice is to use a std::function . It can store any function like things with compatible signature, but with the overhead of runtime indirection, which you probably do not want here.

Or you can just copy and paste the same lines, or use auto if the functor is reused inside the same function.

By the way, there is no need for mem_fun when you use std::bind .

Answer 2

From my experience with boost.bind (which std bind is based on), there's not much point in capturing the results ahead of time. As noted above the type is rather odd and only exists during compile time.

And that's part of the point. Most of the work behind bind is done at compile time. The initialization of the class is trivial as is the function calling when using bind.

From my experience, the magic of bind is done with templates at compile time.