7-3.연산자

7-3-1.연산자 오버로딩

연산자는 피연산자를 인수로 취하고 계산 결과를 리턴한다는 점에서 함수와 유사하다. 다만 피연산자 개수가 정해져 있고 이름이 아닌 기호로 호출한다는 점이 다르다. 연산자 오버로딩은 원래의 연산자 함수를 클래스 타입에 대해 중복 정의하여 객체에 대한 연산을 정의하는 기법이다. 오버로딩은 인수의 타입이 다를 때 성립하는데 연산자는 피연산자가 인수여서 피연산자별로 정의할 수 있다. 기본 타입에 대한 연산자는 각 타입에 대해 이미 오버로딩되어 있다. 그래서 다음과 같은 연산이 자연스럽게 성립한다.

 

연산식	연산자 함수
1 + 2	int +(int a, int b)
3.14 + 2.54	double +(double a, double b)
"하나" + "둘"	string +(string a, string b)

 

정수와 실수, 문자열은 내부적인 구조가 다르며 + 연산 알고리즘도 당연히 다르다. 똑같은 + 연산으로 정수, 실수, 문자열을 더할 수 있는 이유는 + 연산자가 각 타입에 대해 중복 정의되어 있기 때문이다. + 연산자의 원형을 함수의 형태로 작성해 보면 위 오른쪽과 같다.

각 연산자의 내부 코드는 다르지만 피연산자 타입에 따라 적절한 메서드가 호출되어 +라는 하나의 연산자로 정수를 더하고 문자열을 연결하는 동작이 모두 가능하다. 그러나 배열끼리 더하거나 객체끼리 더하는 + 연산자는 정의되어 있지 않아 다음 연산식은 컴파일되지 않는다.

 

Time A, B, C;

C = A + B;

 

+ 연산자는 Time 클래스의 내부를 모르며 어떻게 더하는지도 당연히 모른다. Time형 객체끼리 더하려면 Time을 피연산자로 받는 + 연산자를 새로 정의해야 한다. Time은 사용자가 정의한 특수한 타입이므로 어떻게 더하는지도 사용자가 정의해야 한다.

연산자 대신 AddTime같은 메서드를 정의할 수도 있지만 연산자는 표기가 간편하고 직관적이다. AddTime(A, B)보다는 A + B가 상식적이고 입력하기 쉬우며 가독성도 높다. 연산자나 메서드나 연쇄적인 연산이 가능하다. 다음은 4개의 시간 객체를 더하는 예인데 어느쪽이 더 쉬운지 명백하다.

 

E = AddTime(A, AddTime(B,AddTime(C, D)))

E = A + B + C + D;

 

여러 연산이 섞여 있을 때는 차이가 더 벌어진다. 게다가 연산자는 우선순위와 결합순서의 개념이 있어 괄호를 쓰지 않아도 순서가 분명하다. A + B * C / D + E 같은 식을 메서드로 수행하자면 꽤 지저분해진다. 연산자가 할 수 있는 모든 일은 메서드도 할 수 있으며 속도나 크기차도 거의 없다. 굳이 연산자를 정의하는 이유는 보기 좋고 편리하며 생산성이 높기 때문이다.

연산자 함수의 이름은 operator X이며 X 자리에 오버로딩할 연산자가 온다. 예를 들어 + 연산자를 정의하고 싶으면 operator + 이름으로 메서드를 만든다. 연산자 기호를 명칭으로 쓸 수 없어 operator 키워드를 붙여 이름을 작성한다. 오버로딩 가능한 연산자 목록은 다음과 같다.

 

종류	연산자
산술	+ - * / %
부호	+ -
증감	++, --
비트	& | ^ << >> ~
비교	== != > < >= <= !

 

모든 연산자를 다 오버로딩할 수 있는 것은 아니다. 대표적으로 = 연산자는 너무 기본적인 연산이라 오버로딩할 수 없다. [ ] 연산자는 인덱서로 대신 정의할 수 있어 오버로딩 대상이 아니며 &&, || 연산자는 쇼트 서키트 기능에 의한 민감한 부작용이 있어 오버로딩이 금지되어 있다. 그럼 이론은 이쯤에서 접어두고 연산자 오버로딩을 직접 해 보자. 다음 예제는 Time 객체끼리 더하는 + 연산자를 정의하여 시간끼리 더한다.

 

