[Effective C++] 24: 타입 변환이 모든 매개변수에 대해 적용되어야 한다면 비멤버 함수를 선언하자

24: 타입 변환이 모든 매개변수에 대해 적용되어야 한다면 비멤버 함수를 선언하자

클래스에서 암시적 타입 변환을 지원하는 것은 일반적으로 못된 생각이다. 물론 이 규칙에도 예외가 있는데, 가장 흔한 예외 중 하나가 숫자 타입을 만들 때이다. 예를 들어 유리수를 나타내는 클래스를 만들고 있다면 정수에서 유리수로의 암시적 변환은 크게 어이없거나 하진 않을 것이다.

class Rational {
    // 생성자에는 일부로 explicit를 붙이지 않았다.
    // int에서 Rational로의 암시적 변환을 허용하기 위해
    Rational(int numerator = 0, int denointaor = 1);

    int numerator() const;
    int denominator() const;

private:

};

유리수를 나타내는 클래스의 덧셈이나 곱셈 등의 수치 연산은 기본적으로 지원하고 싶다. 이들을 멤버 함수, 비멤버 함수, 프렌드 함수 어느 것이 좋을까? 일단은 멤버 함수 버전으로 보자.

class Rational {
public:
    const Rational operator*(const Rational& rhs) const;
};

이렇게 설계해 두면 유리수 곱셈을 아주 쉽게 할 수 있게 된다.

Rational oneEighth(1, 8);
Rational oneHalf(1, 2);

Rational result = oneHalf * oneEighth;	// 가능
return = result * oneEighth;			// 가능

하지만 혼합형 수치 연산을 시도하니, 이게 반쪽짜리 연산이라는 사실을 알게 된다.

result = oneHalf * 2;		// 가능
result = 2 * oneHalf		// 불가

이 문제의 원인은 위의 두 예제를 함수 형태로 바꾸어 써 보면 바로 드러난다.

result = oneHalf.operator*(2);		// 가능
result = 2.operator*(oneHalf)		// 불가

oneHalf 객체는 operator* 함수를 멤버로 갖고 있는 클래스의 인스턴스이므로, 컴파일러는 이 함수를 호출한다. 밑의 줄의 2에는 클래스 같은 것이 연관되어 있지 않기 때문에, operator* 멤버 함수도 있을 리가 없다. 컴파일러는 아래처럼 호출할 수 있는 비멤버 버전의 operator*(네임스페이스 혹은 전역 유효범위에 있는 operator*)도 찾아본다.

result = operator*(2, oneHalf);		// 에러

하지만 int와 Rational을 취하는 비멤버 버전의 operator*가 없으므로 탐색은 실패하고 컴파일 에러가 발생한다. 

 

위에 제대로 성공한 함수 호출문을 다시 살펴보면 두 번째 매개변수가 정수 2인데, Rational::operator*의 선언문을 보면 인자로 Rational 객체를 받도록 되어 있다. 이는 바로 암시적 타입 변환(implicit type conversion) 때문이다. 이 int를 Rational의 생성자에 주어 호출하면 Rational로 둔갑시킬 수 있다는 것이다. 그래서 컴파일러는 자기가 알고 있는 대로 한 것이다. 즉, 다음의 코드인 것처럼 처리한 거다.

cont Rational temp(2);

result = oneHalf * temp;

물론 컴파일러가 이렇게 동작한 것은 명시호출(explicit)로 선언되지 않은 생성자가 있기 때문이다. Rational 생성자가 만약 명시호출 생성자였으면 다음의 코드 중 어느 쪽도 컴파일되지 않는다.

result = oneHalf * 2;		// 에러! 명시호출 생성자에 의해 
							// 2를 Rational로 바꿀 수 없다.
                            
result = 2 * oneHalf		// 에러! 같은 이유

이제 두 개의 문장이 전부 컴파일되는 설계를 해야 한다. Rational 생성자가 명시호출이 아닐 때도 어째서 첫 번째 문장은 컴파일 되는데 두 번째 문장은 안 되는 것일까? 

암시적 타입 변환에 대해 매개변수가 먹혀들려면 매개변수 리스트에 들어 있어야만 한다. 그러니까 호출되는 멤버 함수를 갖고 있는(쉽게 말해 this가 가리키는) 객체에 해당하는 암시적 매개변수에는 암시적 변환이 먹히지 않는다. 이게 이유이다.

해결 방법은 바로 operator*를 비멤버 함수로 만들어서, 컴파일러 쪽에서 모든 인자에 대해 암시적 타입 변환을 수행하도록 내버려 두는 것이다.

class Rational {
public:
    // 생성자에는 일부로 explicit를 붙이지 않았다.
    // int에서 Rational로의 암시적 변환을 허용하기 위해
    Rational(int numerator = 0, int denointaor = 1);

    int numerator() const;
    int denominator() const;

private:
};

// 비멤버 함수
const Rational operator*(const Rational& lhs, const Rational& rhs)
{
    return Rational(lhs.numerator() * lhs.numerator(),
        rhs.numerator() * rhs.numerator());
}

Rational oneFourth(1, 4);
Rational result;

result = 2 * oneFourth;

 

여기서 걱정거리가 하나 있다. operator* 함수는 Rational 클래스의 프렌드 함수로 두어도 될까? 지금의 예제에서는 '아니오' 이다. operator*는 완전히 Rational의 public 인터페이스만을 써서 구현할 수 있기 때문이다. 여기서 중요한 결론은 "멤버 함수의 반대는 프렌드 함수가 아니라 비멤버 함수이다"라는 것이다. 프렌드 함수는 피할 수 있으면 피하자. 

 

이것만은 잊지 말자!

• 어떤 함수에 들어가는 모든 매개변수(this 포인터가 가리키는 객체도 포함해서)에 대해 타입 변환을 해 줄 필요가 있다면, 그 함수는 비멤버이어야 한다.