Let's see how that works for classes with some interesting structure. Consider the diagram shown below. The Base class, B, holds an instance of a composed type C, presumably as a private or protected type. The class D inherits publicly from B and aggregates a reference to an instance of another class A.

• When B is constructed the first thing that happens is its internal instance c of type C is constructed. Here's how you write a default constructor for B:
  B::B() : c() { ... }
  where the body is used to construct other resources like creating file streams or acquiring database connections. Here's how you write B's copy constructor:
  B::B(const &b) : c(b.c) { ... }
  The expression c(b.c) is a copy construction of the new B's instance c of C, copied from b's instance of C. If B doesn't need to acquire any other resources then you don't have to write B(const &b) since the compiler generated copy constructor works correctly.
• When D is constructed the first thing that happens is that its base B is constructed, which as its first act, constructs an instance of the composed type C. Then, an instance of A is constructed on the heap. Here's how D's default constructor is written, assuming that D declares a pointer, A* pA, to hold the reference to its A resource:
  D::D() : B(), pA(new A) { ... }
  and here's how its copy constructor is written:
  D::D(const D& d) : B(d), pA(new A(*d.pA)) { ... }
  The expression A(*d.pA) is a copy construction of an instance of A, copying the state of the A instance held by d. The bodies of the D() and D(const D& d) constructors are used to acquire other resources as needed.
• The sequences: B(), pA(new A) and B(d), pA(new A(*d.pA)) are called initialization sequences. By using initialization sequences you get to choose which constructors are called for all of the internal types in some composite, like D.
• Instead of writing these sequences it is possible to simply move the heap construction of the A instance into the body of the D constructors, letting the compiler generate code to automatically call constructors for B and its C. However, that is not a good idea. We will show that there are some situations where the compiler will make the wrong choice with incorrect results. Also, this is sometimes less efficient as we will show when we discuss C++ hierarchy near the beginning of this course.

Conclusions for: Implementing Initialization