The class tt(shared_ptr) offers the following hi(shared_ptr: operators)
operators:
    itemization(
    ithtq(operator=)(shared_ptr &operator=(shared_ptr<Type> const &other))
        (Copy assignment: the reference count of the operator's left hand side
        operand is reduced. If the reference count decays to zero the
        dynamically allocated memory controlled by the left hand side operand
        is deleted. Then it shares the information with the operator's
        right hand side operand, incrementing the information's reference
        count.)
    ithtq(operator=)(shared_ptr &operator=(shared_ptr<Type> &&tmp))
       (Move assignment: the reference count of the operator's left hand side
        operand is reduced. If the reference count decays to zero the
        dynamically allocated memory controlled by the left hand side operand
        is deleted. Then it grabs the information controlled by the
        operator's right hand side operand which is turned into a 0-pointer.)
    ithtq(operator bool)
        (operator bool() const)
       (If the tt(shared_ptr) actually points to memory tt(true) is returned,
        otherwise, tt(false) is returned.)
    ithtq(operator*)
        (Type &operator*())
       (A reference to the information stored in the
        tt(shared_ptr) object is returned. It acts like a normal pointer.)
    ithtq(operator->)
       (Type *operator->())
       (A pointer to the information controlled by the tt(shared_ptr) object
        is returned. Example:
   verb(shared_ptr<string> sp{ new string{ "hello" } };
cout << sp->c_str() << '\n';)

)
    )

    The following i(member function) member functions are supported:
    itemization(
    ithtq(get)(Type *get())
       (A pointer to the information controlled by the tt(shared_ptr) object
        is returned. It acts like tt(operator->). The returned pointer can be
        inspected. If it is zero the tt(shared_ptr) object does not point to
        any memory.)
    ithtq(get_deleter)(Deleter &get_deleter())
       (A reference to the tt(shared_ptr)'s deleter (function or function
        object) is returned.)
    ithtq(reset)(void reset(Type *))
      (The reference count of the information controlled by the tt(shared_ptr)
        object is reduced and if it decays to zero the memory it points to
        is deleted. Thereafter the
        object's information will refer to the argument that is passed to the
        function, setting its shared count to 1. It can also be called without
        argument, turning the object into a 0-pointer. This member function
        can be used to assign a new block of dynamically allocated memory to a
        tt(shared_ptr) object.)
    ithtq(reset)(void reset(Type *, DeleterType &&))
      (This variant of the previous member accepts a specific tt(Deleter)
        type: if tt(Type) is a base-class and derived class objects are used,
        these derived class objects may require specific actions at
        destruction time. When the previous member is used, then eventually the
        newly assigned object's destructor is called without using an
        explicit deleter function. The current member ensures that by the time
        the shared counter has decayed to zero the provided deleter is used.)
      ithtq(swap)
        (void shared_ptr<Type>::swap(shared_ptr<Type> &&))
       (Two identically typed tt(shared_ptrs) are swapped.)
    ithtq(unique)
        (bool unique() const)
        (If the current object is the only object referring to the memory
        controlled by the object tt(true) is returned otherwise (including the
        situation where the object is a 0-pointer) tt(false) is returned.)
    ithtq(use_count)(size_t use_count() const)
       (The number of objects sharing the memory controlled by the object is
        returned.)
    )