TimePlus
using System;   class Time {      private int hour, min, sec;      public Time() { }      public Time(int h, int m, int s) { hour = h; min = m; sec = s; }      public void OutTime() {           Console.WriteLine($"{hour}시 {min}분 {sec}초");      }      public static Time operator +(Time A, Time B) {           Time T = new Time();           T.hour = A.hour + B.hour;           T.min = A.min + B.min;           T.sec = A.sec + B.sec;             T.min += T.sec / 60;           T.sec %= 60;           T.hour += T.min / 60;           T.min %= 60;           return T;      } }   class CSTest {      static void Main() {           Time A = new Time(1, 1, 1);           Time B = new Time(2, 2, 2);           Time C;           C = A + B;           C.OutTime();      } }
실행결과	3시 3분 3초

 

operator +메서드가 Time 객체끼리 더하는 연산자이다. 외부에서 호출하려면 public으로 선언해야 한다. 또 교환 법칙을 적용하려면 호출 객체에 상관없이 연산할 수 있도록 static이어야 한다. + 연산자는 이항 연산자이므로 인수도 꼭 두 개 있어야 한다.

operator +의 본체는 피연산자의 원래값을 유지하기 위해 임시 객체를 생성하고 인수로 전달받은 A와 B의 각 시간 요소를 더한다. 이때 각 요소의 자리 넘침을 처리하는데 초를 더한 결과가 60이 넘으면 분을 증가시키며 분을 더한 결과가 60 이상이면 시를 증가시킨다. 1:1:40초와 2:2:36초를 더하면 3:3:76초가 되는 것이 아니라 3:4:16초가 된다.

시간끼리 더하는 연산은 수치형끼리 더하는 것과는 달리 특수한 처리가 필요해 연산자를 따로 정의해야 한다. Main은 C = A + B 연산식으로 두 객체를 더한다. 이 호출에 의해 operator +(A, B)가 호출되고 임시 객체 T에 A와 B의 각 시간 요소끼리 더해 T를 리턴하며 그 결과를 C가 대입받는다. 피연산자의 개수에는 제한이 있지만 타입에는 제한이 없어 Time 객체와 정수를 더할 수도 있다. 정수를 초로 간주하여 시간에 지정한 초를 더하면 된다. 이 연산을 위해 Time과 int를 인수로 받는 연산자를 정의한다.

 

TimePlusInt
using System;   class Time {      private int hour, min, sec;      public Time() { }      public Time(int h, int m, int s) { hour = h; min = m; sec = s; }      public void OutTime() {           Console.WriteLine($"{hour}시 {min}분 {sec}초");      }      public static Time operator +(Time A, int s) {           Time T = new Time();           T.hour = A.hour;           T.min = A.min;           T.sec = A.sec;           T.sec += s;             T.min += T.sec / 60;           T.sec %= 60;           T.hour += T.min / 60;           T.min %= 60;           return T;      }      public static Time operator +(int s, Time A) {           return A + s;      } }   class CSTest {      static void Main() {           Time A = new Time(1, 1, 1);           A = A + 1;           A.OutTime();           A = 1 + A;           A.OutTime();           A += 2;           A.OutTime();      } }
실행결과	1시 1분 2초 1시 1분 3초 1시 1분 5초

 

operator +(Time A, int s)는 좌변의 A 객체와 우변의 정수 s를 더해 A에 s초만큼 경과한 시간을 계산한다. 임시 객체 T를 생성하고 A의 값을 대입받은 후 초에 s를 더하고 자리 넘침을 처리한다. 덧셈은 교환 법칙이 성립해 피연산자의 순서는 중요치 않다. A + 1이 가능하면 1 + A도 당연히 가능해야 한다.

그래서 인수 순서에 따라 두 개의 함수를 작성하되 내부 동작은 같으니 실제 연산 코드는 한쪽에 작성하고 나머지 한쪽은 인수의 순서만 바꿔 주면 된다. C#은 += 연산을 +와 =의 조합으로 취급하기 때문에 + 연산자를 정의하면 +=도 자동으로 정의된다. 그러나 +를 정의한다고 해서 ++이 정의되는 것은 아니다. ++은 아예 다른 연산자여서 따로 정의해야 한다.

