[STL] vector #4

vector 직접 만들기

template<typename T>
class Vector
{
    public:
        Vector()
            : _cata(nullptr), _size(0), _capacity(0)
        {
        }
		
        ~Vector()
        {
            if (_data)
                delete[] _data;
        }

        T& operator[](const int pos) { return _data[pos]; }

    public:
        void push_back(const T& val)
        {
            if (_size == _capacity)
            {
                // 증설 작업
                int newCapacity = static_cast<int>(_capacity * 1.5);
				
                // capacity가 0 or 1 이면 0과 1.5 짤려서 1을 반환하기 때문에 체크
                if (newCapacity == _capacity)
                    newCapacity++;

                reserve(newCapacity);
            }

            _data[_size] = val;
        }

        void reserve(int capacity)
        {
            _capacity = capacity;

            T* newData = new T[_capacity];

            // 데이터 복사
            for (int i = 0; i < _size; i++)
                newData[i] = _data[i];

            // 기존에 있던 데이터 날린다.
            if (_data)
                delete[] _data;

            _data = newData;
        }

        int size() { return _size; }
        int capacity { return _capacity; }

    private:
        T* _data;
        int _size;
        int _capacity;
}

 

iterator 추가

template<typename T>
class Iterator
{
    public:
        Iterator()
            : _ptr(nullptr)	
        {
        }

        Iterator(T* ptr)
            : _ptr(ptr)
        {
        }

        Iterator& operator++()
        {
            _ptr++;
            return *this;
        }

        Iterator operator++(int)
        {
            Iterator temp = *this;
            _ptr++;
            return temp;
        }

        Iterator operator+(const int count)
        {
            Iterator temp = *this;
            temp._ptr += count;
            return temp;
        }

        bool operator==(const Iterator& right)
        {
            return _ptr == right_ptr;
        }

        bool operator!=(const Iterator& right)
        {
            return !(*this == right);
            //return _ptr != right_ptr;
        }

        T& operator*()
        {
            return *_ptr;
        }

    public:
        T* _ptr;
}

template<typename T>
class Vector
{
    public:
        Vector()
            : _cata(nullptr), _size(0), _capacity(0)
        {
        }
		
        ~Vector()
        {
            if (_data)
                delete[] _data;
        }

        T& operator[](const int pos) { return _data[pos]; }

    public:
        void push_back(const T& val)
        {
            if (_size == _capacity)
            {
                // 증설 작업
                int newCapacity = static_cast<int>(_capacity * 1.5);
				
                // capacity가 0 or 1 이면 0과 1.5 짤려서 1을 반환하기 때문에 체크
                if (newCapacity == _capacity)
                    newCapacity++;

                reserve(newCapacity);
            }

            _data[_size] = val;
        }

        void reserve(int capacity)
        {
            _capacity = capacity;

            T* newData = new T[_capacity];

            // 데이터 복사
            for (int i = 0; i < _size; i++)
                newData[i] = _data[i];

            // 기존에 있던 데이터 날린다.
            if (_data)
                delete[] _data;

            _data = newData;
        }

        int size() { return _size; }
        int capacity { return _capacity; }

    public:
        typedef Iterator<T> iterator;
		
        iterator begin() { return iterator(&_data[0]); }
        iterator end() { return begin() + _size; }

    private:
        T* _data;
        int _size;
        int _capacity;
}