[C++] Inheritance & Virtual function

📚 C++ 상속과 가상 함수

🔸 상속 (Inheritance)

상속의 목적
1. Class Relationship (클래스 관계 표현)

• "is-a" 관계를 코드로 표현
• 예: Cat is an Animal, Dog is an Animal

2. Code Reuse (코드 재사용)

   • 공통 기능을 부모 클래스에 구현
   • 자식 클래스에서 중복 코드 제거

3. Class Interface Consistency (일관된 인터페이스)

   • 같은 부모를 상속받은 클래스들은 동일한 인터페이스 제공
   • 다형성(Polymorphism) 구현의 기반

🔸 상속 접근 지정자 (public/protected/private)

접근 지정자에 따른 멤버 접근 권한 변화

class Base
{
public:
    int x;
protected:
    int y;
private:
    int z;
};

1. public 상속 (가장 일반적)

class Derived : public Base
{
    // x는 public 유지
    // y는 protected 유지
    // z는 접근 불가 (private은 항상 접근 불가)
};

• 부모 클래스의 접근 지정자를 그대로 유지
• "is-a" 관계를 표현할 때 사용
• 대부분의 경우 public 상속을 사용함

2. protected 상속 (드물게 사용)

class Derived : protected Base
{
    // x는 protected로 변경
    // y는 protected 유지
    // z는 접근 불가
};

• 부모의 public 멤버가 protected로 변경
• 외부에서 부모 클래스의 인터페이스 접근 차단
• "implemented-in-terms-of" 관계

3. private 상속 (클래스의 기본값)

class Derived : private Base  // class는 기본값이 private
{
    // x는 private로 변경
    // y는 private로 변경
    // z는 접근 불가
};

• 모든 상속받은 멤버가 private로 변경
• 구현 상속일 때 사용 (인터페이스 상속이 아님)
• 일반적으로 Composition(구성)을 사용하는 것이 더 명확함

접근 권한 정리 표

부모 클래스	public 상속	protected 상속	private 상속
public	public	protected	private
protected	protected	protected	private
private	접근 불가	접근 불가	접근 불가

실전 가이드라인

• 99%의 경우 public 상속을 사용
• protected/private 상속은 특수한 경우에만 사용
• private 상속 대신 멤버 변수로 포함(Composition)하는 것을 권장

// ❌ Private 상속 (혼란스러움)
class Car : private Engine { };

// ✅ Composition (명확함)
class Car {
    Engine engine;  // Car has an Engine
};

🔸 Virtual Function (가상 함수)

가상 함수가 필요한 이유

class Animal
{
public:
    void speak()  // 일반 함수
    {
        std::cout << "Animal sound" << std::endl;
    }
};

class Cat : public Animal
{
public:
    void speak()  // 함수 재정의 (Overriding)
    {
        std::cout << "Meow~" << std::endl;
    }
};

int main()
{
    Cat kitty;
    Animal* ptr = &kitty;  // 부모 타입 포인터로 자식 객체 참조
    
    ptr->speak();  // ❌ "Animal sound" 출력 (Cat의 speak가 아님!)
    return 0;
}

문제점: 포인터 타입이 Animal*이므로 컴파일 타임에 Animal::speak()가 호출됨

virtual 키워드로 해결

class Animal
{
public:
    virtual void speak()  // ✅ 가상 함수로 선언
    {
        std::cout << "Animal sound" << std::endl;
    }
};

class Cat : public Animal
{
public:
    void speak() override  // override 키워드 권장
    {
        std::cout << "Meow~" << std::endl;
    }
};

int main()
{
    Cat kitty;
    Animal* ptr = &kitty;
    
    ptr->speak();  // ✅ "Meow~" 출력 (런타임에 실제 타입 확인!)
    return 0;
}

Dynamic Binding (동적 바인딩)

• 가상 함수는 런타임에 실제 객체의 타입을 확인하여 호출
• 이를 통해 다형성(Polymorphism) 구현

🔸 Virtual Destructor (가상 소멸자)

❗ 중요: Base 클래스의 소멸자는 반드시 virtual로 선언해야 함

문제 상황

class Animal
{
public:
    Animal() { std::cout << "Animal constructor" << std::endl; }
    ~Animal() { std::cout << "Animal destructor" << std::endl; }  // ❌ 가상 소멸자가 아님
};

class Cat : public Animal
{
public:
    Cat() { std::cout << "Cat constructor" << std::endl; }
    ~Cat() { std::cout << "Cat destructor" << std::endl; }
};

int main()
{
    Animal* polyCat = new Cat();
    // 출력:
    // Animal constructor
    // Cat constructor
    
    delete polyCat;
    // 출력:
    // Animal destructor  ❌ Cat destructor가 호출되지 않음!
    // → 메모리 누수 발생!
    
    return 0;
}

