Question

My problem is this, I have a base class from which classes are derived. I have an overloaded += operator in the base class but I only want to be able to add derived classes of the same type. I do this by returning the lhs and producing a warning message if they are not the same type.

class base{
   int variable;
   public:
   base(int v);
   base & operator+=(const base & rhs);

class a: public base{
}

class b: public base{
}

base & operator+=(const base & rhs){
if(type_same(const & rhs){
    variable+=rhs.variable; }
return *this
}

a first(1);
a second(5);
b third(2);

first+=second // first.variable now =6
second+=third // warning produced second.variable still = 5

I’ve never used dynamic cast before so my question is is it possible/advisable to a check using it and typeid to find out whether the types passed are the same. My alternative is a string constant name for each derived class.

Answer 1

My take: you could employ CRTP

The below code will issue the type mismatch error at compile time, as suggested by others.

template <typename Derived>
class base{
   int variable;
 public:
   base(int v) { variable = v; }
   Derived& operator+=(const Derived& rhs);
};

struct a: base<a> {
    a(int v): base<a>(v) {}
};

struct b: base<b> {
    b(int v): base<b>(v) {}
};

template <typename Derived> 
Derived& base<Derived>::operator+=(const Derived& rhs) 
{
    variable += rhs.variable; 
    return static_cast<Derived&>(*this);
}

int main(int argc, const char *argv[])
{
    a a1(1), a2(2);
    b b1(1), b2(2);

    a1 += a2;
    b1 += a2; // compile time error :)

    return 0;
}

Even if you really wanted to type the operator arguments as base& you’d at least gain the benefit of using static_cast<> because the conversion is exact and well defined at runtime. I can expand the idea in a few