7-3-2.연산자 오버로딩의 예

다음은 비교 연산자를 오버로딩해 보자. 참조 타입에 대한 == 연산은 번지만 비교하는데 오버로딩하면 실제 내용을 비교할 수 있다. 다음 예제는 두 개의 Time 객체가 같은 시간을 가지는지 비교한다.

 

TimeEqual
using System;   class Time {      private int hour, min, sec;      public Time() { }      public Time(int h, int m, int s) { hour = h; min = m; sec = s; }      public void OutTime() {           Console.WriteLine($"{hour}시 {min}분 {sec}초");      }      public static bool operator ==(Time A, Time B) {           return (A.hour == B.hour && A.min == B.min && A.sec == B.sec);      }      public static bool operator !=(Time A, Time B) {           return !(A == B);      } }   class CSTest {      static void Main() {           Time A = new Time(5, 5, 5);           Time B = new Time(5, 5, 5);           Time C = new Time(6, 6, 6);           Console.WriteLine("A와 B는 {0}", (A == B ? "같다" : "다르다"));           Console.WriteLine("A와 C는 {0}", (A == C ? "같다" : "다르다"));      } }
실행결과	A와 B는 같다 A와 C는 다르다

 

== 연산자는 두 시간이 같은지 보기 위해 시, 분, 초의 모든 요소가 동시에 일치하는지 점검한다. A와 B는 모두 5시 5분 5초이므로 같다고 평가하며 A와 C는 다른 것으로 평가한다. 원래의 == 연산은 번지만 보기 때문에 오버로딩하지 않으면 A와 B도 다른 것으로 평가한다. 문자열을 == 연산자로 비교할 수 있는 이유도 string 클래스가 == 연산자를 오버로딩해 놓았기 때문이다.

연산자의 리턴 타입에 제약은 없지만 비교 연산자는 조건식에 주로 사용되므로 반드시 bool 타입을 리턴해야 한다. 억지로 만들면 비교 연산자가 int나 string을 리턴하는 것도 가능하지만 이렇게 만든 비교 연산자는 그야 말로 써먹을 데가 없다.

비교 연산자는 대응되는 반대 연산자와 짝으로 오버로딩해야 한다. ==을 정의했으면 !=도 같이 정의하는 것이 타당하다. == 은 내용을 비교하는데 !=은 번지를 비교하면 일관성이 없다. A == B가 참일 때 A != B는 당연히 거짓이 되어야 논리적으로 안정된다. 그래서 컴파일러는 == 과 !=을 같이 정의하도록 강제한다. == 이 정의되어 있으면 !=을 정의하는 것은 굉장히 쉬운데 단순히 ==의 반대값을 리턴하면 된다. 같은 이유로 <와 >, 그리고 <=와 >=도 반드시 짝으로 오버로딩한다. 이외에 컬렉션에 저장될 때를 위해 Equals, GetHashCode 메서드도 오버로딩해야 하나 이 예제와는 직접적인 상관이 없어 무시했다.

다음은 값을 1씩 증감시키는 증감 연산자를 오버로딩해 보자. ++ 연산은 + 1과 같은 연산이지만 이는 수치형에만 해당되며 객체에서는 의미가 완전히 달라질 수도 있다. ++은 하나 더 늘린다는 뜻인데 "하나"가 무엇을 의미하는지는 클래스마다 다르다.

 

TimePlusPlus
using System;   class Time {      private int hour, min, sec;      public Time() { }      public Time(int h, int m, int s) { hour = h; min = m; sec = s; }      public void OutTime() {           Console.WriteLine($"{hour}시 {min}분 {sec}초");      }      public static Time operator ++(Time A) {           Time T = new Time();           T.hour = A.hour;           T.min = A.min;           T.sec = A.sec;             T.sec++;           T.min += T.sec / 60;           T.sec %= 60;           T.hour += T.min / 60;           T.min %= 60;           return T;      } }   class CSTest {      static void Main() {           Time A = new Time(1, 1, 1);           Time t1, t2;           t1 = A++;           t2 = ++A;             t1.OutTime();           t2.OutTime();           A.OutTime();      } }
실행결과	현재 시간은 1시 1분 1초이다. 현재 시간은 1시 1분 3초이다. 현재 시간은 1시 1분 3초이다.

 

