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, a function object handling the
destruction of the allocated memory, or a lambda function. 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)
