my C++ vector

#define __DESTRUCTOR(ty, ptr)   (ptr)->~ty()
#define __CONSTRUCTOR(ty, ptr)  (*ptr) = ty()
#define _vector_start _vector_data
#define _vector_capacity (_vector_end - _vector_start)
#define _vector_size (_current - _vector_start)

template <class T>
class tVector
{

public:

    inline tVector() : _vector_data((T*) new char[sizeof(T) * 1]),
    _current(_vector_start), _vector_end(_vector_data + 1){}

    inline tVector(int nElements) : _vector_data(new char[sizeof(T) * nElements]),
    _current(&_vector_data[nElements]), _vector_end(_current){}

    inline tVector(int nElements, const T& val) : _vector_data((T*) new char[sizeof(T) * nElements]), _vector_end(_vector_data + nElements){
        for(_current = _vector_data;_current != _vector_end;){*_current++ = val;}
    }

    inline tVector(tVector<T> &object){
        if((_vector_capacity) < object.size()) allocate(object.size());
        memcpy(_vector_data, object._vector_data, object.size() * sizeof(T));
        _current = _vector_start + object.size();
    }

    inline operator= (tVector<T> &object){
        if((_vector_capacity) < object.size()) allocate(object.size());
        memcpy(_vector_data, object._vector_data, object.size() * sizeof(T));
        _current = _vector_start + object.size();
    }

    inline ~tVector(){delete [](char*)_vector_data;}

    inline void push_back(const T &t){
        if(_current == _vector_end)double_size();*_current++ = t;
    }

    inline T& push_back_and_access(const T &t){
        if(_current == _vector_end)double_size();*_current++ = t;return _current[-1];
    }

