항상 나이스한 청키

Smart Pointer랑 결국 같은 내용인데. 글 쓰신분이 자바나 C#에서 Garbage Collection 이라는 용어로 알고 있다. C#에서는 array,list,map등을 Collection이라고 표현을 하던데...

===============================================

다음은 데브피아의 이해석님의 글을 옮겨온 것입니다.

===============================================

자바나 C#을 보면 Garbage Collection이라는 용어가 나옵니다. 메모리 관리를 프로그램상에서 명시적으로 해주지 않아도 자동으로 메모리 관리를 해준다는 용어입니다.

근데 저처럼 C++ 같은 언어밖에 안 써본 사람으로서는 도저히 개념이 안잡히는 얘기입
니다. 허허.. 어떻게 동적으로 할당된 메모리가 자동으로 해제되죠??? 자바로 짜여진 프로그
램을 보면 심지어 소멸자도 없는 모습을 볼 수 있지요... 그럼 그동안의 노가다는... 흑
흑..

그래서 그냥 Garbage Collection이 그저 마법(?) 같은 얘기라고만 생각하고 있다가 자바책을 좀 뒤적이게 되었는데 드디어 그 원리를 알았습니다!!!!
그리고 심지어 C++에서도 그 흉내를 낼 수 있다는 사실도 알게 되었지요.. ^^
우선 그 원리에 대해 알아보도록 하죠.. 우선 자바의 경우는 포인터를 사용하지 않는 대신 레퍼런스를 사용합니다. 여기서 레퍼런스는 C++의 그것과 상당히 유사합니다.
일종의 별명이라고 생각하시면 됩니다. 다만 자바에서는 사용자의 클래스는 항상 레퍼런스로 참조된 형태로만 존재되는 것 같더군요.(저는 자바는 거의 모릅니다..

한 1~2시간 정도 책 뒤적이다가 좀 읽어본 내용이 전부입니다... -.-;;)

어쨌든 어떤 메모리를 할당받은 다음 그것을 어떤 레퍼런스 변수가 참조하도록 만듭니다.
그리고 C++과 같이 여러개의 레퍼런스 변수가 하나의 메모리를 가르키도록 할수도 있습니다.
그러다면 한번 생각해보세요. 과연 메모리 유출이 일어나는 시점이 언제일까요?? 아마 대부분 금방 생각해내셨을 거라 믿습니다.. 어떤 메모리를 가르키는 레퍼런스 변수가 하나도 없을 경우이지요..!!

즉 레퍼런스가 어떤 메모리 공간을 가르킬때마다 참조횟수를 늘렸다가 더 이상 그메모리를 가르키지 않게 되면 참조횟수를 하나씩 줄이다가 참조횟수가 0이 된다면 메모리를 해제하게 되면 메모리 유출의 걱정으로부터 벗어날수가 있는거죠!!!!!
물론 자바에서는 정확히 이렇게 작동하는 것 같지는 않지만 여하튼 C++에서는 JVM의  지원(?) 없이 순수 코드만으로 Garbage Collection을 구현 해야하므로 이런 개념을 같고 프로그램을 짜보도록 하죠....

밑의 코드는 MSDN에서 얻은 코드를 제가 임의로 수정한 것입니다..

 
#include <iostream>
using namespace std;

class RefCount {
   int crefs;public:
  RefCount(void)   {      crefs = 0;   }
   ~RefCount() {}
   void upcount(void) { ++crefs; }
   void downcount(void)
    {
         if (--crefs == 0)
            delete this;
    }
};

