9-2.인터페이스 활용

9-2-1.열거하기

닷넷 라이브러리도 많은 인터페이스를 제공하며 해당 기능을 구현하는 필수 메서드가 잘 정리되어 있다. 물론 구현은 없고 메서드 목록만 있을 뿐이다. 닷넷 매뉴얼을 보면 종종 다음과 같은 문구를 볼 수 있다.

 

S 기능을 구현하고 싶어? T 인터페이스를 상속받아 X, Y, Z 메서드를 구현해 봐

 

이 지시대로 클래스를 만들면 S 기능을 보유하게 된다. 계약대로 구현해 놓으면 닷넷 라이브러리가 이 객체의 S 기능이 필요할 때 X, Y, Z 메서드를 호출한다. 인터페이스는 계약을 정형화하여 약속을 지키지 않으면 에러 메시지로 응징한다.

인터페이스 활용예로 열거 가능한 클래스를 만들어 보자. 멤버나 요소를 순회하는 foreach 구문이 동작하려면 처음과 끝은 어디인지, 어떤 순서로 순회할 것인지를 구현해야 한다. 이 계약만 잘 지키면 사용자 정의 클래스도 foreach 구문을 쓸 수 있다. 클래스에 열거 기능을 작성하려면 두 개의 인터페이스를 구현해야 한다. IEnumerable 인터페이스는 열거자 객체를 구하는 GetEnumerator 메서드를 정의한다. 자신을 열거하는 도우미 클래스를 선언하고 GetEnumerator 메서드에서 열거자를 생성하여 리턴하면 된다.

도우미 객체는 프로퍼티 하나와 메서드 둘을 가지는 IEnumerator 인터페이스를 상속받아 구현한다. foreach문은 열거 중에 이 메서드를 호출하여 객체 내부를 순회한다. 각 메서드는 약속에 따라 그리고 클래스의 내부 구조에 맞게 구현한다.

 

메서드

설명

object Current

현재값을 구한다. 열거 대상이 임의 타입이므로 object를 리턴한다.

bool MoveNext()

다음값으로 이동하며 끝에 도달하면 false를 리턴한다.

void Reset()

열거를 처음 상태로 돌린다. 최초 아무것도 가리키지 않는 상태여야 한다.

 

임의의 클래스도 열거할 대상이 있다면 이 인터페이스를 구현하면 된다. Time 클래스의 시, 분, 초 세 요소를 순서있는 집합으로 간주하여 열거해 보자.

 

TimeEnum

실행결과

using System;

using System.Collections;

 

class Time : IEnumerable {

             public int hour, min, sec;

             public Time(int h, int m, int s) { hour = h; min = m; sec = s; }

             public IEnumerator GetEnumerator() {

                           return new TimeEnum(this);

             }

}

 

class TimeEnum : IEnumerator {

             private Time T;

             private int element;

             public TimeEnum(Time aT) {

                           T = aT;

                           Reset();

             }

             public bool MoveNext() {

                           if (element < 2) {

                                        element++;

                                        return true;

                           } else {

                                        return false;

                           }

             }

             public object Current {

                           get {

                                        switch (element) {

                                        case 0: return T.hour;

                                        case 1: return T.min;

                                        case 2: return T.sec;

                                        default: return null;

                                        }

                           }

             }

             public void Reset() {

                           element = -1;

             }

}

 

class CSTest {

             static void Main() {

                           Time Now = new Time(18, 25, 55);

                           foreach (int hms in Now) {

                                        Console.WriteLine(hms);

                           }

             }

}

18

25

55

 

Time 클래스는 IEnumerable을 상속받아 GetEnumerator를 구현한다. TimeEnum 객체를 생성하여 리턴하는데 이 객체가 열거자이다. TimeEnum은 IEnumerator로부터 상속받은 메서드와 프로퍼티를 구현한다. 생성자는 열거 대상 객체를 받아 T에 저장한다. element 는 어떤 요소를 가리키고 있는지 기억하는 첨자이다. Reset에서 -1로 초기화하여 최초 아무 요소도 가리키지 않다가 MoveNext가 1 증가시켜 다음 요소로 이동하고 마지막 요소인 2이면 false를 리턴한다.

