How to overload operator for a set of sets of object

Question

I need to know how to overload the operator = != and < so I could work with set<set<object> >

I have my class:

class pr{
private:
    set<set<e> > pr_;
public:
    pr();
    ~pr();
    void set_pr(set<e> a);
    pr& operator=(const pr& a) const;
    bool operator!=(const pr& a) const;
    bool operator<(const pr& a) const;
};

So if I have a set like this: {{1,2,3},{4,5}} where the numbers are objects.

I would like to do operations with the sets in other class like this:

void otherclass::myfunction(){

    pr prt; //I create the objects
    pr prt_old;

    set<e> C1; //I create the subset and fill
    set<e> C2;
     //C1 and C2 filled here    

    prt.set_pr(C1); //Insert the set<e> into set<set<e>>
    prt.set_pr(C2); //It will fail because i dont know how to compare set<e> < <set<e>

    while(prt != prt_old){
        prt_old = prt ;
        prt = create(prt_old);
    }
    //...

I tried to overload doing this:

 pr& pr::operator=(const pr& a) const{
   this->clear();

   for(set<set<e> >::iterator it =a.begin();it!=a.end();it++){
       for(set<e>::iterator j = it->begin(); j != it->end();j++){
           this->set_pr(*j);
       }
   }

   return *this;
}

bool pr::operator!=(const pr& a) const{
    if(this->size() != a.size()){
        return 1;
    } 

    //Now i don't know how to continue for check if for example
    // i had {{1,2},{3,4}} and {{1},{2}}
    //this two set have same size but they are differnt
    //How could i just iterate through the two sets at same time
    // and check if subset have too same size or if the objects inside the subset are equal

    //Also i need the operator < to insert a set<e> into a set<set<e> > but how??
//Note: class 'e' has already defined the "operator<" for when I insert objects in the set<e>
//And i order them by a function that return an integrer

Answer 1

To test if one set is contained in the other, you iterate over each member of the first set, and test if it exists in the second set.

    bool operator<(const pr& a) const {
        for (auto _set : _data) {
            if (a._data.find(_set) == a._data.end())
                return false;
        }
        return true;
    }

To test if two sets are identical, you test their size is equal, and that one is contained in the other

    bool operator==(const pr& a) const {
        return _data.size() == a._data.size() && *this < a;
    }

But notice that there is no need to define an operator==, because the default one defined by std::set is fine.

Here is a full functioning program:

#include <iostream>
#include <set>
using namespace std;

template <class e>
class pr {
private:
    set<set<e> > _data;
public:
    void insert(set<e> a) { _data.insert(a); }
    bool operator==(const pr& a) const {
        return _data.size() == a._data.size() && *this < a;
    }
    bool operator!=(const pr& a) const { return !(*this == a); }
    bool operator<(const pr& a) const {
        for (auto _set : _data) {
            if (a._data.find(_set) == a._data.end())
                return false;
        }
        return true;
    }
};

int main()
{
    pr<int> a,b,c;

    a.insert(set<int>({ 1 }));
    b.insert(set<int>({ 1 }));
    b.insert(set<int>({ 1, 2 }));
    c.insert(set<int>({ 1, 2 }));
    c.insert(set<int>({ 1 }));

    std::cout << ((a<b) ? "a<b\n" : "NOT a<b\n");
    std::cout << ((b<a) ? "b<a\n" : "NOT b<a\n");
    std::cout << ((a==c) ? "a==c\n" : "NOT a==c\n");
    std::cout << ((b==c) ? "b==c\n" : "NOT b==c\n");
    std::cout << ((a==b) ? "a==b\n" : "NOT a==b\n");
    return 0;
}