C++ STL：vector实现

#include <iostream>
#include <cstdlib>
#include <vector>
#include <algorithm>

using namespace std;

class Object {
public:
    static int count;
public:
    int current;
    int id;
    Object(int i) {
        id = i;
        current = count++;
        cout<<"object["<<id<<"] create : "<<current<<endl;
    }
    
    ~Object() {
        cout<<"object["<<id<<"] destroy: "<<current<<endl;
    }

    Object(const Object& obj) {
        current = count++;
        id = obj.id;
        cout<<"object["<<id<<"] copied : "<<current<<" old : "<<obj.current<<endl;
    }
};

int Object::count = 0;

template<class T>
class MyVector {
public:
    typedef T               value_type;
    typedef value_type*     pointer;
    typedef value_type*     iterator;
    typedef value_type&     reference;
    typedef size_t          size_type;
    typedef ptrdiff_t       difference_type;
    
private:
    iterator  start;
    iterator  finish;
    iterator  space_end;
public:
    MyVector() {
        start = NULL;
        space_end = NULL;
        finish = NULL;
    }
    
    size_type capacity() {return space_end - start;}
    size_type size() { return finish - start; }

    bool empty() { return start == finish; }
    iterator begin() {return start;}
    iterator end() {return finish;}
    
    reference operator[] (int idx) {return start[idx];}
    reference front() {return *start;}
    reference back() {return *(finish-1);}
    
    void clear() {

    }
    
    void pop_back() {
        if (start >= finish) {
            return;
        }
        finish--;
        finish->~T();
    }
    
    void push_back(const T& x) {
        if (finish < space_end) {
            // placement new
            new (finish) T(x);
            // adjust end pointer
            finish++;
        } else if (space_end == finish){
            // space not enough
            int olen = finish - start;
            int nlen = olen == 0 ? 1 : olen * 2;
            T* new_start = (T*) malloc(nlen * sizeof(T));
            T* new_finish = new_start;
            for (int i=0; i<olen; i++) {
                // copy old data to new space
                new (new_finish++) T(*(start + i));
            }
            // append pushed element
            new (new_finish++) T(x);

            // deconstruct old ones
            for (int i=0; i<olen; i++) {
                (start+i)->~T();
            }
            free(start);
            
            start = new_start;
            finish= new_finish;
            space_end = start + nlen;
        } else {
            // state invalid
            cerr<<"error"<<endl;
        }
    }
    
    ~MyVector() {
        for (T* s=start; s<finish; s++) {
            s->~T();
        }
        free(start);
    }
};

#define USE_ORG 0
int main() {

    long* a = NULL;
    long* b = a + 1;
    int n = (char*)b - (char*)a;
    
    cout<<n<<endl;
    
    
    
    int last_capacity =-1;
    Object::count = 0;
    
#if USE_ORG
    vector<Object> tmp;
#else
    MyVector<Object> tmp;
#endif

    for (int i=0; i<5; i++) {
        tmp.push_back(Object(i));
        if (last_capacity != tmp.capacity()) {
            cout<<"======last cap:"<<last_capacity<<" new capacity:"<<tmp.capacity()<<endl;
            last_capacity = tmp.capacity();
        }

        cout<<"\n\n"<<endl;
    }

    MyVector<int> ints;
    ints.push_back(2);
    ints.push_back(3);
    ints.push_back(1);
    
    sort(ints.begin(), ints.end());
    
    for (int i:ints) {
        cout<<i<<endl;
    }
    
    system("pause");
    return 0;
}