working together with operator overloading and inheritance.

base and derive classes are overloading operator '=' .
Now I instantiate two objects of derive class and copy one object into other.
'=' operator for derived class gets invoked. I am expecting both base and derive class '=' should get executed.
any solution?

Please check the code snippet

Code:

---

#include<iostream>

using namespace std;



/*overload operator in base class and for derived class */



class base
{
public:
  base& operator = (base& obj)
  {
      cout<<endl<<"In base = operator"<<endl; 
      return *this;
  }

};


class derive : public base
{
public:
        derive& operator = (derive& obj)
        {
          cout<<endl<<"In derive = operator"<<endl;
          return *this;
        }

};


void main()
{
    derive obj1, obj2;
    obj1 = obj2;
}

---

o/p

In derive = operator

-------------------------------------------------------------------
expected o/p

In base = operator

In derive = operator

explicitly call the operator .

Code:

---

derive& derive::operator=(derive& rhs)
{
    base::operator=(rhs);
    cout<<endl<<"In derive = operator"<<endl;
    return *this;
}

---

Both base and derive class using default '=' implementation then base '=' implementation will not get invoked in above code.

So is it a thumb rule to overload derive class '=' to make sure we explicitly call base class '=' operator ?


Thanks
Ketan

No, it is not. The default assignment operator will always work.

yes, the only reason it wasn't being invoked was because you declared it, but did not call it.

as a rule of thumb, i'd say that to the greatest extent possible, each type should handle it's own members (i.e. not touch those higher in the hierarchy). this is just my personal preference. i try to write so that default assignment & copy-construction work as desired.

Thanks m37h0d and Elysia!

I made some changes in above code(just to check behavior).
changes are 1. base class is using default '=' operator.
2. derive class is using overloaded '=' operator.

Code:

---

 
 class base
{
  public:
  int b;
  base(int i ):b(i) {}
  /*base& operator = (base& obj)
  {
      cout<<endl<<"In base = operator"<<endl; 
      return *this;
  }*/

};


class derive : public base
{
public:
        int d;
        derive(int j, int k):d(j),base(k){}
        derive& operator = (derive& obj)
        {
          base::operator = (obj);
          cout<<endl<<"In derive = operator"<<endl;
          d = obj.d;
          return *this;
        }
       
};


void main()
{
  derive obj1(10,20), obj2(30,40);
  obj1 = obj2;
 }

---

Now if I dont add undelined code statement base class default = implementation is not invoked. I think while overloading derive class = one need to make sure he calls base::operator = (base&)

Thanks,
Ketan

Since you are overloading an operator, it is the same as calling an overloaded function. That is, only the derived's instance of the function will be called.
So if you want to invoke the default copying behavior of base, then yes, you must call base's assignment operator explicitly. Otherwise you have to code the assignment of any inherited variables, too.

Also, void main shall be int main.