++ 연산자는 사본을 만든 후 초를 1증가시켜 그 사본을 리턴한다. 비록 1초 증가시키더라도 9:59:59는 시와 분이 영향을 받을 수 있어 자리 넘침은 반드시 처리해야 한다. ++ 연산자에서 피연산자를 직접 증가시키지 않고 사본을 사용하는 이유는 후위형은 피연산자가 증가되기 전의 값을 가지고 있어야 하기 때문이다.

전위형과 후위형으로 각각 호출해 보았는데 잘 동작한다. 후위형 A++을 대입받은 t1은 증가하기 전의 값을 가지며 전위형 ++A를 대입받은 t2는 증가 후의 값을 가진다. 증가시키는 연산자만 잘 작성해 두면 증가와 평가 순서는 컴파일러가 알아서 결정한다.

7-3-3.캐스트 연산자

캐스트 연산자를 오버로딩하면 클래스를 만든 사람이 변환 공식을 직접 제공하여 다른 타입과의 변환 방법을 지정할 수 있다. 캐스트 연산자 함수는 선언 형식이 일반 연산자와는 달리 특수하다.

 

public static implicit(explicit) 변환대상(인수)

 

캐스트 연산자는 단항 연산자이므로 인수도 반드시 하나여야 한다. 어떤 타입으로 바꿀 것인가는 함수의 이름으로 지정하는데 이 이름은 리턴 타입 지정을 겸한다. 인수로 전달된 타입을 리턴되는 타입으로 변환한다고 생각하면 된다. implicit(암시적), explicit(명시적) 키워드는 변환 방식을 지정한다. 암시적 변환이란 컴파일러의 자동 변환 연산이며 값 손실이 없을 때 사용한다. 명시적 변환은 값 손실이 발생할 가능성이 있어 캐스팅에 의해서만 변환할 수 있다.

다음 예제는 시간과 정수를 상호 변환한다. 시간은 시, 분, 초로 구성되지만 절대초 단위로 표현할 수 있다. 2시 10분 23초는 2 * 3600 + 10 * 60 + 23 = 7823초와 같다. 반대로 정수를 절대초로 해석하여 정수가 시간 객체가 되기도 한다. 절대초는 두 시간의 간격을 계산할 때 실용적이다.

 

TimeInt
using System;   class Time {      public int hour, min, sec;      public Time() { }      public Time(int h, int m, int s) { hour = h; min = m; sec = s; }      public void OutTime() {           Console.WriteLine($"현재 시간은 {hour}시 {min}분 {sec}초이다.");      }      public static implicit operator int(Time T) {           return T.hour * 3600 + T.min * 60 + T.sec;      }      public static explicit operator Time(int abs) {           Time T = new Time();           T.hour = abs / 3600;           T.min = (abs / 60) % 60;           T.sec = abs % 60;           return T;      } }   class CSTest {      static void Main() {           Time Now = new Time(12, 30, 40);           Now.OutTime();           int absec = Now;           Console.WriteLine("절대초 = {0}", absec);           Time Then = new Time();           Then = (Time)12345;           Then.OutTime();      } }
실행결과	현재 시간은 12시 30분 40초이다. 절대초 = 45040 현재 시간은 3시 25분 45초이다.

 

Time을 int로 변환하는 연산자와 int를 Time으로 변환하는 양방향의 캐스트 연산자를 정의했다. 시간을 정수로 바꿀 때는 시에 3600을 곱하고 분에 60을 곱하고 초를 더한다. 반대로 변환할 때는 절대초를 각 단위의 초 단위로 나눈 후 최대값으로 나눈 나머지를 구한다.

Time 객체를 정수로 변환하는 연산자는 별다른 위험이 없어 implicit를 붙여 암시적으로 선언했다. 하루는 길어 봐야 86400초에 불과하며 이 값은 int의 범위에 포함되기 때문에 문제없다. absec = Now 대입문에 캐스트 연산자를 쓰지 않아도 컴파일러가 알아서 변환 연산자를 호출한다.

반면 정수를 Time 객체로 변환하는 연산자는 위험할 수도 있어 explicit를 붙여 명시적으로 선언했다. 정수가 12345나 65300 정도라면 유효한 Time 객체로 변환되지만 123456789 같은 큰 값이면 시간값이 너무 커져 버린다. 절대초가 음수면 황당한 결과가 나올 수도 있어 명시적 변환만 허용한다.

