[C++] 오버로딩/오버라이딩

함수 오버로딩

• 이름은 같지만 매개변수의 타입 혹은 개수가 다른 함수
• 반환형이 다른 것은 인정되지 않음
• bool과 string으로만 오버로딩 할 경우 char형 배열/포인터는 string이 아닌 bool형으로 판단
• 코드

   #include <iostream>
   #include <string>
      
   using namespace std;
      
   void func(const int& i) { cout << "func(const int& i)" << endl; }
   void func(const bool& bArg) { cout << "func(const bool &bArg)" << endl; }
   void func(const string& s) { cout << "func(const string& s)" << endl; }
      
   int main() {
       func(1);
       func(true);
       func("abc");
       func(string("abc"));
      
       return 0;
   }
  

• 실행 결과

   func(const int& i)
   func(const bool &bArg)
   func(const bool &bArg)
   func(const string& s)
  

연산자 오버로딩

• 디폴트 대입 연산자
  • 디폴트 복사 생성자와 마찬가지로 얕은 복사를 하므로 주의
• +, -, *, /의 경우 a = b + c + b 등의 식을 계산할때 상식적인 의미 전달을 위해 일반적으로는 반환형을 레퍼런스로 선언하지 않음
• 자기 자신을 리턴하지 않는 연산자(+, -, *, /)는 외부 함수로 선언하는 것이 원칙
• 코드

   #include <iostream>
   #include <string>
      
   using namespace std;
      
   class Test {
       private:
           int i = 0;
      
       public:
           Test(const int& i) : i(i){};
           Test(const Test& t) : i(t.i) {}
           ~Test() = default;
      
           Test& operator+=(const Test& t) {
               (*this) = (*this) + t;
               return *this;
           }
           Test& operator-=(const Test& t) {
               (*this) = (*this) - t;
               return *this;
           }
           Test& operator*=(const Test& t) {
               (*this) = (*this) * t;
               return *this;
           }
           Test& operator/=(const Test& t) {
               (*this) = (*this) / t;
               return *this;
           }
      
           Test& operator=(const Test& t) {
               this->i = t.i;
               return *this;
           }
      
           Test& operator++() {
               *this += 1;
               return *this;
           }
           Test operator++(int) {
               Test t(*this);
               *this += 1;
               return t;
           }
      
           Test& operator--() {
               *this -= 1;
               return *this;
           }
           Test operator--(int) {
               Test t(*this);
               *this -= 1;
               return t;
           }
      
           bool operator==(const Test& t) const { return this->i == t.i; }
      
           friend Test operator+(const Test& t1, const Test& t2);
           friend Test operator-(const Test& t1, const Test& t2);
           friend Test operator*(const Test& t1, const Test& t2);
           friend Test operator/(const Test& t1, const Test& t2);
      
           friend ostream& operator<<(ostream& os, const Test& t);
   };
   Test operator+(const Test& t1, const Test& t2) { return Test(t1.i + t2.i); }
   Test operator-(const Test& t1, const Test& t2) { return Test(t1.i - t2.i); }
   Test operator*(const Test& t1, const Test& t2) { return Test(t1.i * t2.i); }
   Test operator/(const Test& t1, const Test& t2) { return Test(t1.i / t2.i); }
   ostream& operator<<(ostream& os, const Test& t) {
       os << t.i;
       return os;
   }
      
   class Test2 {
       private:
           string s = "";
      
       public:
           Test2(const string& s) : s(s) {}
      
           char& operator[](const int index) { return this->s.at(index); }
   };
      
   class Integer {
       private:
           int i = 0;
      
       public:
           Integer(const int& i) : i(i){};
           Integer(const Integer& t) : i(t.i) {}
           ~Integer() = default;
      
           operator int() { return this->i; }
   };
      
   int main() {
       Test t1(1);
       Test t2(2);
       Test t3(3);
       cout << t1 + t2 << endl;
       cout << t1 - t2 << endl;
       cout << t1 * t2 << endl;
       cout << t1 / t2 << endl;
       cout << (t1 += t2) << endl;
       cout << (t1 -= t2) << endl;
       cout << (t1 *= t2) << endl;
       cout << (t1 /= t2) << endl;
       cout << (t1 = t2) << endl;
       cout << (t1 == t2) << endl;
       cout << (t1 == t3) << endl;
       cout << t3++ << endl;
       cout << ++t3 << endl;
       cout << t3-- << endl;
       cout << --t3 << endl;
      
       Test2 t4("abc");
       cout << t4[1] << endl;
      
       Integer i = 1;
       int ii = i + 2;
       cout << i << ", " << ii << endl;
      
       return 0;
   }
  

• 실행 결과

   3
   -1
   2
   0
   3
   1
   2
   1
   2
   1
   0
   3
   5
   5
   3
   b
   1, 3
  

함수 오버라이딩

• 기반 클래스의 함수를 파생 클래스가 재정의
• 오버라이드가 안되는 실수를 맞기 위해 오버라이딩된 함수에 override 키워드를 통해 명시적으로 선언해주는 것을 권장
• 코드

   #include <iostream>
      
   using namespace std;
      
   using namespace std;
      
   class Base {
       public:
           virtual void func() { cout << "Base()::func" << endl; }
   };
      
   class Derived : public Base {
       public:
           virtual void func() override { cout << "Derived()::func" << endl; }
   };
      
   int main(void) {
       Base b1;
       b1.func();
      
       cout << "------" << endl;
      
       Derived d;
       d.func();
      
       cout << "------" << endl;
      
       Base& b2 = d;
       b2.func();
      
       return 0;
   }
  

• 실행 결과

   Base()::func
   ------
   Derived()::func
   ------
   Derived()::func