Возвращение ссылки на указатель использование её как левостороннего значения

// Принципы и практика использования C++ Глава 19
// Principles and Practice Using C++ Chapter 19
#include <iostream> 
#include <memory>  
#include <utility> 
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::string;
using std::stringstream;
//using std::swap;
using std::auto_ptr;
//------------------------------------------------------------------------------
 
template<class T, class A>
struct vvector_base {
    typedef ptrdiff_t difference_type ;
    typedef size_t size_type ;
 
    A alloc;
    T* elem;
    int sz;
    int space;
    vvector_base() : sz(0), elem(0), space(0) 
    {
        //cout << this << " vvector_base::vvector_base()" << endl; 
    }
    vvector_base(const A& a, int e,  int n) : alloc(a), elem(alloc.allocate(n)), sz(e), space(n)
    {
        //cout << this << " vvector_base::vvector_base(const A& a, int n)" << endl; 
    }
    vvector_base(const vvector_base&);
    vvector_base& operator=(const vvector_base&);
    ~vvector_base() 
    { 
        //cout << this << " vvector_base::~vvector_base()" << endl; 
        alloc.deallocate(elem,space); 
    }
 
};
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector_base<T,A>::vvector_base(const vvector_base& arg)
    :   sz(arg.sz), space(arg.space), elem(alloc.allocate(arg.space))
{
    //cout << this << " vvector_base::vvector_base(const vvector_base& arg)" << endl; 
    
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&elem[i],arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector_base<T,A>& vvector_base<T,A>::operator=(const vvector_base& arg) {
    //cout << this << " vvector_base& vvector_base::operator=(const vvector_base& arg)" << endl; 
 
    if(&arg==this) return *this; // self-assignment
 
    if(arg.space <= space) {
        for(int i=0; i<arg.sz; i++)
            alloc.construct(&elem[i],arg.elem[i]);
        sz = arg.sz;
        return *this;
    }
    
    auto_ptr<T> p(alloc.allocate(arg.space));
 
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&p.get()[i],arg.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    
    alloc.deallocate(elem,space);
    elem = p.release();
    sz = arg.sz;
    space = arg.space;
    return *this;
 
}
//------------------------------------------------------------------------------
 
template<class T, class A = allocator<T> >
class vvector : private vvector_base<T,A> {
/*
invariant:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) элементов типа T 
*/
 
    void copy(const vvector& arg); // copy elements value. don't carry about its size
 
public:
    vvector() 
    {
        //cout << this << " \tvvector::vvector()" << endl; 
    }
    explicit vvector(int s, const T& val = T()) // constructor; key-word "explicit"  have been added to prevent implicit conversion
    {
        sz = s;
        space = s;
        elem = alloc.allocate(s);
        for(int i=0;i<sz;i++)
            alloc.construct(&elem[i], val);
        //cout << this << " \tvvector::vvector(int s)" << endl; 
    }
  
    vvector(const vvector&);                       // copy constructor: define copy
    vvector& operator=(const vvector&);
  
    ~vvector() { // destructor
        //cout << this << " \tvvector::~vvector()" << endl;
    } 
             
    
    T& operator[](int n) {return elem[n];} // access without range checking
    const T& operator[](int n) const {return elem[n];} // access without range checking
    
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }               // the current size
    int capacity() const {return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::copy(const vvector& arg) {
    for(int i=0; i<arg.sz; i++) 
        alloc.construct(&elem[i],arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying
{
    //cout << this << " \t\tvvector::vvector(const vvector& arg)" << endl;
    sz = arg.sz;
    space = arg.sz;
    elem = alloc.allocate(arg.sz);
    copy(arg);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>& vvector<T,A>::operator=(const vvector& arg) {
    //cout << this << " \t\tvvector::operator=(const vvector& v)" << endl;
    if(this==&arg) return *this;
 
    if(arg.sz<=space) {
        copy(arg);
        sz=arg.sz;
        return *this;
    }
    auto_ptr<T> p(alloc.allocate(arg.space));
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&p.get()[i],arg.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem,space);
    elem = p.release();
    space = sz = arg.sz;
    return *this;
}
 
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::reserve(int newalloc) {
 
    //cout << this << " \t\tvvector::reserve(int newalloc), newalloc==" << newalloc << endl;
    if(newalloc<=space) return;
 
    vvector_base<T,A> b(alloc,sz,newalloc);
    for(int i=0; i<sz; i++) 
        alloc.construct(&b.elem[i],elem[i]);
    for(int i=0; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
    std::swap<vvector_base<T,A>>(*this,b);
    //cout << "vvector<T,A>::reserve, space == " << space << endl;
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::resize(int newsize, T value) {
    //cout << this << " \t\tvvector::resize(int newsize, T value)" << endl;
    if(newsize<0) return;
    if(!newsize) {
        for(int i=0; i<sz; i++) 
            alloc.destroy(&elem[i]);
        alloc.deallocate(elem,space);
        sz = 0;
        space = 0;
        elem = 0;
    }
    else {
        reserve(newsize);
        for(int i=sz; i<newsize; i++) 
            alloc.construct(&elem[i], value);
        for(int i=newsize; i<sz; i++) 
            alloc.destroy(&elem[i]);
        sz = newsize;
    }
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::push_back(T value) {
    //cout << this << " \t\tvvector::push_back(T value), size==" << sz << "; space==" << space << endl;
    if(!space) reserve(8);
    else if (sz==space) reserve(2*space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
T& vvector<T,A>::at(int n) {
    
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
const T& vvector<T,A>::at(int n) const {
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------