Rule of three and inheritance

Question

class A defines copy operator, destructor and operator=. (Rule of Three)

If B inherits from A:

• the destructor will be called automatically
• I need to chain the constructor
• operator= ... should I define it explicitly for the class B?

Answer 1

No, it's unnecessary.

If you read carefully the Rule of Three, you will notice that nothing is said about a base class, the decision is made solely on the class proper attributes and behavior.

(Check this example on ideone)

#include <iostream>

struct A {
  A(): a(0) {}
  A& operator=(A const& rhs) { a = rhs.a; return *this; }
  int a;
};

struct B: A { B(): b(0) {} int b; };

int main() {
  B foo;
  foo.a = 1;
  foo.b = 2;

  B bar;
  bar = foo;

  std::cout << bar.a << " " << bar.b << "\n";
}

// Output: 1 2

This is actually the true power of encapsulation. Because you succeeded, using the Rule of Three, in making the behavior of the base class sane, its derived classes need not know whether the copy constructor is defaulted by the compiler or implemented manually (and complicated), all that matters for a user (and a derived class is a user), is that the copy constructor performs the copy.

The Rule of Three reminds us of an implementation detail to help achieve correct semantics. Like all implementation details, it matters only to the implementer and maintainer of this class.

Answer 2

Same Rule of Three applies to the derived class as well.
The Rule is applicable to all classes and you can apply it to each class down an Inheritance hierarchy same as you apply it to a single class.

If your class B needs any of the two(Copy Constructor & Destructor) of the Big Three then you need to define the copy assignment operator as well.

So it actually depends on the members of the Derived class & the behavior you want for your Derived class objects.

For example:
If the derived class members consists of any pointer members and you need deep copies then as per the Rule of Three your derived class needs to overload and provide own implementations for the Big Three.