해결: 가상 소멸자 사용

class Animal
{
public:
    Animal() { std::cout << "Animal constructor" << std::endl; }
    virtual ~Animal() { std::cout << "Animal destructor" << std::endl; }  // ✅ virtual 추가
};

class Cat : public Animal
{
public:
    Cat() { std::cout << "Cat constructor" << std::endl; }
    ~Cat() override { std::cout << "Cat destructor" << std::endl; }
};

int main()
{
    Animal* polyCat = new Cat();
    delete polyCat;
    // 출력:
    // Cat destructor    ✅ 올바른 순서로 호출됨
    // Animal destructor
    
    return 0;
}

가상 소멸자 규칙

• 상속받을 가능성이 있는 클래스의 소멸자는 반드시 virtual public으로 선언
• 또는 상속을 막으려면 소멸자를 protected로 선언

// ✅ 옵션 1: 상속 허용 + virtual 소멸자
class Base {
public:
    virtual ~Base() = default;
};

// ✅ 옵션 2: 상속 금지 (소멸자 protected)
class Base {
protected:
    ~Base() = default;  // 외부에서 delete 불가
};

// ✅ 옵션 3: C++11 final 키워드
class Base final {  // 상속 불가
public:
    ~Base() = default;
};

🔸 Virtual Table (가상 함수 테이블)

메모리 구조 변화

일반 함수만 있는 경우

class Animal
{
public:
    void speak() { std::cout << "Animal" << std::endl; }
private:
    double height;  // 8 bytes
};

class Cat : public Animal
{
public:
    void speak() { std::cout << "Meow~" << std::endl; }
private:
    double weight;  // 8 bytes
};

// sizeof(Animal) = 8 bytes  (height만)
// sizeof(Cat) = 16 bytes    (height + weight)

가상 함수가 있는 경우

class Animal
{
public:
    virtual void speak() { std::cout << "Animal" << std::endl; }
private:
    double height;  // 8 bytes
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }
private:
    double weight;  // 8 bytes
};

// sizeof(Animal) = 16 bytes  (vptr 8 + height 8)
// sizeof(Cat) = 24 bytes     (vptr 8 + height 8 + weight 8)

Virtual Table (VTable) 구조

Animal 객체 메모리:
┌─────────────┐
│ vptr (8B)  │ → Animal VTable
├─────────────┤   ┌──────────────────┐
│ height (8B)│   │&Animal::speak()│
└─────────────┘   └──────────────────┘

Cat 객체 메모리:
┌─────────────┐
│ vptr (8B)  │ → Cat VTable
├─────────────┤   ┌──────────────────┐
│ height (8B)│   │ &Cat::speak()  │
├─────────────┤   └──────────────────┘
│ weight (8B)│
└─────────────┘

Virtual Table의 동작 원리
1. 가상 함수가 있는 클래스는 vptr (virtual table pointer) 을 가짐 (8 bytes)
2. vptr은 해당 클래스의 VTable을 가리킴
3. VTable에는 가상 함수들의 실제 주소가 저장됨
4. 가상 함수 호출 시 vptr → VTable → 실제 함수 주소로 간접 호출

성능 고려사항

• 가상 함수가 없는 경우: 직접 호출 (빠름)
• 가상 함수가 있는 경우: 간접 호출 (약간 느림, 약 20-30% 오버헤드)
• 메모리: 객체당 vptr 8 bytes 추가

🔸 부모 클래스 포인터의 제약

class Animal
{
public:
    virtual void speak() { std::cout << "Animal" << std::endl; }
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }
    void meow() { std::cout << "Meow meow!" << std::endl; }  // Cat 전용 함수
};

int main()
{
    Cat kitty;
    Animal* ptr = &kitty;
    
    ptr->speak();  // ✅ OK - 가상 함수이므로 Cat::speak() 호출됨
    ptr->meow();   // ❌ 컴파일 에러! Animal 타입으로는 meow() 접근 불가
    
    // 해결 방법 1: Cat 타입 포인터 사용
    Cat* catPtr = &kitty;
    catPtr->meow();  // ✅ OK
    
    // 해결 방법 2: 다운캐스팅 (권장하지 않음)
    Cat* catPtr2 = static_cast<Cat*>(ptr);
    catPtr2->meow();  // ✅ OK (하지만 위험함)
    
    return 0;
}

핵심 원칙

• 부모 타입 포인터로는 부모 클래스에 선언된 멤버만 접근 가능
• 가상 함수는 런타임에 실제 타입의 함수가 호출되지만, 접근 가능 여부는 컴파일 타임에 결정됨
• 자식 클래스 전용 함수를 사용하려면 자식 타입 포인터를 사용해야 함

🔸 Pure Virtual Function (순수 가상 함수)

순수 가상 함수 선언