    inline void pop_back(){_current -= (_current != _vector_start);}
    inline void pop_back_and_destroy(){
        if(_current != _vector_start){_current--;__DESTRUCTOR(T, _current]);}}

    inline void resize(size_t size){
        if((_vector_size) == size)return;

        T *it;
        if((_vector_size) < size){
        if((_vector_capacity) < size)
        {
            T *_temp = (T*) new char[sizeof(T) * size];
            _current = _temp + (_vector_size);
            memcpy(_temp, _vector_data, (unsigned int)((char*)_vector_end - (char*)_vector_start));
            _vector_end = (_temp + size);
            delete [] (char*)_vector_data;_vector_data = _temp;return;
        }else
        {
            it = _current;
            _current = (_vector_start + size);
            for(;it < _current;it++)__CONSTRUCTOR(T, it);
        }}
        else
        {
            it = _current;
            _current = (_vector_start + size);

            if(it != _current)
            do{it--;__DESTRUCTOR(T, it);}while(it != _current);

        }
    }

    inline void resize(size_t size, const T& val){
        if((_vector_size) == size)return;

        T *it;
        if((_vector_size) < size){
        if((_vector_capacity) < size)
        {
            T *_temp = (T*) new char[sizeof(T) * size];
            _current = _temp + (_vector_size);
            memcpy(_temp, _vector_data, (unsigned int)((char*)_vector_end - (char*)_vector_start));
            _vector_end = (_temp + size);
            delete [] (char*)_vector_data;_vector_data = _temp;return;
        }else
        {
            it = _current;
            _current = (_vector_start + size);
            for(;it < _current;)*it++ = val;
        }}
        else
        {
            it = _current;
            _current = (_vector_start + size);

            if(it != _current)
            do{it--;__DESTRUCTOR(T, it);}while(it != _current);

        }
    }

    inline T* insert(T * pos, const T &val){
        if(pos >= _current)return 0;
        unsigned int _pos = (pos - _vector_start);
        if(_current == _vector_end)
            {double_size();pos = _vector_start + _pos;}

        for(T *it = _current++;it != pos;)*it-- = it[-1];
        *pos = val;return pos;
    }

    inline void insert(T * pos, size_t n, const T &val){
        if(pos >= _current)return;
        unsigned int _pos = (pos - _vector_start);

        _current += n;
        if(_current >= _vector_end)
            {double_size();pos = _vector_start + _pos;}

        T *end = pos + n;
        for(T *it = _current - n - 1;it >= pos;)
                it[n] = *it--;

        for(;pos != end;)*pos++ = val;
    }

    inline void insert(T * pos, T* first, T *last){
        if(pos >= _current || first >= last)return;
        unsigned int _pos = (pos - _vector_start);

        _current += (last - first);
        if(_current >= _vector_end)
            {double_size();pos = _vector_start + _pos;}

        int n =  (last - first);
        T *end = pos + n;
        for(T *it = _current - n - 1;it >= pos;)
                it[n] = *it--;
        for(;pos != end;)*pos++ = *first++;
    }

    inline void assign(size_t size, const T &val){if(!size)return;
        if(_current != _vector_start)
            for(T *it = _vector_data;it < _current;it++)__DESTRUCTOR(T, it);
        if((_vector_capacity) < size)allocate(size);
        _current = _vector_start + size;

        for(T *it = _vector_start;it < _current;){*it++ = val;}
    }

    inline void shrink_to_fit(){
    if(_current == _vector_end || _current == _vector_start)return;

        T *_temp = (T*) new char[sizeof(T) * (_vector_size)];
        memcpy(_temp, _vector_data, (unsigned int)((char*)_current - (char*)_vector_start));
        _current = _temp + (_vector_size);
        delete [] (char*)_vector_data;_vector_data = _temp;_vector_end = _current;
    }

    inline void reverse(int count = 0){
        size_t half_size = ((unsigned int)(_vector_size)) / 2;
        if(count && count < half_size)half_size = count;
        char temp[sizeof(T)]; //avoid constructors
        T*_end = _vector_end - 1;

    for(int i = 0;i < half_size;i++)
        {
            *((T*)temp) = (_vector_start)[i];
            (_vector_start)[i] = (_end)[-i];
            (_end)[-i] = *((T*)temp);
        }
    }

    inline void erase(unsigned int pos){
        if(_current == _vector_start || pos >= (_vector_size))return;
        __DESTRUCTOR(T, &_vector_data[pos]);

        for(T *it = &_vector_data[pos + 1];it < _current;){it[-1] = *it++;}
        _current--;
    }

    inline void erase(T *pos){
        if(pos >= _current)return;
        __DESTRUCTOR(T, pos);

        T *__current = _current--;
        for(pos++;pos < __current;){pos[-1] = *pos++;}
    }

    inline void erase(T *first, T *last){
        if(last >= _current)return;

        for(T *it = first;it < last;it++)
            {__DESTRUCTOR(T, it);}

        T *__current = _current;
        _current -= (last - first);
        for(;it < __current;){*first++ = *it++;}

    }

    inline void erase(unsigned int first, unsigned int last){
        unsigned int range = last - first;
        if(first >= last || (_current - range < _vector_start) || last >= (_vector_size))return;

        T *end = &_vector_data[last];
        for(T *it = &_vector_data[first];it < end;it++)
            {__DESTRUCTOR(T, it);}
        range = -range;

        for(;it < _current;){it[range] = *it++;}
        _current += range; //it's negative
    }


    inline void swap(tVector <T> &obj){
        T *__current = _current;
        T *__vector_start = _vector_start;
        T *__vector_end = _vector_end;
        _current = obj._current;
        _vector_start = obj._vector_start;
        _vector_end = obj._vector_end;
        obj._current = __current;
        obj._vector_start = __vector_start;
        obj._vector_end = __vector_end;
    }

    inline void clear(bool bDestroy = false){
        if(bDestroy)for(T *it = _vector_data;it < _current;it++){__DESTRUCTOR(T, it);}
    _vector_end = _vector_start;_current = _vector_data;}

    inline void reset(){_current = _vector_start;}
    inline void reserve(size_t max){if(max > (_vector_capacity))new_size(max);}
    inline size_t size() const {return _vector_size;}
    //inline void set_size(size_t new_size){if(new_size < vector_capacity)_current = _vector_start + new_size;}
    inline T& at(unsigned int index) const {return _vector_start[index];}
    inline bool empty(){return ((_vector_capacity) <= 0);}
    inline T* data() const {return _vector_start;}
    inline T* begin() const {return _vector_start;}
    inline T* end() const {return _current;}
    inline T& front() const {return *_vector_start;}
    inline T& back() const {return _current[-1];}
    inline size_t capacity() const {return (_vector_capacity);}
    T& operator[] (unsigned int index) const {return _vector_start[index];}
    inline size_t max_size() const {allocator<T> obj;return obj.max_size();}

    _PROTECTED :
        T *_vector_data, *_current, *_vector_end;

    private :

    inline void allocate(size_t size){
        delete [] _vector_data;
        _vector_data = (T*) new char[sizeof(T) * size];
        _current = _vector_start;
        _vector_end = (_vector_start + size);
    }


    inline void double_size(){
        T *_temp = (T*) new char[sizeof(T) * (unsigned int)(_vector_capacity) * 2];
        _current = _temp + (_vector_capacity);
        memcpy(_temp, _vector_data, (unsigned int)((char*)_vector_end - (char*)_vector_data));
        _vector_end = _temp + (_vector_capacity) * 2;
        delete [] (char*)_vector_data;_vector_data = _temp;
    }

            inline void new_size(size_t size)
    {
        T *_temp = (T*) new char[sizeof(T) * size];
            _current = _temp + (_vector_size);
            memcpy(_temp, _vector_data, (unsigned int)((char*)_vector_end - (char*)_vector_data));
            _vector_end = _temp + size;
            delete [] (char*)_vector_data;_vector_data = _temp;
    }
};
#undef __DESTRUCTOR
#undef __CONSTRUCTOR
#undef _array_start
#undef _vector_capacity
#undef _vector_size