CLI - 제공되는 명시적인 파괴자의 비밀

저의 경우, VC++ 8.0 의 C++/CLI 에 대한 매력을 느끼게 된 것은 문맥 구문이니... 뭐 그런 것들이 아니었습니다. 바로 명시적인 delete 구문의 지원이었습니다. 어떻게 그것이 가능할까... 뭔가 Interop 간에 대단한 비밀이 있지 않나 싶었는데요. 역시 파고들어 보니... 결국 ^^; IL 코드내에서 해결할 수 있을 뿐이더군요. (이제와서는, 명시적인 종료자보다 IJW 를 구현한 것에 대해 더 칭찬을 해주고 싶습니다.)

우선, 본격적으로 들어가기에 앞서 미리 다음의 토픽을 먼저 봐주시기 바랍니다.

.NET IDisposable 처리 정리 
; http://www.sysnet.pe.kr/Default.aspx?mode=2&sub=0&pageno=0&detail=1&wid=347

사실, 도움말에도 나타난 위의 토픽을 굳이 한번 더 언급한 것은 이번 토픽을 위해서였습니다.

---

그럼, 하나씩 한번 알아볼까요? ^^

우선 예제 코드가 하나 있어야 할테니, 다음과 같은 클래스를 만들어서 예로 들어보겠습니다.

public ref class MyClass 
{
public:

	MyClass()
	{
	}
};

아래는 위의 코드를 사용하느 main 함수입니다.

int main(array ^args)
{
	MyClass ^myClass = gcnew MyClass();
    return 0;
}

일단, 여기 까지는 크게 일반 C#/VB.NET 클래스와 다른 점이 없습니다. 그런데, 여러분이 (또는 과거의 제가) 어렴풋이 들었던 것 중에, C++/CLI 에서는 delete 구문으로 개체를 명시적으로 해제하는 것을 지원한다고 했지요. 그래서 다음과 같이 delete 를 추가해 보겠습니다.

int main(array ^args)
{
	MyClass ^myClass = gcnew MyClass();
	delete myClass;
    return 0;
}

과연 정말 그럴까요? 위와 같이 하면 CLR Heap 에 할당된 개체가 즉시 삭제되어 메모리 관리 효율이 C++ 과 같아질 수 있을까요? 물론... 대답은 "아니오" 입니다. 실제로, 위의 코드 부분에 대해서 ".NET Reflector" 로 보면 다음과 같이 delete 코드가 확장되어 나오는 것을 확인할 수 있습니다.

internal static int main(string[] args)
{
      MyClass class1 = null;
      class1 = new MyClass();
      IDisposable disposable1 = class1 as IDisposable;
      if (disposable1 != null)
      {
            disposable1.Dispose();
      }

      return 0;
}

위의 코드를 보시고, ^^; 쓴 웃음을 짓는 분도 계실 텐데요. 그렇습니다. "delete myClass;" 구문은 실제로는 해당 개체의 IDisposable 인터페이스 구현여부를 알아내서 그것의 Dispose 메서드를 호출해주는 코드로 대체되어 삽입되는 것 뿐입니다. 이건 사실 기술이라고 부를 수도 없지요. 단지 언어적인 확장에 기인한 것 뿐이니까요. 마치 C# 의 경우 using 예약어를 지원하지만, 결국 생성된 코드는 try / finally 에 Dispose 메서드를 불러주는 코드로 확장되는 것과 다를 바 없습니다. 실제로, 우리가 기대했던 CLR Heap 의 메모리 정리 상황은 발생하지 않는 다는 것이 중요할 것입니다. 위의 방식을 아셨으니, 이제 쓰게 될 나머지 부분은 다 그러한 부분의 확장으로 받아들이시면 이해가 금방 되실 텐데요.

가만 있자... 그럼 또 뭐가 있을까요? 그렇군요. 우리가 알고 있던 얘기 중에, C++/CLI 는 파괴자를 구현하면 scope 을 벗어나는 경우 자동으로 호출된다고 들었지요. 그럼 그 부분도 한번 살펴볼까요? 예를 위해 위의 코드를 다음과 같이 수정해 보겠습니다.

public ref class MyClass 
{
	char *m_pBuf;
public:

	MyClass()
	{
		m_pBuf = new char[ 4096 ];
	}

	~MyClass()
	{
		delete [] m_pBuf;
	}
};

scope 을 벗어나는 것을 테스트 하기 위해서 MyClass 에 대한 명시적인 delete 없이 다음과 같은 스택 방식으로 수정을 하겠습니다.

int main(array ^args)
{
	MyClass myClass;
	return 0;
}