class Animal
{
public:
    virtual void speak() = 0;  // ✅ 순수 가상 함수
    // = 0 은 "구현이 없음"을 의미
};

Abstract Class (추상 클래스)

• 순수 가상 함수가 하나라도 있는 클래스를 추상 클래스라고 함
• 추상 클래스는 객체를 생성할 수 없음
• 추상 클래스를 상속받은 클래스는 모든 순수 가상 함수를 구현해야 객체 생성 가능

class Animal  // Abstract class
{
public:
    virtual void speak() = 0;  // 순수 가상 함수
    virtual void eat() { std::cout << "Eating" << std::endl; }  // 일반 가상 함수도 가능
    virtual ~Animal() = default;
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }  // ✅ 구현 필수
};

class Dog : public Animal
{
    // ❌ speak()를 구현하지 않음 → Dog도 추상 클래스가 됨
};

int main()
{
    Animal animal;  // ❌ 컴파일 에러! 추상 클래스는 객체 생성 불가
    Cat kitty;      // ✅ OK - speak()를 구현했으므로
    Dog puppy;      // ❌ 컴파일 에러! Dog도 추상 클래스
    
    Animal* ptr = new Cat();  // ✅ OK - 포인터는 가능
    ptr->speak();  // "Meow~"
    delete ptr;
    
    return 0;
}

🔸 Interface (인터페이스)

인터페이스 정의

• 순수 가상 함수만으로 이루어진 클래스
• 구현(implementation)과 멤버 변수가 없음
• 다른 언어(Java, C#)의 interface와 동일한 개념

// ✅ 좋은 인터페이스 설계
class IDrawable  // I 접두사는 인터페이스 표시 (관례)
{
public:
    virtual void draw() = 0;
    virtual void setColor(int r, int g, int b) = 0;
    virtual ~IDrawable() = default;  // 가상 소멸자는 필수
    
    // 멤버 변수 없음
    // 구현된 함수 없음
};

class Circle : public IDrawable
{
public:
    void draw() override { /* 원 그리기 구현 */ }
    void setColor(int r, int g, int b) override { /* 색상 설정 구현 */ }
    
private:
    double radius;
    int red, green, blue;
};

인터페이스 설계 원칙

1. 순수 가상 함수만 포함
   • 구현 코드 없음
   • 멤버 변수 없음
2. 가상 소멸자 필수

   virtual ~IDrawable() = default;

3. 복사/이동 방지 (권장)

   class IDrawable
   {
   public:
       virtual void draw() = 0;
       virtual ~IDrawable() = default;
       
   protected:
       IDrawable() = default;  // 생성자 protected
       IDrawable(const IDrawable&) = delete;  // 복사 금지
       IDrawable& operator=(const IDrawable&) = delete;
   };

인터페이스 사용의 장점

• 유지보수성 향상: 구현과 인터페이스 분리
• 의존성 감소: 구체적인 클래스 대신 인터페이스에 의존
• 테스트 용이: Mock 객체 생성 쉬움
• 플러그인 아키텍처: 런타임에 구현체 교체 가능

// 나쁜 설계: 구체 클래스에 의존
void processImage(JPEGImage& img) { /* ... */ }

// 좋은 설계: 인터페이스에 의존
void processImage(IImage& img) { /* ... */ }
// JPEG, PNG, BMP 등 다양한 구현체 사용 가능

실전 예제: 다중 인터페이스 구현

class ISerializable
{
public:
    virtual std::string serialize() = 0;
    virtual void deserialize(const std::string& data) = 0;
    virtual ~ISerializable() = default;
};

class ILoggable
{
public:
    virtual void log() = 0;
    virtual ~ILoggable() = default;
};

class User : public ISerializable, public ILoggable
{
public:
    std::string serialize() override { /* JSON 변환 */ }
    void deserialize(const std::string& data) override { /* JSON 파싱 */ }
    void log() override { /* 로그 출력 */ }
    
private:
    std::string name;
    int age;
};

🔸 핵심 정리

상속 사용 가이드라인
1. public 상속만 사용 (99%의 경우)
2. Base 클래스 소멸자는 virtual public 또는 protected
3. 다형성이 필요하면 virtual 함수 사용
4. 인터페이스는 순수 가상 함수만으로 구성
5. override 키워드로 의도 명확히 표현

// ✅ 올바른 상속 구조
class IAnimal  // 인터페이스
{
public:
    virtual void speak() = 0;
    virtual ~IAnimal() = default;
};

class Animal : public IAnimal  // 추상 클래스
{
public:
    void speak() override { std::cout << "Animal" << std::endl; }
    virtual ~Animal() = default;
    
protected:
    int age;  // 공통 데이터
};

class Cat final : public Animal  // 구체 클래스 (final로 더 이상 상속 금지)
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }
};

---

<참고 자료>

코드없는 프로그래밍
C++ Inheritance
C++ Virtual Functions