Subclassing, assignment operator and copy constructor

Question

I have a bunch of questions related to this, I couldn't find exact answers. Class A is the main class, and B is a subclass

1. If A::operator=(const A & other) was defined, does the default implementation of B::operator= copies members of B then calls A::operator= ?

2. If A copy constructor was defined, does the default implementation of the copy constructor for B copy-constructs members of B, then calls A copy constructor?

3. Do I need to define above functions virtual in A to get this behavior? (I suppose yes for operator= and no for the copy constructor, as virtual constructors is a nonsense?)

4. Can I forbid overloading the assignment operator or the copy constructor for subclasses of A, to force the use of default implementations?

The idea behind this, being to offer a plugin API for my users. I need the API to be C++ as scripts are too slow (I'll try JIT compilation one day), but it should be very simple.

Answer 1

1. If the default copy-assignment operator of class B is not deleted, [class.copy]/28

   The implicitly-defined copy/move assignment operator for a non-union class X performs memberwise copy-/move assignment of its subobjects. The direct base classes of X are assigned first, in the order of their declaration in the base-specifier-list [ie in the order in which they're listed after class X : /*here*/ {/*...*/}; ], and then the immediate non-static data members of X are assigned, in the order in which they were declared in the class definition.

2. Similarly, [class.copy]/15

   The implicitly-defined copy/move constructor for a non-union class X performs a memberwise copy/move of its bases and members.

   The order is: first the base class(es) (base class subobjects), then the direct non-static data members, similarly to 1).

3. For the behaviour described in 1) and 2), no . Virtual assignment operators are hardly ever useful. Constructors may not be virtual at all (doesn't make sense).

   In order for a virtual function in a derived class B to override a virtual function in a base class A , it must have the same parameter types. That is, you could have a virtual A& operator=(A const&); in the base class A , but the override in class B had to look like virtual B& operator=(A const&); , which is not a copy-assignment operator for B , because of the parameter type.

4. Not without "hacks". And you're not actually overloading it, but hiding all base class assignment operators. Otherwise, this would be legal:

    class A {}; class B { int i; }; A a; B b = a; // using A::operator=(A const&)