Then = 12345 식으로 암시적으로 변환할 수 없으며 캐스트 연산자를 써서 Then = (Time)12345로 명시적 변환해야 한다. 캐스트 연산자를 썼다는 것은 정수가 유효한 범위내에 있음을 보장하며 모든 책임을 지겠다는 선언이므로 컴파일러는 더 이상 시비를 걸지 않는다. 물론 변환 후에 발생하는 모든 부작용은 개발자가 다 뒤집어 써야 한다.

컴파일러는 변환이 100% 확실히 진짜로 정말로 안전할 때만 암시적 변환을 허용한다. 조금이라도 위험한 변환은 개발자의 명시적인 지시가 있어야 한다. 컴파일러는 알고 보면 참 소심한 녀석이다. 캐스트 연산자를 정의할 때도 안전할 때만 implicit로 정의하며 값 손실 위험이 있을 때는 explicit로 정의해야 한다.

때로는 타입 변환이 여러 단계를 거쳐 일어나는 다중 캐스팅이 발생한다. 위 예제에 double d = Now; 같은 코드를 작성해 보자. Time 객체를 실수로 변환하는 연산자는 정의하지 않았지만 실제로 해 보면 다음 과정을 거쳐 아무 문제없이 잘 변환된다.

Time이 int 변환 연산자에 의해 int로 먼저 변환되고 정수가 다시 실수로 변환된다. 이 연산이 가능한 이유는 Time 객체가 int로 변환하는 암시적인 연산자를 제공하고 정수는 시스템에 의해 암시적으로 실수로 변환 가능하기 때문이다. 변환 과정을 캐스트 연산자로 표시하면 double d = (double)(int)Now; 요렇게 된다.

클래스끼리도 변환 가능하다. 단, 예외적으로 상속 관계의 클래스끼리는 변환 연산자를 정의할 수 없다. 정확하게 얘기하자면 부자 관계의 클래스끼리는 원래 변환 가능해 변환 연산자가 필요치 않다. 자식 타입은 부모 타입으로 언제든지 변환할 수 있으며 부모 타입은 명시적 캐스팅에 의해 자식 타입으로 변환 가능하다.

클래스간의 변환은 섭씨와 화씨처럼 같은 실체에 대한 다른 표현이거나 논리적인 연관성이 있을 때 실용적이다. 그러나 문법적으로 가능하다 해도 실질적으로 의미가 없는 경우도 있다. 사람을 시간으로 바꾼다거나 조폭이 강아지가 되는 택도 없는 변환은 할 필요가 없다. 다음 예제는 밀리미터와 인치 단위를 변환한다.

 

MiliInch
using System;   class Inch {      public double len;      public Inch(double alen) { len = alen; }      public void OutValue() { Console.WriteLine($"{len:F2}인치"); }      public static implicit operator Mili(Inch i) {           return new Mili((uint)(i.len * 25.4));      }      public static implicit operator Inch(Mili m) {           return new Inch(m.len / 25.4);      } }   class Mili {      public uint len;      public Mili(uint alen) { len = alen; }      public void OutValue() { Console.WriteLine($"{len}밀리"); } }   class CSTest {      static void Main() {           Inch disk = new Inch(0);           Mili shoes = new Mili(0);             disk.len = 3.5;           shoes = disk;           shoes.OutValue();             shoes.len = 275;           disk = shoes;           disk.OutValue();      } }
실행결과	88밀리 10.83인치

 

Inch 클래스는 실수로 된 인치를 표현하며 Mili 클래스는 정수로된 밀리미터를 표현한다. 두 타입간의 변환 연산자가 모두 정의되어 있어 양방향으로 변환 가능하다. 1인치는 25.4밀리미터이므로 이 상수를 곱하고 나누면 두 타입을 쉽게 변환할 수 있다. Main에서는 3.5인치가 몇 밀리미터인지, 275밀리미터가 몇 인치인지 계산하여 출력했다.

