C++ OOP (BigThree & Pass by Reference & Return by Reference & Point & Template)

template<typename Object>
class Vector
{
    public:
        explicit Vector( int initSize = 0 )  //显示构造函数，不允许compiler进行自动类型转换 
          : theSize( initSize ), theCapacity( initSize + SPARE_CAPACITY )  //初始化列 
          {
            objects = new Object[theCapacity];  //通过指针动态分配内存生成数组 
          }

        Vector( const Vector& rhs ) : objects(NULL)   { opreator= (rhs); }  //拷贝构造函数(先将objects指针初始化为NULL)

        ~Vector()  { delete [] objects; }  //析构函数 
        /**
        *delete [] objects;
        *这里为什么要加“[]”,原因如下: 
        *如果typename Object = Vector(或其他指针类型，如String、*p;甚至程序员自己开发的另一个指针类型的class)，这样，
        *objects[i]里存储的含有指针变量或指针对象，指针指向其他内存的地址(可能这些地址是属于堆内存)，避免这些内存无法收回造成内存泄漏，
        *所以加“[]”是最万无一失的方法，这样即使objects[i]里存储的都是指针对象并且都各自有动态分配的内存，delete [] objects可以通过调用
        *objects[i]的析构函数来清理掉这些动态分配的内存。 
        * 
        *假设 Object = int, 构造函数里就变成objects = new int[theCapacity]; 这样，objects就变成一个通过动态分配内存的整数数组了， 
        *析构函数里就可以写成delete objects。
        */


        const Vector& operator= ( const Vector& rhs )  //拷贝赋值函数(const,传入的数组不能被修改,pass by reference; return by const reference)
        {//返回常量引用 
            if( this != &rhs)  //自检，对于指针对象，不能自己给自己赋值，否则会出错 
            {
                delete [] objects;  //清空原根据地 
                theSize = rhs.size();
                theCapacity = rhs.thsCapacity;

                objects = new Object[ capacity() ];  //开辟新根据地 
                for( int k = 0; k < size(); k++ )
                {
                    objects[k] = rhs.objects[k];
                }           
            }

            return *this;  //返回拷贝赋值后的对象 
        }

        void resize( int  newSize )  //重置大小函数 
        {
            if( newSize > theCapacity )  
            {
                reserve( newSize * 2 + 1 );  //如果超过原数组容量，重新开辟新空间 
            }

            theSize = newSize;
        }

        void reserve( int newCapacity )  //开辟新根据地 
        {
            if( newCapacity < theSize )  //容量不能比已占空间小 
            {
                return;
            }

            Object *oldArray = objects;  //把原根据地的地址告诉临时指针对象oldArray 

            objects = new Object[ newCapacity ];  //原队伍领头人去开辟新根据地
            for( int k = 0; k < theSize; k++)
            {
                objects[k] = oldArray[k];  //把原班人马转移到新根据地 
            }

            theCapacity = newCapacity;  //记录新根据地容量 

            delete [] oldArray;  //转移成功后放弃原根据地 

        }

        Object& operator[] ( int index )  //非常量成员函数
        {
            return objects[ index ];
        }

        const Object& operator[] (int index) const  //常量成员函数 
        {
            return objects[ index ];
        }

        bool empty() const  //判断大小是否为空 
        {
            return size() == 0;
        }       
        int size() const  //获得大小 
        {
            return theSize;
        }
        int capacity() const  //获得容量 
        {
            return theCapacity;
        }

        void push_back(const Object& x)  //数组末尾添加对象 
        {
            if( theSize == theCapacity)  //判断是否满容 
            {
                reserve( 2*theCapacity + 1);
            }
            objects[theSize++] = x;  //先做操作,然后自增 
        }

        void pop_back()  //弹出数组最后一个元素 
        {
            theSize--;
        }

        const Object& back() const  //取出数组最后一个元素 
        {
            return objects[ theSize - 1 ];
        }

        typedef Object * iterator;  
        typedef const Object * const_iterator;  //常量指针 

        iterator begin()  
        {
            return &objects[0];
        }       
        const_iterator begin() const
        {
            return &objects[0];
        }

        iterator end()
        {
            return &objects[ size() ];
        }
        const_iterator end() const
        {
            return &objects[ size() ];
        }

        enum { SPARE_CAPACITY = 16; };

    private:
        int theSize;  //大小 
        int theCapacity;  //容量 
        Object *objects;  //数组(指针) 

};