Assignment Operator C++ Inheritance Private

Three special kinds of member functions are never inherited:

  1. Copy constructors

  2. Copy assignment operators

  3. Destructors

These three functions are generated automatically by the compiler for classes that do not specify them.

Why Are These Functions Special?

The base class functions are not sufficient to initialize, copy, or destroy a derived instance.


For a class that inherits from another, the base class constructor must be called as part of its initialization process. The derived constructor may specify which base class constructor is called in its initialization list.

A class with no constructors is automatically given a compiler-generated, , default constructor that calls the default constructor for each of its base classes. If a class has some constructors but no default constructor, then it has no default initialization. In this case, any derived class constructor must make an explicit base class constructor call in its initialization list.

Order of Initialization

Initialization proceeds in the following order:

  1. Base classes first, in the order in which they are listed in the classHead of the derived class

  2. Data members, in declaration order

Copy Assignment Operators

A copy assignment operator is automatically generated by the compiler for each class that does not have one explicitly defined for it. Because base class data members are generally private, the derived class copy assignment operator must call the base class assignment operator (for each base class) for memberwise copying of those data members to happen. After that, it can perform memberwise assignments of derived class data members.

Other member function operators are inherited the same way as normal member functions.

Copy Constructors

Like the copy assignment operator, a copy constructor is automatically generated for classes that do not have one defined. The compiler-generated copy constructor carries out member-by-member initialization by copying the data members of its argument object.

Example 6.20 defined a class with a single constructor that requires three arguments, so has no default constructor (i.e., the compiler will not generate one). We declare the base class destructor to ensure that the appropriate derived class destructor gets called when it is time to destroy a derived object accessed through a base class pointer.

Example 6.20. src/derivation/assigcopy/account.h