역시 이번에도 생성된 IL 코드를 ".NET Reflector" 로 확인해 보겠습니다.

internal static int main(string[] args)
{
      int num2;
      MyClass class1 = null;
      MyClass modopt(IsConst) local1 = (MyClass modopt(IsConst)) new MyClass();
      try
      {
            class1 = local1;
            num2 = 0;
      }
      fault
      {
            class1.Dispose();
      }
      class1.Dispose();
      
      return num2;
}

오... 이런... ^^; 역시 이번에도 실제로는 Managed 클래스를 스택상에 생성하지 않고 CLR Heap 에 할당하고는 fault 처리기에서 Dispose 가 명시적으로 불릴 수 있도록 하는 IL 코드로 확장이 되었습니다. 
재미있는 것은, MyClass 를 IL 코드로 열어보면 C++ 구문의 파괴자를 구현한 것이 실제로는 다음과 같이 IDisposable 패턴으로 확장된 것을 볼 수 있습니다.

public class MyClass : IDisposable
{
      public MyClass();
      private void ~MyClass();
      public sealed override void Dispose();
      protected virtual void Dispose([MarshalAs(UnmanagedType.U1)] bool);

      private unsafe sbyte modopt(IsSignUnspecifiedByte)* m_pBuf;
}

패턴은 이전 토픽에서 살펴봤던 C# 과 동일한 구조를 따르고 있습니다.

정리해 보면, C++/CLI 의 자원해제 기능은 결국 C++ 과 유사한 구문을 그대로 유지하되 내부적으로는 IDisposable 구문으로 확장해주는 것에 불과하다는 것입니다.

즉, C++/CLI 에서 다음과 같이 코딩을 한 것은,

	MyClass ^myClass = gcnew MyClass();
	delete myClass;
	
	또는,
	
	MyClass myClass;

C# 으로 다음과 같이 코딩을 해줄 수가 있습니다.

  using ( MyClass myClass = new MyClass() )
  {
  }  

C++/CLI 에서는 단지 구문을 단순하게 해준다는 장점만 있을 뿐, 그 이외의 어떠한 장점도 없다는 것입니다.

---

이미 앞에서 다뤘던 .NET IDisposable 처리 정리의 토픽과 비교해 보시면 아직 얘기하지 않은 이야기가 하나 있음을 아시게 될 텐데요. 바로 Managed 자원 해제와 Unmanaged 자원해제를 구분지어 해제하는 방법이 과연 무엇이냐는 것입니다. C# 의 경우, IDisposable 인터페이스를 구현하고 내부적으로 Dispose(bool disposing) 메서드를 호출하는데, C++/CLI 에서는 IDisposable 인터페이스를 자동으로 구현하기 때문에 bool disposing 에 대한 처리를 하는 부분이 모호해 지기 때문입니다. 이를 위해, C++/CLI 에서는 다음과 같은 특별한 구문의 파괴자를 하나 더 지원합니다.

public ref class MyClass 
{
	char *m_pBuf;
public:

	MyClass()
	{
		m_pBuf = new char[ 4096 ];
	}

	~MyClass()
	{
		// Managed 자원과 Unmanaged 자원을 모두 해제
		delete [] m_pBuf;
	}

	!MyClass()
	{
		// Unmanaged 자원을 해제
		delete [] m_pBuf;
	}
};

이 부분에서 약간 재미난 현상을 만나게 되는데요. Unmanaged 자원에 대한 해제 코드를 중복시키지 않기 위해 ~MyClass 에서 !MyClass 를 아래와 같이 호출하게 되면 컴파일 오류가 발생하게 됩니다.

	~MyClass()
	{
		!MyClass(); // error C2088: '!' : illegal for class	d:\...\Test.h
	}

	!MyClass()
	{
		delete [] m_pBuf;
	}

대신에 다음과 같이 포인터 구문을 쓰게 되면 정상적으로 호출이 됩니다.

	~MyClass()
	{
		this->!MyClass(); // 또는 MyClass::!MyClass();
	}

	!MyClass()
	{
		delete [] m_pBuf;
	}

---

이로써, C++/CLI 의 명시적인 종료자에 대해서 왠만큼 살펴본 것 같은데요. 
결론을 내려보면. C++/CLI 가 자원 해제 면에서 결코 우수한 언어가 아님을 알게 됩니다. 그저 Interop 만 우수한 언어일 뿐.

출처 : http://www.sysnet.pe.kr/Default.aspx?mode=2&sub=0&pageno=1&title=%25c%2B%2B%25&wid=349&detail=1