Question

I’ve written this documentation of a rather simple class, but I feel it’s not clear enough. Should I change anything?

/**
    Pointer class that wraps resources loaded through the ResourceManager.
    The manager is notified to increase or decrease the reference count of
    a resource, as a ResourcePtr gets copied, created, or deleted.

    If a resource has a reference count of zero, the ResourceManager will
    delete it. The reference count of a resource is the same as the number
    of ResourcePtr objects that reference it.

    \see ResourceManager
                                                                             */
template<class T>
class ResourcePtr
{
  public:
    /**
        Default constructor. Creates an empty ResourcePtr that does not
        reference any resource. 
                                                                             */
    ResourcePtr();
    /**
        Copy constructor. Create a copy and increase the reference count
        of the resource referenced by the ResourcePtr being copied, if any.
                                                                             */
    ResourcePtr(const ResourcePtr<T>& other);
    /**
        Destroy the ResourcePtr and release one reference to the resource
        it points to, if any. The resource is deleted if there are no more
        ResourcePtr objects that reference it. 
                                                                             */
    ~ResourcePtr();

    /**
        Access the resource inside the ResourcePtr.
        \return Pointer to the resource or null if ResourcePtr is empty.
                                                                             */
    const T* get() const;
    /**
        Arrow operator. Provided for convenience to access members of
        the resource class directly, without having to first call get().
        An assertion failure occurs if the ResourcePtr is empty.
                                                                             */
    const T* operator->() const;
    /**
        Assignment operator. Release the resource currently pointing to,
        if any. Copy the data from the other ResourcePtr and increase
        the reference count of the resource it points to, if any.
                                                                             */
    ResourcePtr<T>& operator=(const ResourcePtr<T>& other);

  private:
    friend class ResourceManager<T>;
    typename std::list<typename
        ResourceManager<T>::ResourceWrapper*>::iterator iter_;
};

Answer 1

You are missing the fact that those comments are all unecessary, and only serve to make the code more difficult to read and understand. They are the equivalent of:

  i++; // increment i