派生类的运算符重载

Question

I have a base container class, which has a number of operators (=,+,-,+=,etc). It is expected that the logic of the operators will not need to be changed for the derived classes. Thus, ideally, I would like to use the base class operators for all of its derived classes without having to redefine them for each of the derived classes explicitly (with the exception of the assignment operator).

A solution that I came up with is demonstrated below based on a simple example. The solution seems to work, but I have doubts about the validity of the method for more complicated cases. Do you think it is valid to use this assignment "hack" in class B? What are the potential pitfalls of this method? Is there anything I missed? Are there easier ways of achieving the functionality that I need (ie using base class operators for derived classes)?

class A
{
 protected:
 int a;
 public:
 A(int ca)
 {
  a=ca;
 }
 A(const A& A1)
 {
  a=A1.a;
 }

 int geta() const
 {
  return a;
 } 
 void seta(int ca)
 {
  a=ca;
 }  
 const A& operator=(const A& A1)
 {
  a=A1.a;
  return *this;
 }

};

const A operator+(const A& A1, const A& A2)
{
 A myA(A1.geta()+A2.geta());
 return myA;
}

class B: public A
{
 public:
 B(int a): A(a) {}// ... using A::A;
 const B& operator=(const B& B1)
 {
  a=B1.geta();
  return *this;
 }
 const B& operator=(const A& B1)
 {
  a=B1.geta();
  return *this;
 }

};

int main()
{

 B myB(4);
 A myA(3);

 //need this to work
 myB=myB+myB;
 cout << myB.geta();
 myA=myA+myA;
 cout << myA.geta();

 int j;
 cin >>  j; 

}

Answer 1

For the example given i don't see any problems that can happen. Of cause you can improve the code, first by returning non const reference in operator=, second i think by adding += op to your class, and using it's code inside global operator+ function.

But in general i think it should work fine. As for assignment operators - as soon as you have only POD types and no pointers, or references or handles you don't really need any. It will become more complicated, however when pointers appear. You'll need to make sure you copy objects, pointed by them, or manage them some other way.

And you probably will not need to modify your operators as long as you don't add more members to derived classes, which also should take part in calculations.

Answer 2

In general you don't have to redefine functions in the base class for derived classes. With public inheritance your derived classes will have access to those functions and use their operation just fine. If you do want to re-define them (= operator for example), be sure you call the right one (virtual functions help in this case).