양쪽으로 변환하는 기능을 사용했으므로 두 개의 변환 함수가 모두 필요하다. 변환 함수의 소속은 중요하지 않은데 양쪽 클래스 어디에나 존재하면 된다. 어차피 변환 함수는 정적이므로 연산자가 선언된 클래스는 논리적인 소속일 뿐이다. 예제에서는 Inch 클래스에 두 연산자를 정의했는데 Mili 클래스로 옮겨도 상관없으며 두 연산자를 양쪽에 하나씩 찢어 놓아도 된다.

7-3-4.오버로딩의 애매함

오버로딩은 편리한 기능이지만 과하게 쓰면 위험한 면도 있어 주의할 필요가 있다. 오버로딩된 메서드를 호출할 때 메서드를 선택하는 것은 컴파일러의 책임이며 컴파일 중에 결정된다. 그래서 오버로딩이 복잡해지면 컴파일 시간이 오래 걸리는데 다행히 실행 속도와는 상관이 없다.

컴파일러는 호출문의 인수 개수와 타입(시그니처)을 보고 적절한 메서드를 선택하는데 이때 오버로드 결정하기(Overload Resolution)라는 복잡한 내부 정책이 적용된다. 이 정책에는 타입 비교뿐만 아니라 ref, out 등의 지정자, 타입간의 암시적, 명시적 변환 규칙까지 고려되어 상상 이상으로 복잡하다.

정확히 일치하는 메서드가 발견되면 문제없지만 그렇지 않을 경우 컴파일러가 재량껏 호출할 메서드를 선택한다. 우선 호출 가능한 후보 목록(Applicable)을 작성하고 이 중에 그나마 가장 나은(Better) 메서드를 선택한다. 그나마 낫다는 기준은 타입이 가장 근접한다는 뜻이다. 시그니처가 일치하는 메서드가 없더라도 암시적 변환이 가능하면 컴파일러가 알아서 변환한 후 호출한다.

 

OverMethod
using System;   class CSTest {      static void Method(short a) { Console.WriteLine("short"); }      static void Method(int a) { Console.WriteLine("int"); }      static void Method(uint a) { Console.WriteLine("uint"); }      static void Method(long a) { Console.WriteLine("long"); }      static void Method(double a) { Console.WriteLine("double"); }      static void Main() {           short s = 1234;           Method(s);      } }
실행결과	short

 

Method 메서드가 5개의 시그니처로 오버로딩되어 있으며 각 메서드는 자신이 호출되었다는 것을 화면으로 출력한다. Main에서 short형 변수를 선언한 후 이 변수를 Method로 넘겼다. 이때 과연 어떤 메서드가 선택될 것인가가 문제다. 이 경우 short를 받는 메서드가 있어 Method(short)가 호출된다. 만약 Method(short)가 없다면 어떻게 될까? 이 메서드를 주석 처리한 후 다시 실행해 보면 Method(int)가 호출된다. short는 암시적으로 int로 변환 가능하므로 컴파일러는 Method(int)가 short형 인수를 받아도 문제 없다고 판단한다.

Method(int)도 주석 처리하면 남은 세 개의 메서드 중 누가 호출될까? Method(uint)가 근접해 보이지만 실행해 보면 Method(long)이 호출된다. uint는 부호를 표시할 수 없어 short와 암시적으로 호환되지 않으며 long이 더 가깝다. TimeInt 예제에 다음 코드를 작성하면 정수가 출력된다.

 

Time Now = new Time(12, 34, 56);

Console.WriteLine(Now);

 

Time을 인수로 받는 WriteLine 메서드는 없지만 암시적 변환에 의해 Now가 int가 될 수 있다. 만약 Time 클래스가 double로 변환하는 캐스트 연산자를 정의하면 실수로도 출력된다. 컴파일러는 친절해서 가능한 함수를 찾아 적용하지만 때로는 과다 친절에 의해 부정확한 함수가 호출될 수도 있다.

캐스트 연산자에 대해서도 역시 오버로딩 문제가 있다. 여러 개의 캐스트 연산자가 암시적으로 오버로딩되어 있을 때 어떤 연산자에 의해 변환될 것인가는 컴파일러가 엄격한 내부 규칙에 의거하여 지 맘대로 결정한다. 다음은 Time 클래스에 정수 및 실수 변환 연산자를 동시에 정의한 것이다. 시간을 정수부에 두고 분을 소수부에 두는 식으로 실수로 변환 가능하다.

 