[ . . . . ] class Account { public: Account(unsigned acctNum, double balance, owner); virtual ~Account(){ qDebug() << "Closing Acct - sending e-mail " << "to primary acctholder:" << m_Owner; } virtual getName() const {return m_Owner;} // other virtual functions private: unsigned m_AcctNum; double m_Balance; m_Owner; };

We did not define a copy constructor, which means the compiler will generate one for us. Therefore, this class can be instantiated in exactly two ways: (1) by calling the three-parameter constructor or (2) by invoking the compiler generated copy constructor and supplying an object argument.

Example 6.21 defines a derived class with two constructors. Both of them require base class initialization.

Example 6.21. src/derivation/assigcopy/account.h

[ . . . . ] class JointAccount : public Account { public: JointAccount (unsigned acctNum, double balance, owner, jowner); JointAccount(const Account & acct, jowner); ~JointAccount() { qDebug() << "Closing Joint Acct - sending e-mail " << "to joint acctholder:" << m_JointOwner; } getName() const { return ("%1 and %2").arg(Account::getName()) .arg(m_JointOwner); } // other overrides private: m_JointOwner; };

In Example 6.22, the compiler enables to use for initialization, even though we have not defined it. The compiler-generated copy constructor does memberwise copy/initialization in the order that the data members are listed in the class definition.

Example 6.22. src/derivation/assigcopy/account.cpp

[ . . . . ] Account::Account(unsigned acctNum, double balance, owner) : m_AcctNum(acctNum), m_Balance(balance), m_Owner(owner) { } JointAccount::JointAccount (unsigned acctNum, double balance, owner, jowner) :Account(acctNum, balance, owner), m_JointOwner(jowner) { } JointAccount::JointAccount (const Account& acc, jowner) :Account(acc), m_JointOwner(jowner) { }

Base class initialization required.

Compiler-generated copy constructor call.

Example 6.23 defines a little class that maintains a list of pointers.

Example 6.23. src/derivation/assigcopy/bank.h

[ . . . . ] class Account; class Bank { public: Bank& operator<< (Account* acct); ~Bank(); getAcctListing() const; private: <Account*> m_Accounts; }; [ . . . . ]

This is how to add object pointers to m_Accounts.

in Example 6.24 the construction of the object makes use of the compiler-supplied copy constructor, which calls the compiler-supplied copy constructor.

Example 6.24. src/derivation/assigcopy/bank.cpp

[ . . . . ] #include <> #include "bank.h" #include "account.h" Bank::~Bank() { qDeleteAll(m_Accounts); m_Accounts.clear(); } Bank& Bank::operator<< (Account* acct) { m_Accounts << acct; return *this; } Bank::getAcctListing() const { listing("\n"); foreach(Account* acct, m_Accounts) listing += ("%1\n").arg(acct->getName()); return listing; } int main() { listing; { Bank bnk; Account* a1 = new Account(1, 423, "Gene Kelly"); JointAccount* a2 = new JointAccount(2, 1541, "Fred Astaire", "Ginger Rodgers"); JointAccount* a3 = new JointAccount(*a1, "Leslie Caron"); bnk << a1; bnk << a2; bnk << a3; JointAccount* a4 = new JointAccount(*a3); bnk << a4; listing = bnk.getAcctListing(); } qDebug() << listing; qDebug() << "Now exit program" ; } [ . . . . ]

getName() is virtual.

Begin internal block.

What's this?

At this point, all four Accounts are destroyed as part of the destruction of the bank.


Destructors are not inherited. Just as with the copy constructor and copy assignment operator, the compiler generates a destructor if you do not define one explicitly. Base class destructors are automatically called when a derived object is destroyed. Destruction of data members and base class parts occurs in precisely the reverse order of initialization.

6.6.  Constructors, Destructors, and Copy Assignment Operators

A copy assignment operator of class is a non-template non-static member function with the name operator= that takes exactly one parameter of type T, T&, const T&, volatile T&, or constvolatile T&. For a type to be , it must have a public copy assignment operator.


class_nameclass_name ( class_name ) (1)
class_nameclass_name ( const class_name ) (2)
class_nameclass_name ( const class_name ) = default; (3) (since C++11)
class_nameclass_name ( const class_name ) = delete; (4) (since C++11)


  1. Typical declaration of a copy assignment operator when copy-and-swap idiom can be used.
  2. Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used (non-swappable type or degraded performance).
  3. Forcing a copy assignment operator to be generated by the compiler.
  4. Avoiding implicit copy assignment.

The copy assignment operator is called whenever selected by overload resolution, e.g. when an object appears on the left side of an assignment expression.

[edit]Implicitly-declared copy assignment operator

If no user-defined copy assignment operators are provided for a class type (struct, class, or union), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form T& T::operator=(const T&) if all of the following is true:

  • each direct base of has a copy assignment operator whose parameters are B or const B& or constvolatile B&;
  • each non-static data member of of class type or array of class type has a copy assignment operator whose parameters are M or const M& or constvolatile M&.

Otherwise the implicitly-declared copy assignment operator is declared as T& T::operator=(T&). (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument.)

A class can have multiple copy assignment operators, e.g. both T& T::operator=(const T&) and T& T::operator=(T). If some user-defined copy assignment operators are present, the user may still force the generation of the implicitly declared copy assignment operator with the keyword .(since C++11)

The implicitly-declared (or defaulted on its first declaration) copy assignment operator has an exception specification as described in dynamic exception specification(until C++17)exception specification(since C++17)

Because the copy assignment operator is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

[edit]Deleted implicitly-declared copy assignment operator

A implicitly-declared copy assignment operator for class is defined as deleted if any of the following is true:

  • has a user-declared move constructor;
  • has a user-declared move assignment operator.

Otherwise, it is defined as defaulted.

A defaulted copy assignment operator for class is defined as deleted if any of the following is true:

  • has a non-static data member of non-class type (or array thereof) that is const;
  • has a non-static data member of a reference type;
  • has a non-static data member or a direct or virtual base class that cannot be copy-assigned (overload resolution for the copy assignment fails, or selects a deleted or inaccessible function);
  • is a union-like class, and has a variant member whose corresponding assignment operator is non-trivial.

[edit]Trivial copy assignment operator

The copy assignment operator for class is trivial if all of the following is true:

  • it is not user-provided (meaning, it is implicitly-defined or defaulted) , , and if it is defaulted, its signature is the same as implicitly-defined(until C++14);
  • has no virtual member functions;
  • has no virtual base classes;
  • the copy assignment operator selected for every direct base of is trivial;
  • the copy assignment operator selected for every non-static class type (or array of class type) member of is trivial;
  • has no non-static data members of volatile-qualified type.
(since C++14)

A trivial copy assignment operator makes a copy of the object representation as if by std::memmove. All data types compatible with the C language (POD types) are trivially copy-assignable.

[edit]Implicitly-defined copy assignment operator

If the implicitly-declared copy assignment operator is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler if odr-used. For union types, the implicitly-defined copy assignment copies the object representation (as by std::memmove). For non-union class types (class and struct), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using built-in assignment for the scalars and copy assignment operator for class types.

The generation of the implicitly-defined copy assignment operator is deprecated(since C++11) if has a user-declared destructor or user-declared copy constructor.


If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an rvalue (either a prvalue such as a nameless temporary or an xvalue such as the result of std::move), and selects the copy assignment if the argument is an lvalue (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

It is unspecified whether virtual base class subobjects that are accessible through more than one path in the inheritance lattice, are assigned more than once by the implicitly-defined copy assignment operator (same applies to move assignment).

See assignment operator overloading for additional detail on the expected behavior of a user-defined copy-assignment operator.


Run this code


#include <iostream>#include <memory>#include <string>#include <algorithm>   struct A {int n;std::string s1;// user-defined copy assignment, copy-and-swap form A& operator=(A other){std::cout<<"copy assignment of A\n";std::swap(n, other.n);std::swap(s1, other.s1);return*this;}};   struct B : A {std::string s2;// implicitly-defined copy assignment};   struct C {std::unique_ptr<int[]> data;std::size_t size;// non-copy-and-swap assignment C& operator=(const C& other){// check for self-assignmentif(&other == this)return*this;// reuse storage when possibleif(size != other.size){ data.reset(new int[other.size]); size = other.size;}std::copy(&[0], &[0]+ size, &data[0]);return*this;}// note: copy-and-swap would always cause a reallocation};   int main(){ A a1, a2;std::cout<<"a1 = a2 calls "; a1 = a2;// user-defined copy assignment   B b1, b2; b2.s1="foo"; b2.s2="bar";std::cout<<"b1 = b2 calls "; b1 = b2;// implicitly-defined copy assignmentstd::cout<<"b1.s1 = "<< b1.s1<<" b1.s2 = "<< b1.s2<<'\n';}
a1 = a2 calls copy assignment of A b1 = b2 calls copy assignment of A b1.s1 = foo b1.s2 = bar

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior
CWG 2171 C++14 operator=(X&)=default was non-trivial made trivial

One thought on “Assignment Operator C++ Inheritance Private

Leave a Reply

Your email address will not be published. Required fields are marked *