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;  //数组(指针) };