    Once a class becomes a emi(move-aware) class one should realize that its
destructor still performs its job as implemented. Consequently, when moving
pointer values from a temporary source to a destination the move constructor
should make sure that the temporary's pointer value is set to zero, to prevent
doubly freeing memory.

    If a class defines pointers to pointer data members there usually is not
only a pointer that is moved, but also a tt(size_t) defining the number of
elements in the array of pointers.

Once again, consider the class tt(Strings). Its destructor is implemented
like this:
        verb(
    Strings::~Strings()
    {
        for (string **end = d_string + d_size; end-- != d_string; )
            delete *end;
        delete[] d_string;
    }
        )
    The move constructor (and other move operations!) must realize that the
destructor not only deletes tt(d_string), but also considers tt(d_size). A
member implementing move operations should therefore not only set tt(d_string)
to zero but also tt(d_size). The previously shown move constructor for
tt(Strings) is therefore incorrect. Its improved implementation is:
        verb(
    Strings::Strings(Strings &&tmp)
    :
        d_string(tmp.d_string),
        d_size(tmp.d_size),
        d_capacity(tmp.d_capacity)
    {
        tmp.d_string = 0;
        tmp.d_size = 0;
    }
        )
    If operations by the destructor all depend on tt(d_string) having a
non-zero value then variations of the above approach are possible. The move
operations could merely set tt(d_string) to 0, testing whether
tt(d_string == 0) in the destructor (and if so, end the destructor's
actions). In the latter variant the tt(d_size) assignment can be omitted.