element는 -1에서 MoveNext에 의해 0, 1, 2로 증가한다. Current 프로퍼티는 element 위치의 요소를 읽는데 0, 1, 2에 대해 각각 시, 분, 초를 리턴한다. 요소의 순서는 마음대로 정할 수 있지만 큰 단위부터 작은 단위로 순회하는 것이 자연스럽다. foreach문으로 Now 객체를 순회하면 각 요소가 hms에 조사되며 이 값을 화면에 출력했다. 시, 분, 초 요소가 차례대로 출력된다. 각 메서드의 역할을 이해하면 내부에서 무슨 일이 일어나는지 대충 짐작할 수 있다. 아마 다음과 비슷할 것이다.

 

static void Main() {

         Time Now = new Time(18, 25, 55);

         IEnumerator E = Now.GetEnumerator();

         E.Reset();

         while (E.MoveNext()) {

                      Console.WriteLine((int)E.Current);

         }

}

 

GetEnumerator를 호출하여 열거자 객체를 구하고 열거자의 Reset을 호출하여 순회 준비를 한다. MoveNext로 다음 요소로 이동하면서 Current 프로퍼티를 읽는다. 이 과정을 MoveNext가 false를 리턴할 때까지, 즉 모든 요소를 다 순회할 때까지 반복한다. foreach의 내부 동작이 이러함으로 열거 가능 객체는 약속대로 열거자와 열거 관련 메서드를 구현해야 한다. 열거 방식은 클래스가 마음대로 결정할 수 있지만 열거 능력 자체는 꼭 있어야 한다. 이 능력에 대한 명세가 인터페이스이다.

GetEnumerator 메서드를 주석 처리하면 필수 메서드를 구현하지 않아 에러 처리된다. Time 클래스 선언문의 IEnumerable을 빼 버리면 Time은 컴파일되지만 foreach에서 자격 미달인 객체는 열거할 수 없다고 징징대며 파업해 버린다. 왜 인터페이스를 계약이라고 하는지 이해될 것이다.

TimeEnum 클래스는 Time 객체의 열거를 위해서만 사용된다. 분석 편의상 외부에 선언했지만 형식성을 따진다면 Time 클래스의 내부 타입으로 선언하고 private로 숨기는 것이 바람직하다. 필요한 타입을 내부에 품고 있으면 기동성이 좋아진다.

 

class Time : IEnumerable {

         private class TimeEnum : IEnumerator {