CastOver

실행결과

using System;   class Time {      public int hour, min, sec;      public Time() { }      public Time(int h, int m, int s) { hour = h; min = m; sec = s; }      public static implicit operator int(Time T) {           return T.hour * 3600 + T.min * 60 + T.sec;      }      public static implicit operator double(Time T) {           return T.hour + T.min / 100.0;      } }   class CSTest {      static void Main() {           Time Now = new Time(12, 34, 56);           Console.WriteLine((int)Now);           Console.WriteLine((double)Now);           Console.WriteLine(Now);      } }

45296 12.34 45296

 

Main에서 Time 객체를 생성하고 세 번 출력했는데 두 번은 캐스트 연산자를 사용했고 한 번은 암시적으로 출력했다. 명시적으로 캐스팅할 때는 지정한 타입에 맞는 변환 연산자가 호출되지만 암시적으로 호출할 때는 어떤 버전이 호출될지 알기 쉽지 않다. 이 예제의 경우는 정수로 변환되어 출력되는데 의도한 바라면 다행이지만 그렇지 않을 수도 있다. 사용자는 실수가 더 큰 타입이므로 실수로 변환되는 것이 더 자연스럽다고 생각할 수도 있으며 이렇게 기대했다면 원하는 것과는 다른 결과가 나온 것이다.

20개 정도의 오버로드가 존재하는 메서드라면 결코 간단한 문제가 아니다. 컴파일 에러는 발생하지 않아 개발자는 원하는대로 호출되었다고 생각하고 넘어가 버릴 수도 있으며 잘못된 호출이 언제 말썽을 일으킬지 알 수 없다. 최악의 시나리오는 이 호출이 릴리즈될 때까지 발각되지 않는 경우인데 컴파일러는 뒷일을 책임지지 않는다. 사실 책임질 능력도 없다. 그래서 이런 애매한 경우는 가급적 만들지 말아야 한다. 다음 예제는 아예 에러로 처리되는 극단적인 경우이다.

 

OverError

using System;   class Time {      public int hour, min, sec;      public Time() { }      public Time(int h, int m, int s) { hour = h; min = m; sec = s; }      public static implicit operator int(Time T) {           return T.hour * 3600 + T.min * 60 + T.sec;      }      public static explicit operator Time(int abs) {           Time T = new Time();           T.hour = abs / 3600;           T.min = (abs / 60) % 60;           T.sec = abs % 60;           return T;      } }   class CSTest {      static void Method(int a, Time b) { Console.WriteLine("int, Time"); }      static void Method(Time a, int b) { Console.WriteLine("Time, int"); }      static void Main() {           Time Now = new Time(12, 34, 56);           int i = 1234;             Method(i, Now);           Method(Now, i);           Method(Now, Now);           Method(i, i);      } }

 

Time 클래스는 TimeInt 예제의 것과 같으며 정수와 Time간의 상호 변환 연산자가 정의되어 있다. Method는 int와 Time을 받는 버전과 Time과 int를 받는 두 개의 버전이 정의되어 있으며 Main에서 Time 객체와 int형 변수로 Method를 호출한다. 이때 앞의 두 호출은 정확하게 일치하는 메서드가 있어 문제가 없다.

그러나 뒤쪽 두 개의 호출은 애매하여 컴파일 거부된다. Method(Now, Now) 호출문은 정확한 버전은 없고 그나마 나은 버전을 찾는다. 컴파일러는 내부 규칙에 의해 호출문과 어울리는 메서드를 찾고 그 중 가장 적합한 메서드를 선택하려고 시도한다. 그런데 두 Method의 점수가 완전히 같아 어떤 것이 더 낫다고 결정할 수 없다.

존재하는 메서드에 끼워 맞추려면 어쨌든 하나의 Time을 int로 변환해야 하는데 순서외에는 차이가 전혀 없다. 마지막 호출문인 Method(i, i)도 마찬가지 이유로 애매하다. 이런 경우를 만나면 컴파일러는 더 이상 잘난 체하지 않으며 항복의 표시로 섬뜩한 에러 메시지를 출력한다. 둘 중 하나를 대충 골라 줄 수 있지만 그 결과에 대해 책임질 수 없기 때문이다.