C ++从循环中的向量中删除元素

Question

I am trying to implement Set Class in C ++ (on Home exercise). I would like overloading operator - = for sets subtraction. Some times function return good result, but sometimes digits from set s2 are in set s1. Moreover, if you could check out the copy constructor? And tell me and tell me if it should be like this using vectors in Class. And if in Class i have vector, i have to write something in destructor? Thank You for Help! (vector is public for tests)

My code is:

#include <ctime>
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <vector>
using namespace std;

class Set
{
    int n;

public:
    vector <int> set;
    Set(int n)
    {
        for(int i=0; i<n; i++)
        {
            set.push_back(rand()%11);
        }
        this->n = set.size();
        remove_duplicates();
    }
    Set(const Set& obj)
    {
        n=obj.n;
        set.clear();
        for(int i=0; i<n; i++)
        {
            set.push_back(obj.set[i]);
        }
    }
    Set& operator-=(const Set& obj)
    {
        for(auto it = set.begin(); it !=set.end(); it++)
        {
            for(int j=0; j<obj.set.size(); j++)
            {
                if(set[*it]==set[j])
                {
                    it = set.erase(it);
                }
            }
        }
        return * this;
    }
    void remove_duplicates()
    {
        sort( set.begin(), set.end() );
        set.erase( unique( set.begin(), set.end() ), set.end() );
        n = set.size();
    }
    void print()
    {
        for(int i=0; i<set.size(); i++)
        {
            cout << set[i] << " ";
        }
        cout << endl;
    }
};

int main()
{
    srand(time(nullptr));
    Set s1(5);
    Set s2(5);
    s1.print();
    s2.print();
    cout << endl;
    s1-=s2;
    s1.print();
}

example result;

2 3 6 7 9
1 3 7 9

6 7 9

and good result

1 3 5 6 7
2 4 9 10

5 6 7

Answer 1

The loop in operator-= is implemented wrong.

You are incrementing the it iteration on all loop iterations unconditionally, even on iterations that are erase() 'ing elements, thus you end up skipping elements.

Also, you are using the element values of the target vector as indexes into that vector , which is wrong. And though you are looping through the source vector , you are not actually indexing into that vector 's elements at all.

Try this instead:

Set& operator-=(const Set& obj)
{
    auto it = set.begin();
    while (it != set.end())
    {
        bool erased = false;
        for(int value : obj.set)
        {
            if (*it == value)
            {
                it = set.erase(it);
                erased = true;
                break;
            }
        }
        if (!erased)
            ++it;
    }
    return *this;
}

Which can then be simplified using std::find() , eg:

Set& operator-=(const Set& obj)
{
    auto it = set.begin();
    while (it != set.end())
    {
        if (std::find(obj.set.begin(), obj.set.end(), *it) != obj.set.end())
            it = set.erase(it);
        else
            ++it;
    }
    return *this;
}

Alternatively:

Set& operator-=(const Set& obj)
{
    for(int value : obj.set)
    {
        auto found = std::find(set.begin(), set.end(), value);
        if (found != set.end())
            set.erase(found);
    }
    return *this;
}

Or, you can use std::remove_if() instead, eg:

Set& operator-=(const Set& obj)
{
    set.erase(
        std::remove_if(
            set.begin(), set.end(),
            [&](int value){
                return std::find(obj.set.begin(), obj.set.end(), value) != obj.set.end();
            }
        ),
        set.end()
    );
    return *this;
}

---

Also, your n class member is unused outside of your constructors, so it should not be in the class at all. You already know that you can use set.size() where needed.

Also, your copy constructor can be greatly simplified by using vector 's copy constructor, in which case you can actually eliminate your copy constructor altogether and let the compiler auto-generate it for you.