#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 = ;

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-);}

    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 ==  ?  : olen * ;

            T* new_start = (T*) malloc(nlen * sizeof(T));

            T* new_finish = new_start;

            for (int i=; 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=; 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 + ;

    int n = (char*)b - (char*)a;

    cout<<n<<endl;

    int last_capacity =-;

    Object::count = ;

#if USE_ORG

    vector<Object> tmp;

#else

    MyVector<Object> tmp;

#endif

    for (int i=; i<; 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();

    ints.push_back();

    ints.push_back();

    sort(ints.begin(), ints.end());

    for (int i:ints) {

        cout<<i<<endl;

    }

    system("pause");

    return ;

}