How do I return an std::set with a private comparator

Question

Hi folks,

I'd like to write a (C++) method that returns an std::set of custom objects. I do not however want to expose the comparator used when inserting the objects, so I make it a private class. I create the set like this:

std::set<some_class, some_class_comparator> return_object;

now I want to return the set, so it has to be cast like this (implicitly when returning):

(const std::set<some_class>) return_object;

This is where the compiler complains. Is there a way to cast a mutable set with a comparator to an immutable without?

thanks a lot,

holger

Answer 1

I don't think so. AFAIK std::set<some_class> is just shorthand for std::set<some_class, std::less<some_class> > so the set can't be converted as you want.

I suggest transferring the items into some other data structure (e.g. a vector) that will maintain keep the current items in an order without needing a comparator.

Answer 2

Is there a way to cast a mutable set with a comparator to an immutable without?

No because

std::set<some_class, some_class_comparator>

and

std::set<some_class>

are different, unrelated types entirely. Templates are just that, templates -- a way of specifying how a type is to be generated before compilation. In the second case, the comparator is the default comparer that a std::set would come with.

Is there a compelling reason that some_class_comparotor needs to be private? Could it be its own stand-alone entity? Is it just you don't want to pollute the public interface of your class?

Answer 3

This is two different types std::< Type, Comparator > and std::set< Type, DefaultComparator >.

Answer 4

You want to hide an implementation detail from the caller, that doesn't sound like a template, that sounds like virtual functions. I think first, you need to ask yourself, does this really matter? If so, hide your class behind an IOpaqueSet interface. Of course, then no other STL operations could work on it.

Answer 5

Your best solution is something like this:

class MyClass
{
    class some_class_comparator;
public:
    typedef std::set<int, some_class_comparator> ReturnSet;
    ReturnSet myMethod();
    // ...
private:
    class some_class_comparator
    {
    public:
     bool operator< (MyClass& m) {return true;}
    };
};

//later...
MyClass::ReturnSet s = my_class_instance.myMethod();

Answer 6

The STL comes with a lot of built-in classes, but it's also an extensible framework. If you define your::own::immutable_set, with iterators defined, other STL algorithms can use it. immutable_set<T> would be defined as a thin const wrapper around a mutable std::set<T, comparator<T> > (some template magic required to support different comparators, as they lead to different types). immutable_set<T>::iterator::operator++ would forward to std::set<T>::iterator::operator++, etc.