C++ Vector 구현하기

Don’t reinvent the wheel; use libraries.

From <The C++ Programming Language> by Bjarne Stroustrup

들어가기에 앞서

앞으로 게시될 일련의 게시물들은 STL을 쓰지 못하는 특정 상황을 위해 STL과 비슷하게 동작하는 container, data structure, algorithm 등을 구현한 것 들입니다.
STL 상의 모든 함수들을 구현하지는 못하였지만(특히 iterator 관련…) 사용하는데 큰 지장은 없을 것 입니다.

STL을 사용할 수 있는 상황이라면 STL을 사용하도록 합시다. 나보다 똑똑한 사람들이 나보다 더 많은 시간을 들여서 작성하고 최적화한 코드입니다.

구현된 STL-like 자료 구조들은 Github Repo에서도 확인 하실 수 있습니다.

혹시나 있을 버그는 댓글 혹은 이메일로 제보해 주시면 수정하도록 하겠습니다.

Documents

FunctionDescription
operator[]Returns a reference to the element at position n in the vector container.
begin()Return iterator to beginning.
end()Return iterator to end.
front()Returns a reference to the first element in the vector.
back()Returns a reference to the last element in the vector.
push_back(T&)Adds a new element at the end of the vector, after its current last element.
pop_back()Removes the last element in the vector.
resize(size_type n)Resizes the container so that it contains n elements.
If n is smaller than the current container size, the content is reduced to its first n elements.
If n is greater than the current container size, the content is expanded by inserting at the end as many elements as needed to reach a size of n.
swap(Vector& x)Exchanges the content of the container by the content of x, which is another vector object of the same type. Sizes may differ.
capacity()Returns the size of the storage space currently allocated for the vector.
size()Returns the number of elements in the vector.
empty()Returns whether the vector is empty (i.e. whether its size is 0).
clear()Removes all elements from the vector. (capacity does NOT change.)

잡담

C++ container의 꽃 vector입니다.
막상 보면 구현이 어렵지는 않지만 없으면 세상 불편하고 직접 구현하자니 귀찮은 친구입니다.
Iterator를 구현하지 못한 점이 아쉽습니다만, 이외에 자주 사용하는 함수들은 대부분 구현되어 있습니다.

구현

#include <cstddef>
#include <utility>

template <typename T>
class  Vector {
private:
  using size_type = size_t;
  T* arr;
  size_type _size;
  size_type _capacity;
  static constexpr size_type DEFAULT_CAP = 32;

public:
  Vector(size_type cap = DEFAULT_CAP) : arr(new T[cap]), _size(0), _capacity(cap) {}
  Vector(const Vector& v) : arr(new T[v._capacity]), _size(v._size), _capacity(v._capacity) {
    for (size_type i = 0; i < _size; i++)
      arr[i] = v[i];
  }
  Vector(Vector&& v) : arr(std::move(v.arr)), _size(std::move(v._size)), _capacity(std::move(v._capacity)) {
    v.arr = nullptr;
    v._size = 0;
    v._capacity = 0;
  }

  ~Vector() { delete[] arr; }

  Vector& operator=(const Vector& other) {
    if (this != &other) {
      if (_capacity < other._capacity) {
        delete[] arr;
        _capacity = other._capacity;
        arr = new T[_capacity];
      }
      _size = other._size;
      for (size_type i = 0; i < _size; i++)
        arr[i] = other.arr[i];
    }
    return *this;
  }
  Vector& operator=(Vector&& other) {
    std::swap(arr, other.arr);
    std::swap(_size, other._size);
    std::swap(_capacity, other._capacity);
    other._size = 0;
    return *this;
  }

  inline T* begin() const { return arr; }

  inline T* end() const { return arr + _size; }

  inline T& front() { return arr[0]; }
  const inline T& front() const { return arr[0]; }

  inline T& back() { return arr[_size - 1]; }
  const inline T& back() const { return arr[_size - 1]; }

  inline T& operator[](size_type idx) { return arr[idx]; }
  const inline T& operator[](size_type idx) const { return arr[idx]; }

  void push_back(const T& val) {
    if (_size >= _capacity) {
      if (_capacity < DEFAULT_CAP)
        _capacity = DEFAULT_CAP;
      else
        _capacity *= 2;
      T *t_arr = new T[_capacity];
      for (size_type i = 0; i < _size; i++)
        t_arr[i] = arr[i];
      delete[] arr;
      arr = t_arr;
    }
    arr[_size++] = val;
  }
  void push_back(T&& val) {
    if (_size >= _capacity) {
      if (_capacity < DEFAULT_CAP)
        _capacity = DEFAULT_CAP;
      else
        _capacity *= 2;
      T *t_arr = new T[_capacity];
      for (size_type i = 0; i < _size; i++)
        t_arr[i] = arr[i];
      delete[] arr;
      arr = t_arr;
    }
    arr[_size++] = std::move(val);
  }

  void pop_back() { _size = _size > 0 ? _size - 1 : 0; }

  void resize(size_type n, T val = T()) {
    T *t_arr = new T[n];
    _size = _size < n ? _size : n;
    _capacity = n;
    for (size_type i = 0; i < _size; i++)
      t_arr[i] = arr[i];
    for (size_type i = _size; i < _capacity; i++)
      t_arr[i] = val;
    delete[] arr;
    arr = t_arr;
    _size = n;
  }

  void reserve(size_type n) {
    if (n <= _capacity)
      return;
    T *t_arr = new T[n];
    for (size_type i = 0; i < _size; i++)
      t_arr[i] = arr[i];
    delete[] arr;
    arr = t_arr;
    _capacity = n;
  }

  void swap(Vector& other) {
    std::swap(arr, other.arr);
    std::swap(_size, other._size);
    std::swap(_capacity, other._capacity);
  }

  inline size_type capacity() const { return _capacity; }
  inline size_type size() const { return _size; }
  inline bool empty() const { return _size == 0; }
  void clear() { _size = 0; }

  inline bool operator==(const Vector& other) const {
    if (_size != other._size)
      return false;
    for (size_type i = 0; i < _size; i++)
      if (arr[i] != other[i])
        return false;
    return true;
  }
  inline bool operator!=(const Vector& other) const { return !(*this == other); }
  inline bool operator< (const Vector& other) const {
    bool is_all_same = true;
    size_type min_size = _size < other._size ? _size : other._size;
    size_type idx = 0;
    for (; idx < min_size; idx++) {
      if (arr[idx] != other[idx]) {
        is_all_same = false;
        break;
      }
    }

    if (is_all_same) {
      if (_size < other._size)
        return true;
    } else {
      if (arr[idx] < other[idx])
        return true;
    }
    return false;
  }
  inline bool operator<=(const Vector& other) const { return !(other < *this); }
  inline bool operator> (const Vector& other) const { return (other < *this); }
  inline bool operator>=(const Vector& other) const { return !(*this < other); }
};
  • relational operators를 잘보면 ==< 두개만 실제로 구현해 두고 나머지는 그 두개를 호출하는 형식으로 구현되어 있습니다.
    이러한 방식을 통해 에러가 날 가능성이 줄어들고 유지보수가 간편해집니다.
  • vector 생성시 기본 capacity는 32 입니다. DEFAULT_CAP으로 해당 값을 수정할 수 있습니다.

© 2020. All rights reserved.