How to use a std::set as a data member with an explicit comparator member function?

Question

I am using C++17.

std::set is a template type:

template<
    class Key,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<Key>
> class set;

One can have a std::set as a data member. For example:

#include <set>

class Foo
{
    std::set<size_t> someSet_;
};

One can also explicitly specify the comparison function. For example:

#include <set>

auto compare = [](size_t index1, size_t index2) {
    return index1 < index2;
};

class Foo
{
public:
    Foo() : someSet_(compare)
    {
    }

private:
    std::set<size_t, decltype(compare)> someSet_;
};

Now, suppose that the comparison function is a member function. For example:

#include <set>
#include <vector>

class Foo
{
public:
    Foo() : someSet_(compare) // does not compile
    {
    }

private:
    bool compare(size_t index1, size_t index2) const
    {
        return someVector_[index1] < someVector_[index2];
    }

    std::vector<int> someVector_;
    std::set<size_t, decltype(compare)> someSet_; // does not compile
};

As commented, this last code does not compile.

How could someSet_ be declared and initialized to use Foo::compare()?

When the function is a member of the class, the set would need an object to call the function with. When you make the function static it should work. — Zaiborg, Jan 19 '23 at 07:43
Is that because the function is defined after you have used it? Try defining before. — Andrew Truckle, Jan 19 '23 at 07:43
@Zaiborg If `Foo::compare()` were static, it could not access the data member `someVector_`, which is what I want to do. — user1387866, Jan 19 '23 at 07:48
This construction is probably not a good idea, since modifying `someVector_` would change the ordering relation and lead to undefined behaviour. — molbdnilo, Jan 19 '23 at 08:22

sklott · Accepted Answer · 2023-01-19T12:03:09.460

If you look at errors generated by compiler, you will see, that compare can't be non-static function. So, usually you do static function. But in your case you need access to member variable, in this case its better to create helper comparator object. For example, like this:

#include <set>
#include <vector>

class Foo
{
public:
    Foo()
    {
    }

private:
    struct comparator {
        comparator(const Foo& foo) : foo_(foo) {}
        bool operator()(size_t index1, size_t index2) const
        {
            return foo_.someVector_[index1] < foo_.someVector_[index2];
        }
    private:
        const Foo& foo_;
    };

    std::vector<int> someVector_;
    comparator comp_{*this};
    std::set<size_t, comparator> someSet_{comp_};
};

PS: But in this case you need to define or delete copy/move constructors and assignment operators, since default will incorrectly copy such comparator.

`friend comparator;` is redundant. Member classes already have access. — StoryTeller - Unslander Monica, Jan 19 '23 at 08:55

score 2 · Answer 2 · answered Jan 19 '23 at 09:32

2

The only reason why you would want the comparator to be a member function is when it generates different results depending on the state of the object it's a member of. But that's wrong, the results of the comparator should not change because then the set you're using suddenly has a wrong ordering, and that's not good. For that reason, make sure your comparator is an entirely separate object that has its own state and does not change that state while its in use.

answered Jan 19 '23 at 09:32

Aykhan Hagverdili

28,141
6
41
93

Of course the contents of `someVector_` and `someSet_` must be synchronized, otherwise things go crazy. For example, when the value of `someVector_[index]` is to be changed, we (1) remove `index` from `someSet_` (2) update `someVector_[index]` (3) insert `index` back to `someSet_`. – user1387866 Jan 20 '23 at 09:11

How to use a std::set as a data member with an explicit comparator member function?

2 Answers2