28-1-다.연산자 함수의 형식

클래스의 연산자 함수를 정의하는 방법은 다음 두가지가 있다.

① 클래스의 멤버 함수로 작성한다.

② 전역 함수로 작성한다.

우선 상대적으로 좀 더 간단한 멤버 연산자 함수를 작성하는 형식부터 알아보자. 전역 함수로 작성하는 방법에 대해서는 다음 절에서 상세하게 알아볼 것이다. 멤버 연산자 함수의 기본 형식은 다음과 같다.

리턴타입 Class::operator 연산자(인수 목록)

{

함수 본체;

}

일반적인 멤버 함수 선언문과 동일하되 함수 이름이 키워드 operator와 연산자로 구성되어 있다는 점만 다르다. 연산자 자리에는 +, -, *, /, <<, != 등 대부분의 연산자 기호가 올 수 있다. 이 형식대로 앞 항에서 작성한 ComplexAdd 예제의 Complex 클래스에 덧셈 연산자를 추가해 보자.

class Complex

{

private:

double real;

double image;

public:

Complex() { }

Complex(double r, double i) : real(r), image(i) { }

void OutComplex() const { printf("%.2f+%.2fi\n",real,image); }

const Complex operator +(const Complex &T) const {

Complex R;

R.image = image + T.image;

R.real = real + T.real;

return R;

}

};

임시 객체 R을 선언하고 R에 덧셈 결과를 작성하되 허수부와 실수부를 각각 따로 더했다. 이 연산자가 정의되면 이제 Complex 객체에 대해 + 연산자로 간편하게 덧셈을 할 수 있으며 Complex가 기본형과 비슷한 자격을 가지게 된다. 실행 결과는 다음과 같다.

1.10+2.20i

3.30+4.40i

4.40+6.60i

C3=C1+C2 연산문에 의해 두 복소수가 제대로 더해졌다. 멤버 연산자 함수의 원형이 다소 복잡한데 이 원형을 간략하게 분석해 보면 다음과 같다.

클래스 선언문 내부의 인라인 함수로 정의했기 때문에 함수명앞에 소속 클래스에 대한 표기(Complex::)는 빠져 있는데 외부에서 정의한다면 Complex::operator + 등으로 소속 클래스 이름도 밝혀야 한다. 이 예를 통해 멤버 연산자 함수의 각 요소에 대해 상세하게 연구해 보자. 각각의 const 키워드가 가지는 의미, 레퍼런스를 넘기는 이유, 값을 리턴하는 이유 등이 나름대로 복잡하다.

인수의 타입

연산자 함수의 인수란 피연산자를 의미하는데 함수를 호출하는 자기 자신(this)과 함수로 전달되는 인수가 연산 대상이다. 이항 연산자의 경우 멤버 연산자 함수를 호출하는 객체가 좌변이 되고 인수로 전달되는 대상이 우변이 된다.

원칙적으로 연산자 함수의 인수는 임의의 타입을 모두 받아들일 수 있지만 논리적으로 객체와 연산 가능한 대상이어야 한다. Complex 객체의 경우 다른 Complex 객체나 실수 또는 정수형이 피연산 대상이 될 수 있다. 복소수를 복소수와 덧셈하는 것은 논리적으로 합당하지만 복소수에 시간을 더하거나 Person, Position 따위의 전혀 관련없는 객체를 더하는 것은 별 의미가 없다. 자신과 같은 타입의 다른 객체인 경우가 가장 보편적이고 가끔 호환되는 타입과 연산하기도 한다.

객체는 값으로 넘길 수도 있지만 아무래도 기본형보다는 덩치가 크기 때문에 값으로 넘기면 비효율적이므로 레퍼런스로 넘기는 것이 유리하다. 인수 T앞에 &기호를 빼고 값으로 넘겨도 동작에는 별 이상은 없지만 객체가 커지면 다소 느릴 것이다. 포인터를 넘기는 것도 연산자 함수가 피연산 대상을 읽을 수 있으므로 일단 가능은 하다. 위 예제의 + 연산자를 다음과 같이 Complex *를 받도록 수정해 보자.

