티스토리 뷰

추가되는 사항

    • C++에서 함수를 구별하는 방법은 함수의 이름 뿐만 아니라 인자값으로도 구별한다.
      class Object {
          public:
          void foo() {
              std::cout << "foo()" << std::endl;
          }
      
          void foo(int i) {
              std::cout << "foo(int)" << std::endl;
      };
      
      int main() {
          Object o;
          foo();
          foo(10);
      
          return 0;
      }
      
      foo()
      foo(int)

      이때 foo()와 foo(int)는 서로 다른 함수로 작동하며 컴파일러가 매개변수에 맞게 찾는다.

목표

    • 함수 오버로딩을 이용하여 같은 기능을 하는 함수를 인자값만 달리하여 선언, 정의한다.

디자인

    • 다음 멤버 함수가 추가됩니다.
      • void add(int index, int element)
        index번째에 element를 삽입한다.

      • void shiftLeft(int offset, int width)
        offset번째 이후의 모든 원소를 앞으로 width칸 옮긴다.

      • void shiftRight(int offset, int width)
        offset번째 이후의 모든 원소를 뒤로 width칸 옮긴다.

구현

#include <iostream>
#include <algorithm>

constexpr int INITIAL_SIZE = 10;

class vector {
    private:
    int* data;
    int capacity;
    int length;
    
    bool ensure_capacity(int to_add) const {
        return length + to_add < capacity;
    }
    
    void increase_capacity() {
        auto tmp = data;
        data = new int[capacity * 2];
        std::copy(tmp, tmp + length, data);
        delete[] tmp;
        capacity *= 2;
    }
    
    void shiftLeft(int offset, int width) {
        int tail_length = length - offset - width;
        int* tail = new int[tail_length];
        std::copy(data + offset + width, data + length, tail);
        std::copy(tail, tail + tail_length, data + offset);
        delete[] tail;
    }
    
    void shiftRight(int offset, int width) {
        int tail_length = length - offset;
        int* tail = new int[tail_length];
        std::copy(data + offset, data + length, tail);
        std::copy(tail, tail + tail_length, data + offset + width);
        delete[] tail;
    }
    
    public:
    vector() {
        data = new int[INITIAL_SIZE];
        capacity = INITIAL_SIZE;
        length = 0;
    }
    
    vector(const vector& v) {
        data = new int[v.capacity];
        capacity = v.capacity;
        length = v.length;
        std::copy(v.data, v.data + v.length, data);
    }
    
    ~vector() {
        delete[] data;
    }
    
    void add(int element) {
        if (!ensure_capacity(1))
            increase_capacity();
        
        *(data + length++) = element;
    }
    
    void add(int index, int element) {
        if (!ensure_capacity(1))
            increase_capacity();
        
        shiftRight(index, 1);
        *(data + index) = element;
        length++;
    }
    
    int get(int index) const {
        return *(data + index);
    }
    
    int set(int index, int element) {
        auto tmp = *(data + index);
        *(data + index) = element;
        return tmp;
    }
    
    int remove(int index) {
        auto tmp = *(data + index);
        shiftLeft(index, 1);
        length--;
        
        return tmp;
    }
    
    void print() const {
        std::cout << '{';
        for (int i = 0; i < length; i++)
            std::cout << *(data + i) << ((i < length - 1) ? ", " : "");
        std::cout << '}' << std::endl;
    }
};


댓글
댓글쓰기 폼