[STL] 연산자 오버로딩

연산자 오버로딩의 이해

C++에서는 연산자를 오버로딩하여 기존에 존재하던 연산자의 기능 이외에 다른 기능을 추가할 수 있다.

#include <iostream>

using namespace std;

class Point{
// 좌표 값
private:
  int x, y;

public:
  Point(int x, int y){
    this->x = x;
    this->y = y;
  }

  void showInfo(){
    cout << "(" << this->x << ", " << this->y << ")";
  }

  // 더하기 연산자 오버로딩
  Point operator+(const Point & ref){
    Point pos(x + ref.x, y + ref.y);
    return pos;
  }
};

int main(){
  Point p1(1, 1);
  Point p2(3, 4);

  /**
   *  p1 + p2는
   *  컴파일러가 p1.operator+(p2) 로 인식한다.
   */
  Point p3 = p1 + p2;
  p3.showInfo();// (4,5) 출력

  return 0;
}

#include <iostream>

using namespace std;

class Point{
// 좌표 값
private:
  int x, y;

public:
  Point(int x, int y){
    this->x = x;
    this->y = y;
  }

  void showInfo(){
    cout << "(" << this->x << ", " << this->y << ")";
  }

  // friend 선언으로 private 값에 접근 가능
  friend Point operator+(const Point & p1, const Point & p2);  
}

Point operator+(const Point & p1, const Point & p2){
  Point pos(x + ref.xpos, y + ref.ypos);
  return pos;
}

연산자 오버로딩의 주의사항

• 본래의 의도를 벗어난 형태의 오버로딩은 좋지 않다.
• 연산자의 우선순위와 결합성은 바뀌지 않는다.
• 매개변수의 디폴트 값 설정이 불가능하다.
• 연산자의 순수 기능까지 빼앗을 수는 없다. (오버라이딩 불가)

증감연산자 오버로딩

class Point{
// 좌표 값
private:
  int x, y;

public:
  Point(int x, int y){
    this->x = x;
    this->y = y;
  }

  /**
   *  prefix 증가 연산자
   *  lvalue를 return. ++(++num) 같은 연산이 가능
   */
  Point& operator++(){
	  x += 1;
	  y += 1;
	  
	  return *this;
  }

  /**
   *  postfix 증가 연산자
   *  parameter에 int는 전위연산과 구분하기 위함이다. 다른 의미는 없다.
   *  rvalue를 return. (num++)++ 같은 연산은 컴파일 에러
   */
  const Point operator++(int){
	  const Point ret(x, y);
	  x += 1;
	  y += 1;
	  return ret;
  }
}

교환 법칙 문제

class Point{
// 좌표 값
private:
  int x, y;

public:
  Point(int x, int y){
    this->x = x;
    this->y = y;
  }

  Point operator*(int times){
	  Point pos(x * times, y * times);
	  return pos;
  }

  /**
   *  위의 함수만 정의하면 
   *  Point p2 = 2 * p1;
   *  해당 식을 실행할 수 없다.
   *  교환 법칙을 위해서는 별도로 외부 선언이 필요하다.
   */
   friend Point operator*(int times, Point & ref);
};

friend Point operator*(int times, Point & ref){
	Point pos(ref.x * times, ref.y * times);
	return pos;
}

cout, cin, endl

입출력에 사용되는 << 또한 연산자이며 구조는 대략 다음과 같다.

namespace mystd{
	using namespace std;

	class ostream:{
	public:
		Ostream& operator<< (char * str){
			printf("%s", str);
			return *this;
		}
		
		Ostream& operator<< (char str){
			printf("%c", str);
			return *this;
		}
		
		Ostream& operator<< (int num){
			printf("%d", num);
			return *this;
		}
		
		Ostream& operator<< (double e){
			printf("%f", e);
			return *this;
		}
		
		Ostream& operator<< (ostream& (*fp)(Ostream &ostm)){ // 함수 포인터
			return fp(*this); // 해당 함수 실행
		}

		Ostream& endl(ostream &ostm){
			ostm<<'\n';
			flush(stdout);
			return ostm;
		}
	}

	ostream cout;
}

int main(){
	using mystd::cout;
	using mystd::endl;
	
	cout<<33<<endl;
	
	return 0;
}

이를 이용해서 객체의 출력도 cout를 통해서 할 수 있다.

class Point{
private:
	..
public:
	..
	Friend ostream& operator<<(ostream&, const Point&);
}

Ostream& operator<<(ostream& os, const Point pos){
	os << '['  << pos.xpos << ", " << pos.ypos << "]";
	return os;
}

대입 연산자 오버로딩

대입연산자도 오버로딩이 가능하며, 이는 Copy constructor의 특성과 비슷하다.

• 정의하지 않으면 디폴트 대입 연산자가 삽입된다.
• 디폴트 대입 연산자는 shallow copy이다.
• deep copy 필요시 직접 정의해야한다.

int main(){
	Point pos1(5, 7);
	Point pos2 = pos1; // Copy constructor에 의한 객체 생성

	Point pos3(9, 10); 
	pos3 = pos1; // 두 객체 모두 초기화가 진행된 상태이며 대입 연산자 실행
}

상속 구조에서의 대입 연산자 호출

• 생성자 : 자식 클래스의 생성자는 아무런 명시를 하지 않아도, 부모 클래스의 생성자를 호출한다.
• 대입 : 자식 클래스에서 명시를 하지 않으면, 부모 클래스의 대입 연산자가 호출되지 않고 멤버 대 멤버 복사를 진행할 수 없다,

배열의 인덱스 연산자 오버로딩

#include <iostream>

using namespace std;

class BoundaryCheckIntArray{
private:
	int * arr;
	int arrlen;
	
	BoundaryCheckIntArray(const BoundaryCheckIntArray& arr);
	BoundaryCheckIntArray& operator=(const BoundaryCheckIntArray& arr);
	// BoundaryCheckIntArray cpy1 = orgin, cpy2 = orgin 같은 문장을 막기 위해 private로 선언

public:
	BoundaryCheckIntArray(int len) 
	: arrlen(len)
	{
		arr = new int[len];
	}
	
	int& operator[](int idx){
		if(idx < 0 || idx >= arrlen){
			cout << "out of index" << endl;
			exit(1);
		}
		
		return arr[idx];
	}
	
	// 단순 값 참조를 위한 const 함수 오버로딩
	// 함수의 const 선언 유무도 오버로딩의 조건에 해당한다.
	int& operator[](int idx) const{ 
		if(idx < 0 || idx >= arrlen){
			cout << "out of index" << endl;
			exit(1);
		}
		
		return arr[idx];
	}
	
	~BoundaryCheckIntArray(){
		delete[] arr;
	}
};

int main(){
	BoundaryCheckIntArray mArr(10);
	
  mArr[0] = 1;
  mArr[1] = 2;
  cout << mArr[1] << endl;
}