Complex operator +(const Complex *T) const {

Complex R;

R.image = image + T->image;

R.real = real + T->real;

return R;

}

포인터로 넘겨진 피연산자의 멤버를 참조하려면 . 연산자 대신 ->연산자를 사용하기만 하면 된다. 그러나 연산자 함수가 포인터를 받아들이면 이 함수를 호출할 때 피연산자의 주소를 넘겨야 하므로 호출부의 모양이 C3=C1.operator +(&C2);가 될 것이고 이를 연산식으로 표현하면 C3=C1+&C2; 가 되는데 이런 형식은 연산문의 일반적인 표기법에 어긋나며 전혀 직관적이지 못하다. 정수형의 경우 i=j+&k;로 연산하지 않는 것과 마찬가지이다.

연산자 오버로딩의 목적은 객체의 연산문을 기본형과 같은 방법으로 표현함으로써 가독성을 높이고 클래스의 직관적인 활용성을 향상시키는 것인데 이런 식으로 매번 &연산자를 사용해야 한다면 차라리 AddComplex 따위의 일반 함수를 쓰는 편이 더 나을 것이다. 연산자 함수로 피연산자를 넘기는 방법은 사실 세 가지 모두 가능하다. 값으로 넘기는 방법은 객체가 커지면 효율이 좋지 못하다는 문제가 있고 포인터로 넘기는 방법은 효율은 좋지만 호출 구문이 요상해진다. 레퍼런스로 넘기면 효율과 직관적인 표기라는 두 마리 토끼를 다 잡을 수 있다. C++이 레퍼런스 타입을 지원하는 주된 이유 중의 하나가 바로 객체 연산식의 직관적인 표현을 위해서이다.

인수의 상수성

피연산자로 전달된 인수는 보통 읽기만 한다. a+b, a*b, a>>b, a[b], a->b 등 우리가 알고 있는 모든 이항 연산자를 관찰해 보면 인수로 전달되는 우변의 값을 변경하는 경우는 전혀 없으며 단지 연산할 값을 얻기 위해 읽기만 한다. 그래서 연산자 함수로 전달되는 인수는 읽기 전용의 const 로 받는 것이 좋다. 연산자 함수로 객체의 레퍼런스를 전달할 때 이 함수가 객체의 상태를 함부로 변경하지 못하도록 하기 위해 const 지정자를 붙이는 것이 안전하다.

만약 레퍼런스로 전달되는 T가 const가 아니라면 operator + 함수 내부에서 T.real=12.34; 로 실인수를 마음대로 바꿔 버릴 수도 있다. 이항 연산자의 피연산자는 연산의 재료일 뿐이지 연산 대상이 아니므로 이는 분명히 잘못된 연산이다. 또한 다음과 같은 연산문도 불가능해진다.

const Complex C2(1.0, 2.0);

C3=C1+C2;

상수 객체도 피연산자로 사용할 수 있어야 하는데 인수가 상수가 아니라면 에러로 처리될 것이다. 정수 연산에서 a=b+3;이 허용되므로 복소수 연산에서도 상수 객체를 피연산자로 쓸 수 있어야 한다. 물론 강제 사항은 아니므로 필요에 따라 인수의 상수성을 선택할 수 있겠지만 제대로 된 연산자라면 피연산자를 변경하지 말아야 한다. 직관적인 연산식 표현을 위해 포인터는 안된다고 했으므로 Complex 객체를 인수로 전달받는 operator +의 경우 다음 4가지 형식의 인수를 받아들일 수 있다.

① Complex

② Complex &

③ const Complex

④ const Complex &

이 중 ④번 형식이 가장 바람직하다. 레퍼런스를 넘기므로 빠르고 const 지정을 했으므로 안전하기도 하다. 객체의 크기가 아주 작아 굳이 레퍼런스를 쓸 필요가 없다면 ①번 형식이 가장 간단하다. 값으로 넘길 경우는 어차피 사본이 전달되므로 ③번 형식처럼 값에 대해 const 지정자를 붙이는 것은 사실 별 실용성이 없다.

함수의 상수성

