Class templates can be used for inheritance purposes as well. When a
class template is used in class derivation, the following situations should be
distinguished:
    itemization(
    it() An existing class template is used as base class when deriving a
ordinary class. The derived class itself will partially be a class template,
but this is somewhat hidden from view when an object of the derived class is
defined.
    it() An existing class template is used as the base class when deriving
another class template. Here the class template characteristics remain clearly
visible.
    it() An ordinary class is used as the base class when deriving a template
class. This interesting hybrid allows us to construct class templates that
        hi(class template: partially compiled)
are em(partially compiled).
    )
    These three variants of hi(class template: derivation) class template
derivation are elaborated in this and the upcoming sections.

Consider the following base class:
        verb(
    template<typename T>
    class Base
    {
        T const &t;

        public:
            Base(T const &t);
    };
        )
    The above class is a class template that can be used as a base class for
the following derived class template tt(Derived):
        verb(
    template<typename T>
    class Derived: public Base<T>
    {
        public:
            Derived(T const &t);
    };
    template<typename T>
    Derived<T>::Derived(T const &t)
    :
        Base(t)
    {}
        )
    Other combinations are also possible. The base class may be instantiated
by specifying template arguments, turning the derived class into an ordinary
class (showing a class object's definition as well):
        verb(
    class Ordinary: public Base<int>
    {
        public:
            Ordinary(int x);
    };
    inline Ordinary::Ordinary(int x)
    :
        Base(x)
    {}

    Ordinary ordinary{ 5 };
        )
    This approach allows us to
 hi(class template: adding functionality)
    add functionality to a class template, without the need for constructing a
derived class template.

    Class template derivation pretty much follows the same rules as ordinary
class derivation, not involving class templates. Some subtleties that are
specific for class template derivation may easily cause confusion like the use
of tt(this) when members of a template base class are called from a derived
class. The reasons for using tt(this) are discussed in section ref(SUBTLE). In
the upcoming sections the focus will be on the class derivation proper.
