Re: operator==

Below is a version of your example that compiles. The reason it
didn't compile was because you were trying to use operator==(const
Interface&) before it was declared.

The code below does not exhibit the problem you are having with your
actual code. That should tell you that the Base::op==(const Base&)
function is not where your problem lies.

Chances are that somewhere in your code (not shown to us so far,)
you are putting an object into the vector, then destroying it
without removing it from the vector. Although, your problem could be
more pernicious than that.

class Interface;

class Base {
protected:
    std::vector<Interface*> fields;
    virtual bool operator==(const Base& other);
public:
    Base();
};

class Interface {
public:
    Interface();
    // just an example, should be overloaded of course
    virtual bool operator==(const Interface& other) { return false; }
};

bool Base::operator==(const Base& other) {
   for (size_t i=0; i < fields.size(); ++i)
      if (! ((*fields[i]) == (*other.fields[i])))
         return false;
   return true;
}

class Ext : public Base {
private:
    Interface x;
    Interface y;
    
public:
    Ext() {
        fields.push_back(&x);
        fields.push_back(&y);
    }
};

int main() {
}

There are also problems with the above conceptually. For example:

class Derived1 : public Interface {
   bool operator==(const Interface&);
}

class Derived2 : public Interface {
   bool operator==(const Interface&);
};

int main() {
   Derived1 d1;
   Derived2 d2;
   Interface* i1 = &d1;
   Interface* i2 = &d2;
   *i1 == *i2; // this will call a different function than
   *i2 == *i1; // this.
}

All of your op==(const Interface&) functions will have invariants
tying them together, but they are in different classes. This is not
a good thing. My guess is, that at a minimum, you want the base
class op== to ensure that the two objects passed in are of the same
type, returning true if they are, false otherwise. Then each derived
class will need to call it's base op== and only do it's own checks
if the base's op== returns true.