Complex의 operator + 연산자가 const 함수로 지정되어 있는데 멤버 연산자 함수가 호출 객체의 상태를 바꾸지 않을 경우는 원칙에 따라 const 함수로 지정하는 것이 좋다. 그래야 함수 내부에서 부주의하게 호출 객체를 변경하는 사고를 방지할 수 있다. 덧셈, 뺄셈, 곱셈 등의 통상적인 이항 연산자들은 객체의 값을 읽기만 할 뿐 객체를 변경하지 않는다. 만약 연산자 함수가 상수성을 가지지 않으면 상수 객체에 대해서는 연산을 할 수 없을 것이다. 다음 코드를 보자.

const int i=4;

int j=3,k;

k=i+j;

이 연산이 가능하기 위해서는 +연산자가 상수 i의 값을 바꾸지 않는다는 보장이 있어야 한다. 반면 객체의 값을 직접 변경하는 연산자는 const로 지정해서는 안된다. 이런 연산자에는 대표적으로 대입 연산자가 있고 증감 연산자, 복합 대입 연산자도 const가 될 수 없는 연산자이다. 같은 타입의 다른 객체를 대입받아 객체의 값을 변경하는 = 연산자가 const라면 말이 안된다.

임시 객체의 사용

위 예제의 operator + 연산자 본체를 보면 Complex형의 임시 객체 R을 선언하고 호출 객체와 피연산자 T를 더한 결과를 R에 작성한 후 임시 객체 R을 리턴하고 있다. 이 연산에 사용된 임시 객체 R은 호출 객체와 피연산자의 값을 변경하지 않고 연산 결과를 잠시 저장하기 위한 용도로 사용되는 것이다. 만약 임시 객체를 쓰지 않고 다음과 같이 이 함수를 작성했다고 해 보자.

const Complex operator +(const Complex &T) {

image = image + T.image;

real = real + T.real;

return *this;

}

호출 객체인 this의 멤버를 직접 변경하고 *this 자체를 리턴했다. 이렇게 수정한 후 컴파일해 보면 별 이상없이 잘 동작하는 것처럼 보인다. 그러나 테스트 코드의 끝에 C1.OutComplex();로 C1값을 확인해 보면 원래 값인 1.1+2.2i를 그대로 가지고 있지 않으며 C3과 같은 값이 되어 있을 것이다. + 연산자의 좌변 객체가 변경되어 버리므로 자세히 따져 보면 본래의 + 연산과는 다른 연산(+=)이 되어 버린다. 이 상황을 좀 더 이해하기 쉬운 정수형 연산을 예로 설명해 보자.

int a=1,b=2,c;

c=a+b;

이 코드의 결과 c에는 3이 대입될 것이고 a와 b는 원래의 값을 그대로 유지해야 하므로 a는 1, b는 2가 되는 것이 옳다. a가 b의 값을 더한 값으로 변경된 후 그 결과가 c에 대입되는 것이 아니라 두 피연산자의 값만 읽어 덧셈을 한 후 그 결과값을 c로 대입해야 한다. 이때의 결과값을 잠시 가지기 위해 정수형 임시 변수가 필요하다.

그래서 Complex의 operator +도 이 요구에 맞추기 위해 호출 객체를 건드리지 말아야 하며 따라서 이 함수는 const가 되어야 하는 것이다. 그러다 보니 연산 결과를 저장할 임시 객체가 필요하며 이 함수는 임시 객체에 연산을 한 후 그 객체를 리턴하는 형식으로 작성해야 한다. 호출측에서는 연산 결과 리턴되는 값을 같은 타입의 다른 객체에 즉시 대입해야 한다. 대입되지 않으면 이 값은 버려진다.

리턴 타입

연산의 결과로 어떤 타입을 리턴할 것인가는 연산자별로 다르다. 정수끼리 더하면 정수가 되고 실수끼리 곱하면 실수가 되는 것처럼 객체에 대한 연산 결과는 보통 객체와 같은 타입이 되지만 반드시 그런 것은 아니다. 논리 연산자의 경우는 BOOL(또는 bool)형이나 int형이 리턴될 수도 있고 첨자 연산자 [ ]의 경우처럼 특수한 연산자는 멤버 중의 하나를 리턴하는 경우도 있다.

