C++ 상속과 다형성

C++에서 객체 지향 프로그래밍(Object-Oriented Programming, OOP)은 코드의 재사용성과 유지보수를 향상시키는 강력한 도구를 제공합니다. 그중에서도 상속(Inheritance)과 다형성(Polymorphism)은 객체 지향 프로그래밍의 핵심적인 개념입니다. 이번 포스팅에서는 상속과 다형성의 개념과 실제 코드 예제를 통해 이를 이해해보겠습니다.

---

1. 상속(Inheritance)

상속이란?

상속은 기존 클래스를 기반으로 새로운 클래스를 생성하는 방법입니다. 이를 통해 코드의 중복을 줄이고, 기존 코드의 기능을 확장하거나 수정할 수 있습니다. 부모 클래스(Base Class)로부터 자식 클래스(Derived Class)가 모든 속성과 메서드를 물려받습니다.

상속의 기본 문법

class Base {
public:
    void display() {
        std::cout << "Base class" << std::endl;
    }
};

class Derived : public Base {
};

int main() {
    Derived obj;
    obj.display(); // Base class 출력
    return 0;
}

Derived 클래스는 Base 클래스의 display() 메서드를 그대로 사용할 수 있습니다.

접근 지정자와 상속

C++에서는 상속 시 접근 지정자에 따라 멤버의 접근 권한이 달라집니다.

접근 지정자	설명
public	부모 클래스의 public 멤버는 자식 클래스에서도 public으로 유지됩니다.
protected	부모 클래스의 public 멤버는 자식 클래스에서 protected로 변경됩니다.
private	부모 클래스의 멤버는 자식 클래스에서 접근할 수 없습니다.

상속의 유형

1. 공개 상속(Public Inheritance): 부모 클래스의 public 및 protected 멤버를 그대로 상속합니다.
2. 비공개 상속(Private Inheritance): 부모 클래스의 모든 멤버가 자식 클래스에서 private로 변경됩니다.

class Base {
public:
    void show() { std::cout << "Base class" << std::endl; }
};

class Derived : private Base {
public:
    using Base::show; // 접근 수준 변경
};

int main() {
    Derived obj;
    obj.show();
    return 0;
}

---

2. 다형성(Polymorphism)

다형성이란?

다형성은 동일한 인터페이스를 통해 서로 다른 동작을 구현할 수 있는 능력입니다. C++에서 다형성은 주로 가상 함수(Virtual Function)와 다형적 호출(Polymorphic Call)을 통해 구현됩니다.

정적 다형성과 동적 다형성

1. 정적 다형성(Static Polymorphism): 컴파일 시간에 호출될 함수가 결정됩니다. 예: 함수 오버로딩, 연산자 오버로딩.
2. 동적 다형성(Dynamic Polymorphism): 실행 시간에 호출될 함수가 결정됩니다. 예: 가상 함수.

가상 함수(Virtual Function)

가상 함수는 부모 클래스에서 선언된 메서드를 자식 클래스에서 재정의(Override)하고, 실행 시점에 올바른 메서드가 호출되도록 합니다.

가상 함수 예제

#include <iostream>
using namespace std;

class Base {
public:
    virtual void display() {
        cout << "Base class" << endl;
    }
    virtual ~Base() {} // 가상 소멸자
};

class Derived : public Base {
public:
    void display() override {
        cout << "Derived class" << endl;
    }
};

int main() {
    Base* basePtr;
    Derived derivedObj;
    basePtr = &derivedObj;

    basePtr->display(); // Derived class 출력

    return 0;
}

위 코드에서 Base 클래스의 display() 메서드는 가상 함수로 선언되었습니다. 따라서 실행 시점에 basePtr이 가리키는 객체(Derived)의 메서드가 호출됩니다.

순수 가상 함수와 추상 클래스

1. 순수 가상 함수(Pure Virtual Function): 구현이 없는 가상 함수입니다.
2. 추상 클래스(Abstract Class): 하나 이상의 순수 가상 함수를 포함한 클래스입니다.

예제

class Shape {
public:
    virtual void draw() = 0; // 순수 가상 함수
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Rectangle" << std::endl;
    }
};

int main() {
    Shape* shape;
    Circle circle;
    Rectangle rectangle;

    shape = &circle;
    shape->draw(); // Drawing Circle

    shape = &rectangle;
    shape->draw(); // Drawing Rectangle

    return 0;
}

위 코드에서 Shape 클래스는 추상 클래스이며, 이를 상속받은 Circle과 Rectangle 클래스는 draw() 메서드를 재정의하였습니다.

---

3. 상속과 다형성의 실제 활용

예제: 간단한 직원 관리 프로그램

#include <iostream>
#include <vector>
#include <memory>
using namespace std;

class Employee {
public:
    virtual void showInfo() const = 0; // 순수 가상 함수
    virtual ~Employee() {}
};

class Developer : public Employee {
public:
    void showInfo() const override {
        cout << "Developer: Writing Code" << endl;
    }
};

class Manager : public Employee {
public:
    void showInfo() const override {
        cout << "Manager: Managing Team" << endl;
    }
};

int main() {
    vector<unique_ptr<Employee>> employees;

    employees.push_back(make_unique<Developer>());
    employees.push_back(make_unique<Manager>());

    for (const auto& emp : employees) {
        emp->showInfo();
    }

    return 0;
}

출력 결과

Developer: Writing Code
Manager: Managing Team

이 프로그램은 상속과 다형성을 활용하여 직원의 역할에 따라 서로 다른 동작을 구현합니다.

---

4. 정리

C++에서 상속과 다형성은 객체 지향 프로그래밍의 강력한 기능으로, 코드의 재사용성과 유연성을 크게 향상시킵니다. 이 두 개념을 잘 이해하고 활용하면, 유지보수와 확장성이 뛰어난 프로그램을 작성할 수 있습니다.