포인터끼리 더하는 것이 의미가 없는 것처럼 하루중의 한 시점을 가리키는 시각을 더하는 것은 사실 별 의미가 없다. 아침이 9:00이고 점심이 12:30일 때 이 둘을 더한 21:30은 어떤 의미도 부여할 수 없다. 그러나 경과 시간끼리 더하는 것은 분명히 의미가 있는데 밥먹는데 40분, 커피 마시는데 25분이 걸린다면 이 둘을 더한 1:5분은 밥먹고 커피 마시는데 필요한 시간이라고 할 수 있다.
시간을 표현하는 Time이라는 클래스를 정의했다면 시간끼리 더할 수 있는 방법도 제공할 필요가 있는데 시간이란 과연 어떻게 더할 수 있을까? 시간이라는 타입은 시, 분, 초의 세 가지 요소로 구성되며 적어도 int나 double 같은 기본 타입보다는 훨씬 더 복잡한 처리가 필요하다. 초는 초끼리 더하고 분은 분끼리 더해야 하며 시는 시끼리 각각 더하되 각 자리에서 60이 넘는 결과가 나오면 자리 올림 처리를 해야 한다. 예를 들어 1:26:42초라는 시간과 2:38:55초라는 시간을 더하면 3:64:97초가 되는 것이 아니라 4:5:37초가 되어야 한다.
사람은 시간이라는 포맷에 아주 익숙하고 일상 생활에서 늘상 사용하므로 쉽게 연산할 수 있지만 컴퓨터는 이런 복잡한 타입의 연산 방법을 모른다. Time 클래스에 대해 덧셈을 하는 멤버 함수를 정의해 보자. 다음 예제의 AddTime 멤버 함수는 또 다른 Time 객체 T를 인수로 전달받아 자기 자신과 더한 결과를 리턴한다. 시간끼리 덧셈 연산을 하므로 이 동작을 잘 설명할 수 있는 AddTime이라는 이름을 주었다.
|
예 제 : TimeAdd |
#include <Turboc.h>
class Time
{
private:
int hour,min,sec;
public:
Time() { }
Time(int h, int m, int s) { hour=h; min=m; sec=s; }
void OutTime() {
printf("%d:%d:%d\n",hour,min,sec);
}
const Time AddTime(const Time &T) const {
Time R;
R.sec=sec + T.sec;
R.min=min + T.min;
R.hour=hour + T.hour;
R.min += R.sec/60;
R.sec %= 60;
R.hour += R.min/60;
R.min %= 60;
return R;
}
};
void main()
{
Time A(1,1,1);
Time B(2,2,2);
Time C;
A.OutTime();
B.OutTime();
C=A.AddTime(B);
C.OutTime();
}
더하는 방법은 비교적 간단한데 임시 객체 R을 선언한 후 자기 자신과 T의 시, 분, 초를 각각 더해 R의 대응되는 멤버에 대입하고 자리 올림을 한다. 자리 올림은 나누기 연산자와 나머지 연산자를 적절히 활용하면 간단하게 처리할 수 있다. main 함수의 테스트 코드는 A와 B를 더해 C에 대입한 후 C를 출력해 본다. 실행 결과는 다음과 같다.
1:1:1
2:2:2
3:3:3
아주 간단한 연산을 해 보았는데 1:36:42와 5:42:29처럼 조금 복잡해 보이는 시간끼리 더해도 자리 올림까지 고려하여 7:19:11라는 정확한 연산을 한다. Time 클래스가 시간 포맷에 대해 캡슐화를 잘 하고 있으며 AddTime이라는 이름의 멤버 함수를 정의함으로써 시간 객체끼리 더하는 방법을 컴파일러에게 알려 주었으므로 main에서는 AddTime 함수를 호출하여 A와 B를 더하기만 하면 된다. 동작상의 문제는 전혀 없지만 연산을 위해 함수를 호출하는 방식이 연산자를 쓰는 방법에 비해 직관적이지 못하며 기본형의 연산문과 모양이 다르다는 것도 불만이다. 그래서 이런 동작을 하는 연산자 함수를 정의할 수 있다.
사실 연산자는 모양이 좀 특이한 함수라고 볼 수 있는데 인수를 취한다는 것과 연산 결과를 리턴한다는 점에서 함수와 공통적이다. 연산자 함수의 이름은 키워드 operator 다음에 연산자 기호를 써서 작성하는데 연산자 기호를 명칭으로 쓸 수 없으므로 operator라는 키워드를 앞에 두는 것이다. 덧셈 연산자 함수의 이름은 operator +가 되는데 중간의 공백은 무시되므로 operator+라고 붙여 써도 상관없다. 함수명은 명칭이므로 영문자, 숫자, _만 쓸 수 있지만 연산자 함수의 이름은 예외적으로 기호를 사용할 수 있다. 연산자 자체가 기호로 되어 있으므로 여기에는 예외를 적용할 수밖에 없다. 위 예제에서 AddTime이라는 함수의 이름을 operator +로 바꿔 보자.
class Time
{
....
const Time operator +(const Time &T) const {
....
}
};
리턴값, 인수, 본체는 그대로 두고 AddTime이라는 이름만 operator +로 바꾼 것 뿐이다. 이렇게 연산자 함수를 정의하면 이 클래스 타입의 객체를 좌변으로 가지는 + 연산자를 쓸 수 있다. main 함수의 AddTime 호출문도 다음과 같이 수정한다.
void main()
{
Time A(1,1,1);
Time B(2,2,2);
Time C;
A.OutTime();
B.OutTime();
C=A+B;
C.OutTime();
}
C=A.AddTime(B)가 C=A+B로 바뀌었는데 함수의 본체 코드가 똑같으므로 동작도 완전히 동일하다. AddTime이라는 함수의 이름이 operator +로 바뀌었고 함수를 호출하는 방법이 연산문으로 바뀌었을 뿐이다. C=A+B를 다음과 같이 작성해도 똑같이 동작한다.
C=A.operator +(B); // C=A+B; 와 같다.
C=A+B는 연산문이고 C=A.operator +(B)는 함수 호출문의 형태를 띠고 있을 뿐 실행되는 코드는 둘 다 동일하다. 표현만 다른 같은 구문이다. A+B 연산문에 중단점을 설정하고 디버거로 실행하여 함수 안쪽으로 파고 들어가 보면 이 연산문에 의해 operator + 함수가 호출된다는 것을 확인할 수 있다. 그렇다면 AddTime 일반 함수와 operator +연산자 함수는 과연 어떤 차이점이 있을까 비교해 보자.
첫 번째로 연산자 형태의 호출 방식이 길이가 짧아 타이핑하기 편리하며 오타가 발생할 가능성도 극히 낮다. 몇 자 되지는 않지만 자주 사용하는 연산이라면 이 차이도 결코 무시할 수 없다.
두 번째로 연산자 함수는 호출 형식이 연산문 형태로 작성되기 때문에 훨씬 더 직관적이고 기본형의 연산 방법과 일치하므로 사용하기 쉽다. A+B라는 표현식 자체가 A와 B를 더한다는 것을 잘 표현한다. 물론 Add라는 영어 단어도 뭔가를 더한다는 것을 의미하기는 하지만 + 연산자보다 쉽지는 않다. Add는 영어지만 +는 초등학생들도 아는 기호가 아닌가?
세 번째로 연산자는 함수와는 달리 우선 순위와 결합 방향의 개념이 있어 괄호를 쓰지 않아도 연산 순서가 자동으로 적용되어 편리하다. 어떤 객체 A와 B의 곱과 C와 D의 곱을 더해 E에 대입한다고 해 보자.
일반 함수 : E=(A.Multi(B)).Add(C.Multi(D));
연산자 함수 : E=A*B+C*D;
어느쪽이 더 보기 좋고 읽기 좋은지는 굳이 강조하지 않더라도 쉽게 판단될 것이다. 일반 함수는 호출 순서를 괄호로 분명히 명시해야 하므로 식을 작성하는 프로그래머도 골치 아프고 이 식을 읽는 사람은 더 골치 아프다. 자연어로 표현하면 "A와 B를 곱하고 C와 D를 곱하고 두 곱셈 결과를 더해 E에 대입한다"가 되어 훨씬 더 복잡해진다. 이런 복잡한 동작을 E=A*B+C*D로 간략하게 표기할 수 있으므로 한마디로 가독성의 차이가 엄청나며 이 차이로 인해 유지 보수 비용의 규모가 달라진다. 그래서 C++은 문법이 복잡해지는 대가를 치르더라도 객체에 대한 연산자 오버로딩을 지원하는 것이며 우리는 이것을 애써 배우고 적극적으로 활용해야 한다.
물론 이런 연산자 함수를 일일이 정의한다는 것은 상당히 번거로운 일이며 또 정확하게 작성하기 위해 알아야 할 것도 많다. 하지만 OOP의 철학은 소수의 객체 작성자에게 편리함을 주는 것보다 무수히 많은 사용자들을 편하게 하는 쪽에 치중되어 있음을 생각해 본다면 연산자 오버로딩은 진정으로 사용자를 위한 기능임이 분명하다.