[C to C++] 함수 오버로딩

추가되는 사항

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