Thread: Signature of function accepting functor as argument?

If I had a template class that contained lists of type <T>, what would the function's signature look like to pass functor objects that provide the sort semantics for the list?

Code:

void add_sort( // ?

}

to then be later called just like sorting any other list

Code:

// ...

private_list.sort(previously_defined_functor);

What would add_sort() do?

Originally Posted by C_ntua

What would add_sort() do?

sorry, I want add_sort() to *store* the function pointer to be called at a later time.

hmm... when you say "functor objects that provide the sort semantics", you are talking about functions that sort, rather than predicates used in a sort?

Originally Posted by laserlight

hmm... when you say "functor objects that provide the sort semantics", you are talking about functions that sort, rather than predicates used in a sort?

I'm not sure. Functional programming in C++ is not one of my strengths, I'm admittedly intimidated by the syntax.

Here's an example of what I'd like the end result to look like:

Code:

struct Custom_sort{

    bool operator()(const foo& a, const foo& b){
        return a.bar < b.bar;
    }
} custom_sort;

int main(){

    Custom_container<foo> foos;
    foos.add_sort(custom_sort);
}

where Custom_container<T> is my template container.

EDIT: It's important that custom_sort not be called until needed by the Custom_container<T>. add_sort() just defines how one of the std::list<T> will be sorted, when it actually needs to be sorted.

Ah, then you are actually talking about a predicate. You can do something similiar to what std::set does:

• The predicate type is a template parameter.
• The predicate can be provided in a template constructor.
• Otherwise, the predicate defaults to std::less<T>.

You can then store the predicate as a member.

So what's the advantage of using predicates over something like:

Code:

std::list<T> the_list;

typedef bool (*list_sort)(T,T);
std::list<list_sort> sort_routines;

// ...

void add_sort(bool (*ls)(T,T)){ sort_routines.push_back(ls); }

// ...

the_list.sort(*sort_routines[i]);

what added functionality do they give you?

Is the added benefit simply that functor objects can hold state?

It seems like in many situations, you could just code around the limitations of mere functions, to avoid functor objects, which are clearly more difficult to code! for me anyway!

Why not just let your class/function take a template parameter? Ie

Code:

template<typename T>
class myclass
{
...
T& stored_cmp_obj;
};

So long as the type supports your operators and functions, all works out fine. It needn't be more difficult.
Though I am a little unsure of what exactly you are after, but I this is the principle you're after.

So, just add them the way you do.

Code:

template<typename T> 
void Custom_container::add_sort(bool (*ls)(T,T))
{ 
    sort_routines.push_back(ls);
    activeSort = ls;
}
...
the_list.sort(*sort_routines[i]);

Or maybe you want to sort a list with the selected routine, something like:

Code:

template<typename T> 
void Custom_container::select_sort(int index)
{ 
    //some checks
    activeSort = sort_routines[index];
}
...
myContainer.mySort(...);

which can call sort with activeSort as a parameter for the given list you want. Except if I am missing something...

I would simply shorten it down to

Code:

template<typename T> 
void Custom_container::add_sort(T ls)
{ 
    sort_routines.push_back(ls);
    ActiveSort = ls;
}
...
the_list.sort(sort_routines[i]);

If T fails to have, say, operator (), it fails to compile. Simple.