A tt(unique_ptr) hi(unique_ptr: initialization) is most often initialized
using a pointer to dynamically allocated memory. The generic form is:
        verb(
    unique_ptr<type [, deleter_type]> identifier(new-expression
            [, deleter = deleter_type{}]);
        )
    The second (template) argument (tt(deleter(_type))) is optional and may
 hi(deleter) refer to a free function or function object handling the
destruction of the allocated memory. A deleter is used, e.g., in situations
where a double pointer is allocated and the destruction must visit each nested
pointer to destroy the allocated memory (see below for an illustration).

    Here is an example initializing a tt(unique_ptr) pointing to a tt(string)
object:
        verb(
    unique_ptr<string> strPtr(new string("Hello world"));
        )
    The argument that is passed to the constructor is the pointer returned by
tt(operator new). Note that tt(type) does em(not) mention the pointer.  The
hi(unique_ptr: used type) type that is used in the tt(unique_ptr) construction
is the same as the type that is used in tt(new) expressions.

Here is an example showing how an explicitly defined deleter may be used to
delete a dynamically allocated array of pointers to strings:
        verbinclude(-a examples/deleter.cc)

A tt(unique_ptr) can be used to reach the
 hi(unique_ptr: reaching members) member functions that are available for
objects allocated by the tt(new) expression.  These members can be reached as
if the tt(unique_ptr) was a plain pointer to the dynamically allocated
object. For example, in the following program the text `tt(C++)' is inserted
behind the word `tt(hello)':
        verbinclude(-a examples/insertcpp.cc)
