A emi(policy) defines (in some contexts: prescribes) a particular kind of
behavior. In bf(C++) a
    hi(class: policy)
 em(policy class) defines a certain part of the class interface. It may also
define inner types, member functions, and data members.

In the previous section the problem of creating a class that might use any of
a series of allocation schemes was introduced. These allocation schemes all
depend on the actual data type to use, and so the `template reflex' should
kick in.

Allocation schemes should probably be defined as template classes, applying
the appropriate allocation procedures to the data type at hand. When such
allocation schemes are used by the familiar STL containers (like
tt(std::vector, std::stack), etc.), then such home-made allocation schemes
should probably be derived from tt(std::allocator)hi(allocator), to provide
for the requirements made by these containers. The class template
tt(std::allocator) is declared by the tthi(memory) header file and the three
allocation schemes developed here were all derived from tt(std::allocator).

Using in-class implementations for brevity the following allocation classes
could be defined:
    itemization(
    it() No special allocation takes place, tt(Data) is used `as is':
    verb(template <typename Data>
class PlainAlloc: public std::allocator<Data>
{
    template<typename IData>
    friend std::ostream &operator<<(std::ostream &out,
                                    PlainAlloc<IData> const &alloc);
    Data d_data;

    public:
        PlainAlloc()
        {}
        PlainAlloc(Data const &data)
        :
            d_data(data)
        {}
        PlainAlloc(PlainAlloc<Data> const &other)
        :
            d_data(other.d_data)
        {}
};)

it() The second allocation scheme uses the standard tt(new) operator to
allocate a new copy of the data:
    verb(template <typename Data>
class NewAlloc: public std::allocator<Data>
{
    template<typename IData>
    friend std::ostream &operator<<(std::ostream &out,
                                    NewAlloc<IData> const &alloc);
    Data *d_data;

    public:
        NewAlloc()
        :
            d_data(0)
        {}
        NewAlloc(Data const &data)
        :
            d_data(new Data(data))
        {}
        NewAlloc(NewAlloc<Data> const &other)
        :
            d_data(new Data(*other.d_data))
        {}
        ~NewAlloc()
        {
            delete d_data;
        }
};)

it() The third allocation scheme uses the i(placement new) operator (see
        section ref(PLACEMENT)), requesting memory from a
        common pool (the implementation of the member tt(request),
        obtaining the required amount of memory, is left as an exercise to the
        reader):
    verb(template<typename Data>
class PlacementAlloc: public std::allocator<Data>
{
    template<typename IData>
    friend std::ostream &operator<<(std::ostream &out,
                                    PlacementAlloc<IData> const &alloc);
    Data *d_data;

    static char s_commonPool[];
    static char *s_free;

    public:
        PlacementAlloc()
        :
            d_data(0)
        {}
        PlacementAlloc(Data const &data)
        :
            d_data(new(request()) Data(data))
        {}
        PlacementAlloc(PlacementAlloc<Data> const &other)
        :
            d_data(new(request()) Data(*other.d_data))
        {}
        ~PlacementAlloc()
        {
            d_data->~Data();
        }
    private:
        static char *request();
};)

)
    The above three classes define em(policies) that may be selected by the
user of the class tt(Storage) introduced in the previous section. In addition
to these classes, additional allocation schemes could be implemented by the
user as well.

    To apply the proper allocation scheme to the class tt(Storage),
tt(Storage) should be designed as a class template itself. The class also
needs a template type parameter allowing users to specify the data type.

    The data type to be used by a particular allocation scheme could of course
be specified when specifying the allocation scheme to use. The class
tt(Storage) would then have two template type parameters, one for the data
type, one for the allocation scheme:
        verb(    template <typename Data, typename Scheme>
    class Storage ...)

To use the class tt(Storage) we would then write, e.g.:
        verb(    Storage<string, NewAlloc<string>> storage;)

Using tt(Storage) this way is fairly complex and potentially error-prone,
as it requires the user to specify the data type twice. Instead, the
allocation scheme should be specified using a new type of template parameter,
not requiring the user to specify the data type required by the allocation
scheme. This new kind of template parameter (in addition to the well-known
em(template type parameter) and em(template non-type parameter)) is called the
 emi(template template parameter).

Starting with the C++14 standard the keyword em(class) 
        hi(template: class vs. typename) 
    in the syntactical form of template template parameters (tt(template
<parameter specifications> class Name)) is no longer required. From that
standard onward, the keyword tt(typename) can also be used (e.g., tt(template
<parameter specifications> typename Name)).