앞에서 예를 든 Time의 +, Complex의 +는 둘 다 클래스형의 객체를 리턴했는데 그래야 연산 결과를 제 3 의 객체에게 대입할 수 있다. 만약 + 연산자가 덧셈만 하고 결과를 리턴하지 않는다면 A=B+C같은 대입은 불가능할 것이며 A=B+C+D 같은 연쇄적 연산도 할 수 없을 것이다. 임의의 타입 T에 대한 덧셈 결과는 역시 T형이 되는 것이 합리적이다.

연산자 함수가 객체를 리턴할 때 레퍼런스를 리턴할 것인가, 값을 리턴할 것인가는 연산자에 따라 다르다. operator +의 경우 임시 객체로 연산 결과를 리턴하기 때문에 레퍼런스형은 안된다. 임시 객체는 함수 호출이 종료되면 사라지며 함수 리턴 직후에 다른 객체로 대입할 수 있는 값을 넘겨야 한다. 임시객체에 대한 레퍼런스도 물론 곧바로 대입한다면 별 문제는 없다. Complex의 + 연산자를 레퍼런스를 리턴하도록 수정해 보자.

Complex &operator +(const Complex &T) const {

...

이렇게 수정한 후 컴파일하면 경고가 발생하기는 하지만 C3=C1+C2; 연산문이 정상적으로 실행된다. 왜냐하면 + 연산 바로 다음 연산이 대입 연산이고 대입 연산은 함수 호출이 아닌 멤버별 복사 코드의 실행이기 때문에 스택에 있는 임시 변수가 대입되는 시점까지 값을 계속 유지하기 때문이다. 그러나 다음 테스트 코드를 작성해 보면 제대로 동작하지 않음을 확인할 수 있다.

void main()

{

Complex C1(1.1,2.2);

Complex C2(3.3,4.4);

Complex C3(5.5,6.6);

Complex C4;

C4=C1+C2+C3;

C1.OutComplex();

C2.OutComplex();

C3.OutComplex();

C4.OutComplex();

}

연산 순위에 따라 C1+C2가 먼저 호출되고 이 연산의 결과 지역변수 R의 레퍼런스가 리턴되며 다음으로 연산결과 R+C3가 호출되는데 이 시점에서 스택에 있는 호출 객체인 R이 깨지기 때문이다. 그러므로 C4는 제대로 된 값을 대입받을 수 없다. 연쇄적인 연산이 아닌 C3=C1+C2 같은 대입문도 = 연산자가 별도의 함수로 오버로딩된 된 경우 마찬가지 현상이 발생한다. 바로 직전의 함수가 만든 지역변수는 다음 함수가 호출되면 완전히 사라진다. 스택은 매 함수 호출마다 새로 재구성되는 임시 기억 장소이기 때문이다.

반면 값으로 리턴할 경우는 아무런 문제가 없다. 값은 리턴될 때 새로 만들어지는 사본이기 때문에 다른 함수 호출에 대해 침범당하지 않기 때문이다. 그래서 Complex의 + 연산자는 Complex의 레퍼런스가 아닌 Complex의 값을 리턴하는 것이 정확하다.

리턴 타입의 상수성

리턴 타입의 상수성도 경우에 따라 다른데 객체 타입을 리턴하는 함수는 보통 상수 객체를 리턴해야 한다. Time이나 Complex는 연산을 위해 임시 객체를 생성하고 연산 결과인 임시 객체를 리턴한다. 이 임시 객체는 값을 리턴하기 위해 잠시 생성되는 것이므로 상수성을 가지는 것이 옳다. 잘 이해가 되지 않으면 정수 연산을 예로 들어 보자.

int i=3,j=4,k;

k=i+j;

이 연산에서 i+j의 결과로 리턴되는 값은 7이라는 정수 상수이지 정수형 변수가 아니다. 즉 우변값이어야지 좌변값이어서는 안된다. 만약 i+j가 값을 변경할 수 있는 정수형 변수를 리턴한다면 i+j=5;라는 연산식도 허용되어야 할 것이다. Complex의 경우 C1+C2는 덧셈을 한 복소수 객체일 뿐 여기에 어떤 변경을 가할 수는 없어야 하며 만약 이를 허용하면 잠시 후면 사라질 임시 객체를 변경하는 쓸데없는 짓을 하게 된다. 이 함수의 원형을 보면 const가 세 번 사용되는데 각각의 의미는 다르다.

읽기 전용 피연산자를 받고 객체를 변경하지 않으며 리턴되는 객체도 읽기만 할 수 있다. 덧셈 연산은 모든 대상을 상수로만 취급한다.

생성자의 활용

Complex 클래스는 실수부 r과 허수부 i를 인수로 전달받는 생성자가 정의되어 있으므로 이를 활용하여 생성자로부터 임시객체를 쉽게 만들 수 있다. operator + 연산자의 본체를 다음과 같이 수정해 보자.

const Complex operator +(const Complex &T) const {

Complex R(real+T.real, image+T.image);

return R;

}

임시 객체 R을 만들 때 생성자로 실수부와 허수부의 연산식을 넘기면 된다. 생성자의 인수로 전달되기 전에 대응되는 멤버끼리 연산이 수행되고 그 결과가 새로 생성되는 객체의 멤버로 대입된다. 또는 아예 임시 객체를 만들지 않고 생성자가 리턴하는 이름없는 임시 객체를 곧바로 리턴할 수도 있다.

const Complex operator +(const Complex &T) const {

return Complex(real+T.real, image+T.image);

}

이 코드는 앞서 만든 코드보다 훨씬 더 짧고 간략해 보일 뿐만 아니라 컴파일러의 리턴값 최적화(RVO:Retrun Value Optimization) 기능의 도움도 받을 수 있어 훨씬 더 유리하다. 제대로 만든 컴파일러는 호출원의 대입되는 좌변에 대해 곧바로 생성자를 호출하며 불필요한 임시 객체를 만들지 않음으로써 훨씬 더 작고 빠른 코드를 생성한다.

임시 객체를 명시적으로 선언하든 아니면 생성자가 리턴하는 임시 객체를 리턴하든 어쨌든 리턴되는 결과는 임시적인 객체이므로 함수 호출이 완료되면 사라진다. 그래서 호출원에서는 C3=C1+C2;처럼 리턴되는 임시 객체를 곧바로 다른 객체에 대입해야 한다. 만약 C1+C2; 연산문으로 더하기만 하고 대입을 받지 않으면 리턴되는 임시 객체는 버려진다. 이 점도 정수형의 연산과 동일하다.

본체

연산자 함수의 본체에는 연산자에 요구되는 논리적인 연산 코드를 작성한다. 실제 연산 코드는 클래스마다, 연산자마다 천차만별로 달라질 것이다. 복소수 연산의 경우 실수부와 허수부를 따로 연산하며 시간은 시분초 요소끼리 연산하되 자리 올림이나 내림을 처리해야 한다. 문자열끼리 더할 때는 버퍼를 재할당하여 연결해야 할 것이며 행렬의 경우 수학적 정의에 따라 행렬 연산을 해야 할 것이다.

이처럼 클래스가 표현하는 대상에 따라 연산하는 방법이 고유하고 특수하기 때문에 클래스를 만든 사람이 연산 방법 자체를 정의할 수 있어야 하며 이런 정의를 가능하도록 하는 C++의 문법적인 장치가 바로 연산자 오버로딩인 것이다. 모든 클래스에 대해, 모든 연산자에 대해 절대적으로 적용되는 법칙 같은 건 없으며 클래스별로 연산자별로 규칙이 달라진다.

이상으로 멤버 연산자 함수를 구성하는 여러 가지 요소에 대해 상세하게 연구해 봤는데 나름대로 합리적인 규칙들이기는 하지만 별로 쉽지는 않을 것이다. 이런 여러 가지 복잡한 규칙들을 골고루 적용하여 제대로 만든 덧셈 연산자 함수의 아름다운 모습을 다시 한 번 더 감상해 보자.

const Complex operator +(const Complex &T) const {

Complex R;

R.image = image + T.image;

R.real = real + T.real;

return R;

}