五大函数：

析构函数

拷贝构造函数

移动构造函数

拷贝赋值 Operator=

移动赋值 Operator=

---

 

析构函数

只要一个对象运行越出范围，

或经受一次 delete，

则析构函数就要被调用

 

对于 Intcell,这些操作的形式是：

~Intcell();          //析构函数
Intcell(const Intcell &rhs);        //拷贝构造函数
Intcell(Intcell &&rhs);             //移动构造函数
Intcell &operator=(const Intcell &rhs);      //拷贝函数
Intcell &operator=(Intcell &&rhs);           //移动函数

 

vector 的实现

概述：

1.vector 将（通过一个指向所分配的内存块的指针变量）保留原始的数组，数组容量以及数组当时存储在 vector 中的项数。

2.该 vector 将实现五大函数以提供为拷贝构造函数 和 operator= 的深层拷贝功能，并将提供一个析构函数以回收原始数组。此外，它还将实现 c++11的移动功能。

3.vector 将提供改变 vector 的大小（一般改成更大的数）的 resize 例程，以及 reserve 例程，后者将改变 vecotr 的容量（一般是更大的数）。这个容量通过为原始数组获取新的内存块，把老内存块复制到新内存块并回收老内存块而得以更新。

4.vector 将提供operator[] 的实现。

5.vector 将提供size ，empty ,clear ,back ,pop_back ,push_back等基本例程。

6.对于内嵌函数提供支持。

 

#include <algorithm>
template <typename object>
class vector{
    public:
    explicit vector(int initsize=0):thesize(initsize),
    thecapacity{initsize+spare_capacity}
    {
        objects = new object[thecapacity];
    }

    vector(const vector &rhs):thesize{rhs.thesize},
    thecapacity{rhs.thecapacity},objects{nullptr}{
        objects = new object[thecapacity];
        for (int k = 0; k < thesize;++k)
            objects[k] = rhs.objects[k];
    }

    vector & operator= (const vector &rhs)
    {
        vector copy = rhs;
        std::swap(*this, copy);
        return *this;
    }

    ~vector() {
        delete[] objects;
    }

    vector(vector && rhs):thesize{rhs.thesize},
    thecapacity{rhs.thecapacity},objects{rhs.objects}{
        rhs.objects = nullptr;
        rhs.thesize = 0;
        rhs.thecapacity = 0;
    }

    vector & operator=(vector && rhs){
        std::swap(thesize, rhs.thesize);
        std::swap(thecapacity, rhs.thecapacity);
        std::swap(objects, rhs.objects);

        return *this;
    }

    void resize(int newsize){
        if(newsize>thecapacity)
            reserve(newsize * 2);
        thesize = newsize;
    }

    void reserve(int newcapacity){
        if(newcapacity<thesize)
            return;
        object *newarray = new object[newcapacity];
        for (int k = 0; k < thesize;++k)
            newarray[k] = std::move(objects[k]);
        thecapacity = newcapacity;
        std::swap(objects, newarray);
        delete []newarray;
    }

    objcet & 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);
        object[thesize++] = x;
    }

    void push_back(object && x){
        if(thesize == thecapacity)
        reserve(2 * thecapacity + 1);
        object[thesize++] = std::move(x);
    }

    void pop_back(){
        --thesize;
    }

    const object & back()const{
        return objects[thesize - 1];
    }

    typedef object * iterator;
    typedef const object * const_iterator;

    iterator begin(){
        reutrn &objects[0];
    }

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

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

    const_iterator end()const{
        return &objects[size()];
    }
    
    static const int spare_capacity = 16;

    private:
        int thesize;
        int thecapacity;
        object *objects;
};