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