         ....

 

열거 관련 인터페이스가 둘로 나누어져 있는 이유는 뭘까? 번거롭게 열거자 객체를 따로 둘 필요 없이 Time이 직접 IEnumerator를 구현할 수도 있다. 이유없이 복잡하게 만들어 놨을 리는 없을 것이고 분명 그럴만한 사정이 있다. 열거자가 꼭 필요한 이유는 이중 루프 때문이다.

 

foreach (int hms in Now) {

         foreach (int hms2 in Now) {

         ....

 

이중 루프는 각 루프의 순회 위치를 루프별로 관리해야 한다. Time이 직접 순회를 관장하면 element 필드가 하나 밖에 없어 두 위치를 따로 기억할 수 없다. 이런 경우를 위해 element를 두 벌 만들면 되지 않냐구? 그럼 삼중 루프는? 결국 루프별로 현재 위치를 따로 관리할 독립된 열거자가 필요하다.

이 상황이 잘 이해되지 않으면 일반 루프를 생각해 보자. for (a) for (a)는 중첩 루프의 제어 변수가 같아 정상 동작하지 않는다. for (a) for (b) 형태여야 각 루프가 독립적으로 돌아간다. 제어 변수가 루프 수만큼 필요하니 따로 생성 가능한 열거자가 필요하다.

9-2-2.반복기

열거 기능은 인터페이스의 규칙대로 메서드만 구현하면 되니 어렵지는 않다. 다만 코드의 양이 많아 번거롭고 잔손질이 많이 간다. 그래서 좀 더 간편하게 구현할 수 있는 반복기(Iterator)라는 새로운 열거 방법을 도입했다. 반복기는 열거 대상 요소를 순서대로 생성하는 구문이다. 열거 방법보다 대상에 초점을 두어 다음 순서가 뭔지만 지정하면 나머지 뒷처리는 컴파일러가 해 준다. 앞 예제를 반복기로 다시 작성해 보자.

 

TimeIterator

실행결과

using System;

using System.Collections;

 

class Time {

             public int hour, min, sec;

             public Time(int h, int m, int s) { hour = h; min = m; sec = s; }

             public IEnumerator GetEnumerator() {

                           yield return hour;

                           yield return min;

                           yield return sec;

             }

}

 

class CSTest {

             static void Main() {

                           Time Now = new Time(18, 25, 55);

                           foreach (int hms in Now) {

                                        Console.WriteLine(hms);

                           }

             }

}

18

25

55

 

Time 클래스는 GetEnumerator 메서드 안에 반복기 블록을 작성한다. 길이는 짧지만 동작은 같은데 압축된 코드여서 직관적으로 이해하기 어렵다. 반복기 블록은 문법보다는 의미론적으로 정의되며 컴파일러가 의도를 분석하여 필요한 코드를 생성한다. 메서드나 연산자, get 접근자가 반복기 블록이 되는데 다음 조건을 만족해야 힌다.

 

① 내부에 값을 생성하는 yield 명령이 있어야 하며 다음 두 가지 형태로 사용한다. yield를 쓸 수 있는 위치는 제약 사항이 많다. finally 블록이나 catch가 있는 try 블록, 익명 메서드, 안전하지 않은 코드에서는 사용할 수 없다.

 

yield return 값 : 열거값을 생성한다. 요소의 타입은 동일해야 한다.

yield break : 값 생성을 종료한다.

 

② 함수의 리턴 타입은 다음 4가지 중 하나여야 한다. 제네릭 버전과 비제네릭 버전의 인터페이스 중 하나를 리턴한다. 비제네릭 버전이 리턴하는 타입은 object이며 제네릭 버전이 리턴하는 타입은 타입 인수인 T이다.

 

System.Collections.IEnumerator

System.Collections.Generic.IEnumerator<T>

System.Collections.IEnumerable

System.Collections.Generic.IEnumeraable<T>

 

③  열거 범위나 방법을 전달받기 위한 인수를 취할 수 있지만 사용자가 호출하는 메서드가 아니어서 ref, out 인수는 취할 수 없다. 컴파일러가 단계적으로 실행하므로 return 문을 쓸 수 없으며 yield 문으로 열거 대상 값을 생성하는 코드만 있어야 한다.

 

예제의 GetEnumerator 메서드는 IEnumerator 타입을 리턴하며 세 시간 요소를 yield 명령으로 차례대로 리턴하여 열거한다. yield 명령은 한꺼번에 실행되는 것이 아니라 컴파일러에 의해 순서대로 호출되며 다음 호출 위치를 기억해 둔다.

조건을 만족하는 반복기 블록이 발견되면 컴파일러가 열거자 클래스를 만든다. private 속성의 내부 타입으로 정의하여 객체를 생성하고 관리한다. 이 클래스에는 foreach문이 요구하는 Current 프로퍼티, MoveNext, Dispose 메서드 등이 포함된다. 단, Reset 메서드는 없어 순차 순회만 가능하다. 컴파일러는 위 예제를 다음과 같이 변형하여 컴파일한다.

 

class Time {

         public int hour, min, sec;

         public Time(int h, int m, int s) { hour = h; min = m; sec = s; }

         public IEnumerator GetEnumerator() {

                      return new __Enumerator ();

         }

         private class __Enumerator() {                   // 컴파일러가 생성하는 클래스

                      int __state;

                      object __current;

 

                      public object Current { ... }

                      public bool MoveNext { ... }

                      public void Dispose { ... }

         }

}

 

__Enumerator 내부 클래스를 정의하고 GetEnumerator 메서드는 이 클래스의 객체인 열거자를 생성하여 리턴한다. 열거자 클래스는 상태를 관리하는 __state 필드를 가지며 before, suspended, running, after 네 가지 상태를 유지한다. MoveNext나 Current는 상태에 따라 다음 동작을 결정하며 상태를 변경하여 다음 호출 가능한 명령을 구분한다.

상태 관리나 요소를 구하는 방식이 스펙 문서에 기술되어 있지만 굳이 다 알 필요는 없으며 알아서 잘 만들어 놨겠거니 생각해도 무방하다. 규칙에 맞게 반복기 블록만 작성해 놓으면 foreach와 컴파일러가 다 알아서 한다. 각 열거자가 상태를 관리해 이중 루프도 가능하다.

다음 예제는 한강의 다리를 동쪽에서 서쪽으로 열거한다. 열거할 요소가 많아 정적 배열에 다리 이름을 저장해 두고 루프를 돌며 하나씩 리턴한다. 한강 다리에 번호가 붙어 있는 것은 아니므로 순서대로 배열에 몰아 놓고 돌리는 수밖에 없다. 열거자 객체는 루프의 첨자 i도 필드로 포함하여 다음 반복 대상을 기억한다.

 

EnumBridge

실행결과

using System;

using System.Collections;

 

class HanBridge {

             static string[] Bridge = {"팔당", "강동", "광진", "천호", "올림픽", "잠실",

                           "청담", "영동", "성수", "동호", "한남", "반포", "동작", "한강", "원효",

                           "마포", "서강", "양화", "성산", "가양", "방화", "행주", "김포", "일산"};

             public IEnumerator GetEnumerator() {

                           for (int i = 0; i < Bridge.Length; i++) {

                                        yield return Bridge[i];

                           }

             }

}

 

class CSTest {

             static void Main() {

                           HanBridge hb = new HanBridge();

                           foreach (string b in hb) {

                                        Console.WriteLine(b);

                           }

             }

}

팔당

강동

광진

천호

올림픽

잠실

청담

영동

성수

동호

한남

반포

동작

한강

원효

마포

서강

양화

성산

가양

방화

행주

김포

일산

 

한강 다리 이름이 순서대로 출력된다. 객체가 아닌 메서드로도 반복기를 구현할 수 있다. 이름있는 반복기는 IEnumerable 인터페이스를 리턴하는 메서드이다. 메서드는 인수를 받아 값을 순환하는 방법을 결정할 수 있고 오름차순, 내림차순 등 여러 가지 방식으로 열거하는 반복기를 각각 만들어 놓고 번갈아 가며 사용할 수 있다. 다음 예제는 한강 다리 이름을 열거하는 두 개의 반복기 메서드를 정의한다.

 

EnumBridge2

using System;

using System.Collections;

 

class HanBridge {

             static string[] Bridge = {"팔당", "강동", "광진", "천호", "올림픽", "잠실",

                           "청담", "영동", "성수", "동호", "한남", "반포", "동작", "한강", "원효",

                           "마포", "서강", "양화", "성산", "가양", "방화", "행주", "김포", "일산"};

             public IEnumerable EastToWest() {

                           for (int i = 0; i < Bridge.Length; i++) {

                                        yield return Bridge[i];

                           }

             }

             public IEnumerable WestToEast() {

                           for (int i = Bridge.Length - 1; i >= 0; i--) {

                                        yield return Bridge[i];

                           }

             }

}

 

class CSTest {

             static void Main() {

                           HanBridge hb = new HanBridge();

                           foreach (string b in hb.EastToWest()) {

                                        Console.WriteLine(b);

                           }

                           foreach (string b in hb.WestToEast()) {

                                        Console.WriteLine(b);

                           }

             }

}

 

foreach문에서 이름있는 반복기를 컬렉션처럼 지정하여 열거한다. 한강 다리 이름이 동에서 서로, 서에서 동으로 두 번 출력된다. 다음 예제는 이름있는 반복기로 구구단 예제를 만든다.

 

GuGuEnum

using System;

using System.Collections;

 

class CSTest {

             public static IEnumerable IntIterator(int s, int e) {

                           for (int i = s; i <= e; i++) yield return i;

             }

             static void Main() {

                           foreach (int x in IntIterator(1, 9))

                                        foreach (int y in IntIterator(1, 9))

                                                     Console.WriteLine($"{x} * {y} = {x * y}");

             }

}

 

IntIterator 메서드는 s~e 사이의 정수를 열거하는 정수 열거자이다. foreach에서 이 객체를 열거하여 1~9 사이를 각각 순회하면서 곱을 출력한다. 이런 식이라면 소수만 리턴하는 반복기나 피보나치 수열을 열거하는 반복기도 만들 수 있다. 이런 약속에 의해 foreach 구문이 가능해진다. 클래스를 만드는 개발자는 인터페이스 구현하랴 반복기 만들랴 힘들겠지만 최종 사용자는 foreach로 한방에 순회 가능하다.

반복자는 처음 보면 무척 헷갈리는 구조이다. 반복기는 개발자에게 사용 대상이지 직접 만드는 경우는 흔치 않다. 꼭 필요하다면 위 예제의 코드중 비슷한 것을 복사해 조금만 뜯어 고치면 된다. 인터페이스는 구현틀도 비슷해 복사해 붙이기 내공으로 구현 상속하는 작전이 때로는 무난하게 잘 먹혀 든다.

9-2-3.깊은 복사

참조 타입끼리의 대입은 힙에 있는 객체의 번지를 대입하는 것이어서 같은 대상을 가리키며 그래서 한 쪽을 변경하면 다른 쪽도 영향을 받는다. 다음 예제로 확인해 보자.

 

Shallow

using System;

 

class C {

             public int v;

             public C(int av) { v = av; }

}

 

class CSTest {

             static void Main() {

                           C a = new C(1234);

                           C b = a;

                           b.v = 5678;

                           Console.WriteLine("a = {0}, b = {1}", a.v, b.v);

             }

}

실행결과

a = 5678, b = 5678

 

C 클래스에는 정수형 필드 v와 생성자가 있다. C 타입의 객체 a를 1234로 초기화하고 다른 C 타입의 객체 b에 a를 대입한 후 b의 v를 5678로 수정했다. 복사된 사본을 수정했지만 원본인 a도 영향을 받는다.

번지만 복사할 뿐 실제 내용을 복사하지 않는 방식을 얕은 복사라고 한다. 대입에 의해 완전히 독립적인 사본을 생성하려면 ICloneable 인터페이스를 상속받아 Clone 메서드를 구현하여 깊은 복사를 해야 한다.

 

Object Clone ()

 

인수는 취하지 않으며 자신과 똑같은 타입의 객체를 만들어 리턴한다. 임의의 타입에 대해 사본을 생성하기 위해 리턴 타입은 object이다.

 

Clone

using System;

 

class C : ICloneable {

             public int v;

             public C(int av) { v = av; }

             public object Clone() {

                           return new C(v);

             }

}

 

class CSTest {

             static void Main() {

                           C a = new C(1234);

                           C b = (C)a.Clone();

                           b.v = 5678;

                           Console.WriteLine("a = {0}, b = {1}", a.v, b.v);

             }

}

실행결과

a = 1234, b = 5678

 

Clone에서 자신의 값과 같은 새로운 객체를 생성 및 리턴하여 완전한 사본을 만든다. b를 a의 사본으로 만들고 싶다면 a의 Clone 메서드를 호출하여 새 객체를 생성하고 원하는 타입으로 캐스팅한다. b를 어떻게 수정하더라도 원본인 a는 영향을 받지 않는다.

C 클래스는 정수형 멤버 하나 뿐이어서 사본 생성이 쉽지만 내부에 참조 멤버가 있으면 각 멤버도 깊은 복사를 해야 하므로 복잡한 코드가 필요하다. 그러나 사용자는 Clone만 호출하면 사본을 생성하는 모든 처리가 내부에서 완전하게 처리되어 편리하다.

라이브러리 차원에서 굳이 ICloneable 인터페이스를 정의하는 목적은 깊은 복사의 필요성이나 방법을 알려 주려는 것이 아니라 메서드명을 Clone으로 통일하자는 뜻이다. ICloneable 인터페이스는 아무 코드도 없는 텅텅 빈 껍데기에 불과하다. 하지만 이름을 정해 놓으면 Obj is ICloneable 연산식으로 깊은 복사 지원 여부를 확실히 알 수 있다.