[C++] 16-3. 상속(Inheritance)관계의 인스턴스 생성, 소멸

 

상속 관계에서 생성되는 인스턴스의 유형 중 다형성을 기반으로 만들어진 인스턴스는 보통 파생클래스(Derived Class)를 통해 기본 클래스(Base Class)를 초기화합니다. 상속 관계에서 파생 클래스의 인스턴스를 만든다 하더라도 내부적으로는 기본 클래스의 인스턴스까지 만들어지지만 기본 클래스의 생성자는 임의로 호출할 수 없기 때문입니다.

반대로 인스턴스의 소멸도 마찬가지입니다. 파생 클래스만 소멸하고 기본 클래스의 영역이 소멸되지 않으면 메모리 누수(Memory Leak)가 발생할 가능성이 있기 때문에 이 또한 파생 클래스에서 책임져야 합니다.

 

 

생성자(Contructor)

기본 클래스(Base Class)의 생성자 호출: 파생 클래스(Derived Class)의 생성자가 호출되기 전에 먼저 기본 클래스의 생성자가 호출됩니다. 기본 클래스의 생성자는 해당 클래스의 멤버 변수 및 기타 초기화를 담당합니다. 기본 클래스의 생성자 호출은 파생 클래스의 생성자의 초기화 목록(initialization list)에서 수행됩니다.

파생 클래스(Derived Class)의 생성자 호출: 기본 클래스의 생성자 호출이 완료되면, 파생 클래스의 생성자가 호출됩니다. 파생 클래스의 생성자는 기본 클래스의 생성자 호출 후에 실행되는 코드를 포함합니다. 이 코드는 파생 클래스의 멤버 변수를 초기화하거나 추가적인 작업을 수행하는 데 사용됩니다.

상속 관계에서 파생 클래스의 생성자는 기본 클래스의 생성자를 호출해야 합니다. 이렇게 하면 기본 클래스의 멤버 변수가 올바르게 초기화되고, 파생 클래스의 생성자에서는 해당 클래스에 특화된 작업을 수행할 수 있습니다.

class Base {
private:
	int baseValue;
public:
    Base(int value) : baseValue(value) 
    {
        // 기본 클래스 생성자의 코드
        // 멤버 변수 초기화 등을 수행
    }
};

class Derived : public Base {
private:
	int derivedValue;
public:
    Derived(int value1, int value2) : Base(value) 
    {
    	derivedValue = value2;
        // 파생 클래스 생성자의 코드
        // 멤버 변수 초기화 및 추가 작업 수행
    }
};

위 간단한 예제에서, 자식 클래스(파생 클래스)는 2개의 생성자 인자를 받고 그중 하나는 부모 클래스(기본 클래스)의 생성자를 호출하며, 나머지 하나는 자신이 사용합니다. 만약 부모 클래스의 생성자를 자식 클래스에서 책임지지 않는다면, 부모 클래스의 생성자를 호출할 수 있는 방법은 없습니다.

 

물론, 부모클래스의 생성자에서 해야하는 일을 init과 같은 함수를 만들어서 호출할 수 있습니다. 어디까지나 생성자의 이야기입니다. 대부분의 멤버변수의 초기화는 생성자가 맡고 있기 때문에 위와 같이 부모 클래스의 생성자 호출이 매우 일반적입니다.

 

 

소멸자(Destructor)

파생 클래스(Derived Class)의 소멸자 호출: 객체가 파괴되는 시점에 파생 클래스의 소멸자가 호출됩니다. 소멸자는 해당 클래스의 객체가 소멸될 때 필요한 정리 작업을 수행합니다. 파생 클래스의 소멸자는 파생 클래스에 추가된 멤버 변수 또는 자원을 해제하는 등의 작업을 수행할 수 있습니다.

기본 클래스(Base Class)의 소멸자 호출: 파생 클래스의 소멸자 호출이 완료되면, 기본 클래스의 소멸자가 호출됩니다. 기본 클래스의 소멸자는 해당 클래스의 객체가 소멸될 때 필요한 정리 작업을 수행합니다. 기본 클래스의 소멸자는 파생 클래스의 소멸자에서 명시적으로 호출되지 않더라도 자동으로 호출됩니다.

상속 관계에서 객체의 소멸은 파생 클래스에서부터 시작하여 기본 클래스까지 거슬러 올라가며 소멸자가 호출되는 반대 순서로 진행됩니다. 이를 "역순 소멸(reverse order of destruction)"이라고도 합니다. 이 순서는 객체가 생성될 때와는 반대로, 기본 클래스의 소멸자가 먼저 호출되고 파생 클래스의 소멸자가 나중에 호출되는 것입니다.

