main 함수를 보자. 먼저 Str형의 객체 you를 생성하고 생성자가 호출되어 데
이터 멤버 neme이 초기화 문자열 "Han Sung An"으로(정확하게는 그 번지로) 초
기화된다. 이때 생성자 내에서 메모리의 동적 할당이 발생했다. 그리고 화면을
지우고 난 후에 멤버 함수 outstr을 호출해서 문자열을 출력했다. main 함수가
끝나는 시점에서 main 함수 내부의 지역 변수인 you 객체는 통용 범위를 벗어
나게 되므로 메모리에서 삭제(파괴)된다.
객체의 삭제란 객체가 점유하고 있던 메모리를 다시 자유 메모리로 돌리는 것
을 말한다. 그래서 you 객체가 차지하고 있던 2바이트가 메모리로부터(지역 변
수니까 stack) 사라진다. 그러나 이때 문제가 되는 것은 객체는 분명히 없어지
지만 객체에 의해 동적으로 할당되어 있던 메모리는 그대로 할당된 채로 남아
있는다. 왜냐하면 동적으로 할당된 메모리는 객체에 소속되어 있지 않기 때문
에 객체 삭제시 같이 삭제되지 않는다. new나 malloc등에 의해 동적으로 할당
된 메모리는 반드시 delete나 free에 의해 능동적으로 할당이 해제되어야 함을
상기하자.
이러한 문제를 해결하기 위해 C++에서는 객체가 삭제되기 직전에 반드시 파괴
자라고 불리는 특별한 함수를 호출하여 객체 자신이 할당한 메모리를 책임지고
할당 해제할 기회를 준다. 이것이 바로 파괴자(destructor)의 개념이다.
객체 Str의 파괴자 ~Str()은 delete name;이라는 할당 해제를 하도록 정의되어
있다. 객체가 통용 범위를 벗어날 때 객체 자체가 삭제됨은 물론 객체가 할당
한 메모리도 파괴자에 의해 삭제되므로 객체가 생성되기 전의 상태로 원상 복
귀가 된다.
파괴자는 주로 이런 동적 메모리 할당 해제에 사용이 되지만 다른 여러 가지
목적으로 사용될 수 있다. 예를 든다면 객체 obj가 특정 텍스트 속성을 사용한
다고 하자. 이때 생성자에서 textattr 함수에 의해 자신이 원하는 속성으로 설
정을 한다면 파괴자에서는 속성을 원위치시켜야 한다. 또한 특정한 그래픽 상
태나, 통신 port의 상태를 원하는 객체에서는 생성자에서 통신 port를 조작하
고 파괴자에서는 다시 원위치시킨다.
일반적으로 생성자는 객체가 동작하기 위한 환경을 설정하고 파괴자는 객체가
사라질 때 다른 객체가 변경된 환경에 영향을 받지 않도록 하기 위해 환경을
원위치시킨다. 여기서 환경이란 메모리, 그래픽 board 기타 등등의 모든 컴퓨
터 구성 요소가 될 수 있지만 주로 메모리, 그중에서도 특히 동적 할당의 대상
이 되는 heap을 말한다.
잠깐 여기서 생성자, 파괴자의 존재 이유에 대해 생각해보자. 왜 필요한가를
안다는 것은 벌써 반 이상을 아는 것이 된다. 클래스가 다른 데이터 타입과 동
등이라고 하는데 다른 데이터 타입에는 없는 생성자, 파괴자가 왜 유독 클래
스에만 필요한가?
그 이유는 클래스가 워낙 변화무쌍하고 사용자에 의해 자유자재로 만들어질
수 있기 때문이다. 사용자의 자유를 보장해주고자 하다보니 초기화 식이 int i
=3; 등으로 간단해지지가 않고 특별한 함수가 필요하게 되어 생성자라는 멤버
함수가 생겨나게 되었다. 또한 생성자를 만들어 놓고 보니 몇 가지 문제가 생
겨 생성자가 벌려놓은 일을 뒤치닥거리 해줄 파괴자라는 것이 필요하게 된 것
이다.
다. 생성자, 파괴자의 특징
생성자와 파괴자의 대충적인 개념과 형태에 관해 공부해보았다. 생성자와 파
괴자는 일반 함수와는 달리 자동으로 호출되고 맡은 일 자체가 특수한 목적을
띤 일이므로 그 성격이 일반 함수와는 다른 점이 많이 있으며 주의해야 할 사
항도 많다. 다음에 설명한 생성자, 파괴자의 특징을 자세히 읽어보고 그 성질
에 관해서 상세히 알아둘 필요가 있다. 다소 복잡해 보이는 내용이기는 하지만
개념만 확실히 깨우치고 있다면 특징들이야 지극히 당연한 것으로 이해될 것이
다. 가벼운 마음으로 읽어보고 고개 한번 끄덕이고 지나가면 된다.
첫째, 이름이 정해져 있다.
앞에서 언급했지만 클래스 KISS가 있을 경우 생성자의 이름은 자동적으로 KIS
S()가 되고 파괴자의 이름은 ~KISS()가 된다. 사용자가 이름을 마음대로 정하
지 못하고 클래스의 이름을 따라가는 이유는 간단하다. 생성자, 파괴자는 사용
자에 의해 능동적으로 호출되는 것이 아니라 시스템에 의해 객체가 생성, 파괴
될 때 자동으로 호출되는 특성이 있다. 이때 시스템이 생성자, 파괴자를 호출
하기 위해서는 생성자, 파괴자의 이름을 알 수 있어야 하는데 이름을 사용자
마음대로 정하도록 내버려 두었다가는 어느 함수가 생성자인지, 파괴자는 어떤
함수인지를 분간해내지 못하는 모호함이 발생해 버린다. 그래서 멍청한 컴파일
러를 위해 생성자와 파괴자의 이름을 클래스의 이름으로부터 찾을 수 있도록
미리정해 놓았다.
둘째, 리턴값이 없다.
리턴값이 없는 이유는 리턴값을 받아줄 대상이 없기 때문이다. 생성자 파괴자
는 생성되고 파괴될 때 정해진 일을 하도록 되어 있는 함수이지 어떤 값을 조
사하거나 계산하는 함수가 아니다. 일반 함수에 비유하자면 void형 함수에 해
당한다. 그러나 void형이라는 형조차 밝힐 필요도 없다(물론 밝혀도 문제는 없
다).
다른 멤버 함수는 리턴하는 데이터 타입이 있지만 생성자 파괴자는 곧바로 함
수의 이름이 나온다. 클래스 KISS의 생성자의 원형을 밝히라고 한다면 KISS(),
또는 KISS(인수형) 등이 되지 void KISS(), int KISS()가 되지는 않는다. 리턴
값이 없으므로 생성자, 파괴자의 본체에서는 return문을 쓸 필요가 없다.
세째, 생성자는 인수가 있다.
생성자는 데이터 멤버의 초기화를 주로 담당한다. 따라서 생성자 호출시에 데
이터 멤버를 어떻게 초기화시킬 것인가에 대해 인수로 알려주어야 한다. 인수
를 전달해주는 방식도 여러 가지가 있으며 인수가 있음으로 해서 다형성이 성
립되고 따라서 생성자는 인수가 다르면 여러 개 존재할 수 있다.
보통 대여섯개의 생성자가 존재하는 클래스가 허다하다. 객체 생성시에 인수
의 개수와 타입을 보고 어떠한 생성자가 호출될 것인가를 결정하여 적당한 생
성자가 호출된다. 객체를 생성할 때는 생성자 함수의 인수를 객체 뒤에 괄호로
묶어 넘겨 주어야 한다.
네째, 파괴자는 인수가 없다.
생성자는 하는 일이 데이터 멤버에 값을 주어 만드는 일을 하므로 어떻게 만
들 것인가가 전달되어야 하고 따라서 인수가 필요하다. 하지만 파괴자는 주로
할당된 것을 지워 객체 생성 전의 원 상태로 만드는 일을 하며 삭제하는 일에
어떻게 삭제할 것인가 라는 방법이 있을 수 없는 관계로 인수가 필요없다. 즉
없애면 그냥 없애는거지 어떻게 없애는가를 가르쳐 줄 필요가 없다는 것이다.
파괴자는 무조건 인수가 없으며 인수가 없는 관계로 다형성이 성립되지 않게
되고 여러 개의 파괴자가 존재할 수 없다. 한 클래스에는 오직 한 개의 파괴자
만 존재할 수 있다. 클래스 KISS의 파괴자는 무조건 ~KISS()여야 한다. ~KISS
(int), ~KISS(int,double) 등의 파괴자는 있을 수 없다.
설사 파괴자에 인수를 줄 수 있다고 해도 줄 방법도 없지 않은가? 생성자는
생성된 객체 다음에 괄호를 열고 인수를 적어 주지만 파괴자는 자동으로 호출
되는 것이기 때문에 인수를 전달할 기회가 없다.
다섯째, 생성자, 파괴자에도 default가 있다.
만약 어떤 클래스에 생성자도 파괴자도 정의되어 있지 않다면 어떻게 될것인
가. 이때는 객체가 생성될 때나 파괴될 때 아무 일도 하지 않게 된다. 생성할
때 특별히 초기화를 할 필요가 없다면 생성자가 없어도 되지만 보통 생성자는
만들어 두어 초기화를 시키는 것이 보편적이다. 파괴할 때 특별히 삭제해야 할
일이 없다면 파괴자가 없어도 되며 파괴자는 정의하지 않는 경우가 있다.
그러나 생성자, 파괴자를 정의하지 않았더라도 객체가 생성될 때는 생성자가
호출되고, 파괴될 때는 파괴자가 호출된다. 이때 호출되는 생성자, 파괴자를
디폴트 생성자, 디폴트 파괴자라고 하며 인수도 취하지 않고 아무 일도 하지
않는 있으나마나한 존재이다.
여섯째, 생성자나 파괴자는 friend도 static도 될 수 없다.
friend 함수, static 함수를 배워보면 알겠지만 전혀 그럴 필요가 없다.
일곱째, 파괴자는 가상 함수로 정의될 수 있다.
그러나 생성자는 절대로 가상 함수로 정의될 수 없다. 파괴자가 가상 함수로
정의되는 이유는 특성 상속을 충분히 활용하기 위해서이다. 이 부분에 대해서
는 상속과 가상 함수에 대해 알아본 후에 다시 언급한다.
**********************************************
**********************************************
2-4 액세스 권한 지정자
앞에서 설명을 잠시 보류해 두었던 액세스 권한 지정자(access specifier)에
관해 알아볼 차례이다. C++에서 확장된 구조체와 클래스의 차이는 멤버를 숨기
는가 그렇지 않는가 하는 점이다. 멤버의 내용을 숨긴다는 것은 프로그래밍시
에 여러 가지로 편리함을 주고 bug의 위험을 막아준다. 앞의 예로 쓴 Position
클래스 내부에 있는 정수형 변수 px, py에 대해 생각해보자. 이 데이터 멤버는
화면상에 한 위치를 나타내기 위해서 사용된다. 그 외의 다른 목적에는 사용되
지 않으며 그럴 필요도 없다. 용도가 이렇게 정해져 있는 데이터는 프로그램의
다른 부분에서 함부로 건드리지 못하도록 숨기는 것이 보통이다.
왜냐하면 아무 곳에서나 건드릴 수 있다면 bug가 났을 경우 잡아내기가 곤란
할 뿐만 아니라 클래스를 프로그램의 부품으로 독립성을 준다는 정신에 위배되
기 때문이다. 그래서 클래스 내의 멤버를 다른 부분에서 건드리지 못하도록 원
천적으로 막는 방법이 제공되는데 이것을 정보 은폐(information hiding)라고
한다. 그러나 클래스 내부를 몽땅 다 숨겨 버리면 클래스 외부와의 통신이 두
절되어 버리므로 적절한 범위에서 숨기고 적절한 범위에서 개방한다.
어떤 멤버를 개방하고 어떤 멤버를 숨길 것인가를 지정하는 것을 멤버 액세스
권한 지정자(member access specifier)라고 한다. 액세스 지정자는 다음 세 가
지가 제공되는데 이 중 private와 public을 당장 알아야 하며 protected는 나
중에 상속을 배운 후에 다시 보면 된다.
private:
이 지정 이후의 멤버는 클래스 내의 멤버 함수만 액세스 가능하다. 클래스 밖
으로는 알려지지 않으며 클래스에 속하지 않는 함수는 이 속성의 멤버를 건드
릴 수 없다.
public:
이 지정 이후의 멤버는 클래스 외부로도 알려지며 외부에 있는 함수가 읽거나
쓸 수 있으며 멤버 함수가 이 속성을 가질 경우 외부에서 멤버 함수를 마음대
로 호출할 수 있다. 단, 통용 범위 규칙에 의해 지정되는 범위 내에서만 가능
하다.
protected:
private와 마찬가지로 동일 클래스 내부의 멤버 함수에 의해서 액세스가 가능
하며 클래스 밖의 함수는 건드릴 수 없다. private와 다른 점은 상속이 될 경
우 상속된 클래스에 속한 멤버 함수들도 이 protected 속성의 멤버를 액세스할
수 있다는 점이다. private의 경우 상속이 되면 상속된 클래스의 멤버 함수들
이 이 멤버를 액세스할 수 없으며 오로지 현재의 클래스 내의 멤버 함수만이
액세스할 수 있다. 상속을 하지 않는 클래스라면 private 속성이나 protected
속성이나 차이가 없다.
이어서 계속됩니다. ==============>>>>>>>
-------------------------------------------------------------------------------