class Sample : public RefCount {
public:
   void func1(void) { cout < <  "func1
"; }
};

template < class T> class Ptr 
{
   T* p;

public:

   Ptr(T* p_) : p(p_) { p->upcount(); }
   ~Ptr(void) { p->downcount(); }
   operator T*(void) { return p; }
   T& operator*(void) { return *p; }
   T* operator->(void) { return p; }
   Ptr& operator=(Ptr< T> &p_)
   {        return operator=((T *) p_);   }
   Ptr& operator=(T* p_)   {
       p->downcount(); p = p_; p->upcount(); return *this;
   }
};

int main()
{
   Ptr< Sample> p  = new Sample;
   Ptr< Sample> p2 = new Sample;
   p = p2;
   p->func1();
   return 0;
}

우선 refCount라는 클래스에서 참조횟수를 구하는 멤버변수와 멤버함수들을 정의합니다.
처음 생성될때 0의 참조횟수를 가지도록하고 upcount()와 downcount()라는 멤버함수를 만듭니다. 그리고 downcount()에서 참조횟수를 감소 시킬때 만약 참조횟수가 0이라면 객체를 해제시킵니다.. 우리가 Garbage Collection을 사용하고 싶은 객체들은 모두 이 refCount 클래스를 상속받음으로서 필요한 기능을 구현합니다.
그리고 Ptr이라는 클래스를 보도록하죠. Ptr은 Garbage Collection 기능을 가진 포인 터입니다.
각종 연산자를 재정의 한 건 일반 포인터와 같이 ->나 .을 사용해 멤버연산을 할 수 있도록 하기 위해서 이고요, 여기서 중요한건 복사생성자랑 할당연산자, 그리고 소멸자입니다.
우선 복사생성자를 보면 어떤 포인터가 생성되면서 어떤 메모리공간을 가르키는 게 되기때문에 참조횟수가 하나 늘어나도록합니다. 그리고 할당연산자의 경우에는

a=b;

이런 식의 경우에 a가 가르키고 있는 메모리공간의 경우는 참조 횟수를 하나 줄이고 가 가르키고 있는 메모리 공간은 참조횟수를 하나 늘입니다. a라는 Ptr에 있는 내용이 사라지고 a는 b가 가르키고 있는 메모리 공간을 가르키는 
Ptr이 되기 때문이죠...

그리고 당연히 소멸자의 경우에는 참조횟수를 하나 줄이도록합니다.
이렇게 코딩한다음 예제를 보도록하죠... 우선 Sample이라는 클래스가 refCount클래스를
상속 받도록 코딩하고(위에 이부분까지 코딩 되어있습니다.) 그리고 위의 main함수 부
분을 보도록 하죠..

int main() {
   Ptr< Sample> p  = new Sample;
   Ptr< Sample> p2 = new Sample;
   p = p2;
   p->func1();
   return 0;
}

우선 처음 Sample형 Ptr p의 할당연산자를 불러 어떤 Sample 객체를 가르키도록합니다.
마찬가지로 p2도 또다는 Sample 객체를 가르키도록합니다. 지금 두 Sample 객체는
모두 자신을 가르키는 Ptr이 한개씩 있으므로 참조횟수가 1씩일 겁니다. 그리고
p = p2;

라는 명령을 실행하게 됩니다. 여기서 p가 가르키는 메모리 공간은 참조횟수가 하나 줄게
되죠.. 즉 p가 가르키는 공간은 이전에 참조횟수가 1이었음으로 참조횟수가 0이 되면서
메모리가 해제됩니다!!!! 메모리가 유출되지 않았습니다!! ^^

그리고 p2는 참조횟수가 2가 되죠..

p->func1();

이 명령은 이 Ptr클래스가 일반 포인터와 똑같이 간접멤버연산자를 통해연산될수 있다는것 보여줍니다. 결과는 당연히

func1

입니다.

그리고 main 함수가 끝나게 되죠... 여기서 중요한 건 Ptr은 실제로 포인터가 아닌 클래스 이므로 main함수가 끝나게 되면 자동으로 소멸자가 불리게 되죠.
그러면 p와 p2 두 개 모두 소멸자가 불리게 되고 참조횟수가 2이던 공간의 참조횟수가 0이 되면서 이 부분 역시 메모리가 자동으로 해제 됩니다!!

드디어 C++에서도 new와 delete 없는 프로그래밍이 가능하게 된거죠.. 물론 이런 처리를 하는데 필요한 오버헤드를 감당할 수 있는 경우에 한해서요.. ^^

그럼 이만..