class Base {
private:
	int* ptr[64];
public:
    Base() {
        // 기본 클래스 생성자 코드
    }
    ~Base() {
    	delete ptr[];
        // 기본 클래스 소멸자 코드
    }
};

class Derived : public Base {
public:
    Derived() {
        // 파생 클래스 생성자 코드
    }
    ~Derived() {
        // 파생 클래스 소멸자 코드
    }
};

위의 예시에서 Derived 클래스는 Base 클래스를 상속하고 있습니다. 객체가 소멸될 때는 ~Derived()가 먼저 호출되고, 그 후에 ~Base()가 호출됩니다. 이렇게 함으로써 파생 클래스의 소멸자에서 추가적인 정리 작업을 수행한 후, 기본 클래스의 소멸자에서 해당 클래스의 자원을 해제할 수 있습니다.

 

 

 

다형성 관계에서의 가상 소멸자(Virtual Destructor)

C++에서 가상 소멸자(virtual destructor)는 기본 클래스에 대한 포인터나 참조를 사용하여 파생 클래스 객체를 다룰 때 중요한 역할을 합니다. 파생 클래스의 소멸자를 가상 소멸자로 선언하면, 동적 할당된 객체를 제대로 소멸시키고 메모리 누수(memory leaks)를 방지할 수 있습니다.

가정해 봅시다. 기본 클래스에 대한 포인터로 파생 클래스 객체를 가리키고 있는 상황에서 파생 클래스의 객체를 삭제하려고 합니다. 그러나 기본 클래스의 소멸자가 가상이 아닌 경우(기본 클래스의 소멸자가 virtual이 아닌 경우), 파생 클래스의 소멸자가 호출되지 않을 수 있습니다. 이는 파생 클래스의 멤버 변수 또는 동적으로 할당된 메모리 등이 적절하게 해제되지 않는 문제를 초래할 수 있습니다.

다음은 virtual 소멸자를 사용하지 않은 예시 코드입니다.

#include <iostream>

class Base {
public:
    Base() {
    	std::cout << "Base()" << endl;
        // 기본 클래스 생성자 코드
    }
    ~Base() {
    	std::cout << "~Base()" << endl;
        // 기본 클래스 소멸자 코드
    }
};

class Derived : public Base {
public:
    Derived() {
    	std::cout << "Derived()" << endl;
        // 파생 클래스 생성자 코드
    }
    ~Derived() {
    	std::cout << "~Derived()" << endl;
        // 파생 클래스 소멸자 코드
    }
};

int main() {
    Base* ptr = new Derived();
    delete ptr; // 문제가 발생할 수 있음
    return 0;
}

/* 실행결과
Base()
Derived()
~Base()
*/

 

위의 예시에서 ptr은 Base 클래스의 포인터지만, 실제로 Derived 클래스의 객체를 가리키고 있습니다. 그러나 Base 클래스의 소멸자가 가상이 아니기 때문에 delete ptr 문장이 실행될 때 파생 클래스인 Derived의 소멸자가 호출되지 않을 수 있습니다. 이는 Derived 클래스에서 동적으로 할당된 메모리 또는 추가적인 정리 작업이 제대로 이루어지지 않는 문제를 초래할 수 있습니다.

따라서 Base 클래스의 소멸자에 virtual을 붙여 가상 소멸자로 선언해야 합니다:

#include <iostream>

class Base {
public:
    Base() {
    	std::cout << "Base()" << endl;
        // 기본 클래스 생성자 코드
    }
    virtual ~Base() {
    	std::cout << "~Base()" << endl;
        // 기본 클래스 소멸자 코드
    }
};

class Derived : public Base {
public:
    Derived() {
    	std::cout << "Derived()" << endl;
        // 파생 클래스 생성자 코드
    }
    ~Derived() {
    	std::cout << "~Derived()" << endl;
        // 파생 클래스 소멸자 코드
    }
};

int main() {
    Base* ptr = new Derived();
    delete ptr; // 문제가 발생할 수 있음
    return 0;
}

/* 실행결과
Base()
Derived()
~Derived()
~Base()
*/

Base 클래스의 소멸자를 virtual로 선언하면, delete ptr 문장이 실행될 때 Derived 클래스의 소멸자가 올바르게 호출됩니다. 이로써 Derived 클래스에서 동적 할당된 메모리 또는 추가적인 정리 작업을 적절하게 수행할 수 있게 됩니다.