In the previous section policy classes were used as base classes of template
classes. This resulted in the interesting observation that a policy class
may serve as a em(base class)
        hi(class template: as base class)
    of a derived class.
    As a policy class may act as a base class, a pointer or reference to such
a policy class can be used to point or refer to the derived class using the
policy.

    This situation, although legal, should be avoided for various reasons:
        hi(pointer: to policy base class)
    itemization(
    it() Destruction of a derived class object using the base class's
destructor requires the implementation of a virtual destructor;
    it() A virtual destructor introduces overhead to a class that normally has
no data members, but merely defines behavior: suddenly a ti(vtable) is
required as well as a data member pointing to the vtable;
    it() Virtual member functions somewhat reduce the efficiency of code;
virtual member functions use emi(dynamic polymorphism), which in principle is
undoing the advantages of emi(static polymorphism) as offered by templates;
    it() Virtual member functions in templates may result in emi(code bloat):
once an instantiation of a class's member is required, the class's vtable and
em(all) its virtual members must be implemented too.
    )
    To avoid these drawbacks, it is good practice to em(prevent) the use of
references or pointers to policy classes to refer or point to derived
class objects. This is accomplished by providing policy classes with
        hi(destructor: for policy classes)
    em(non-virtual protected destructors). With a non-virtual destructor there
is no performance penalty and since its destructor is protected users cannot
refer to classes derived from the policy class using a pointer or reference to
the policy class.
