[C++] 16-2. 다형성(Polymorphism)과 추상 클래스(Abstract Class)

 

 

 

순수 가상 함수(Pure Virtual Function)과 추상 클래스(Abstract Class)

순수 가상 함수(Pure Virtual Function)는 함수의 정의를 가지지 않고 선언만 포함하는 가상 함수입니다. 순수 가상 함수는 = 0으로 표시되며, 파생 클래스에서 반드시 구현되어야 합니다. 순수 가상 함수를 가진 클래스는 추상 클래스로 간주되어 객체를 직접 생성할 수 없습니다. 추상 클래스는 주로 인터페이스를 정의하기 위해 사용됩니다.

순수 가상 함수와 일반 가상 함수의 차이점은 순수 가상 함수는 기본 클래스에서 정의를 가지지 않고, 파생 클래스에서 구현해야 한다는 점입니다. 이를 통해 다형성을 지원하면서도 파생 클래스에서 각각의 독립적인 동작을 구현할 수 있습니다.

가상 함수와 순수 가상 함수는 다형성을 구현하는 데 사용되며, 상속 계층 구조에서 다양한 객체 타입을 처리하기 위해 유용합니다. 이를 통해 런타임 시에 올바른 함수가 호출되며, 객체의 동작이 동적으로 결정될 수 있습니다.

 

추상 클래스(Abstract Class)는 하나 이상의 순수 가상 함수(순수 가상 멤버 함수)를 포함하는 클래스입니다. 순수 가상 함수는 함수의 정의를 가지지 않고, 선언만 포함하는 가상 함수입니다. 추상 클래스는 객체를 직접 생성할 수 없으며, 파생 클래스에서 이를 상속받아 구체적인 동작을 구현하는 역할을 합니다.

추상 클래스는 다음과 같은 특징을 가집니다:

1. 추상 클래스는 하나 이상의 순수 가상 함수를 포함합니다. 순수 가상 함수는 선언만 있고 정의가 없으며, "= 0"으로 표시됩니다. 이는 파생 클래스에서 반드시 구현되어야 함을 나타냅니다.
2. 추상 클래스는 직접 객체를 생성할 수 없습니다. 추상 클래스의 주된 목적은 인터페이스를 정의하고, 파생 클래스에서 해당 인터페이스를 구현하는 것입니다.
3. 추상 클래스는 순수 가상 함수를 가질 수 있는 반면, 일반 가상 함수나 일반 멤버 함수도 포함할 수 있습니다. 일반 멤버 함수는 추상 클래스 내에서 구현될 수 있습니다.

추상 클래스는 다형성과 추상화를 구현하는 데 사용됩니다. 추상 클래스를 상속받은 파생 클래스는 순수 가상 함수를 구현함으로써 공통된 인터페이스를 제공하면서도 각각의 독립적인 동작을 수행할 수 있습니다.

 

#include <iostream>

// 추상 클래스: 도형
class Shape {
public:
    virtual void draw() const = 0; // 순수 가상 함수
    virtual double area() const = 0; // 순수 가상 함수
    void printInfo() const {
        std::cout << "이 도형은 넓이 " << area() << "를 가지고 있습니다." << std::endl;
    }
};

// 파생 클래스: 직사각형
class Rectangle : public Shape {
private:
    double width;
    double height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    void draw() const override {
        std::cout << "직사각형을 그립니다." << std::endl;
    }
    double area() const override {
        return width * height;
    }
};

// 파생 클래스: 원
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    void draw() const override {
        std::cout << "원을 그립니다." << std::endl;
    }
    double area() const override {
        return 3.14 * radius * radius;
    }
};

int main() {
   // 추상 클래스의 포인터를 사용하여 객체 다형성 구현
    Shape* shape1 = new Rectangle(5, 3);
    shape1->draw();
    shape1->printInfo();
    delete shape1;

    Shape* shape2 = new Circle(2.5);
    shape2->draw();
    shape2->printInfo();
    delete shape2;

    return 0;
 }
 
 /* 실행결과
직사각형을 그립니다.
이 도형은 넓이 15를 가지고 있습니다.
원을 그립니다.
이 도형은 넓이 19.625를 가지고 있습니다.
 */

Shape라는 추상 클래스를 정의하고, draw()와 area()라는 순수 가상 함수를 선언합니다. 또한 printInfo()라는 일반 멤버 함수도 포함되어 있습니다.

Rectangle 클래스와 Circle 클래스는 Shape 클래스를 상속받아서 각각의 도형을 구현합니다. 이들 클래스에서는 draw()와 area() 함수를 오버라이딩하여 독자적인 동작을 구현합니다.

main() 함수에서는 Shape 포인터를 사용하여 추상 클래스의 포인터를 선언하고, Rectangle과 Circle 객체를 동적으로 생성하여 이를 가리키게 합니다. draw() 함수와 printInfo() 함수를 호출하여 도형의 정보를 출력한 후, 메모리를 해제합니다.

이 예제에서 추상 클래스는 인터페이스를 제공하고, 파생 클래스에서 이를 구체적으로 구현함으로써 각각의 도형을 처리합니다. 추상 클래스는 객체를 직접 생성할 수 없지만, 다형성을 통해 동일한 인터페이스를 가진 객체들을 다룰 수 있습니다.

 

 

 

다형성(Polymorphism)

C++에서 다형성(Polymorphism)은 객체 지향 프로그래밍의 중요한 개념 중 하나로, 동일한 인터페이스를 사용하여 다양한 객체 타입을 처리할 수 있는 능력을 의미합니다. 다형성은 코드의 재사용성, 유연성, 확장성을 향상시키는 도구로 활용됩니다.

C++에서 다형성은 다음과 같은 방법으로 구현됩니다:

가상 함수(Virtual Function): 기본 클래스에서 가상 함수를 선언하고, 파생 클래스에서 이를 재정의(오버라이딩)하는 방식으로 다형성을 구현합니다. 실행 시간에 객체의 실제 타입을 파악하여 적절한 함수를 호출하는 동적 바인딩이 가능해집니다.

추상 클래스(Abstract Class): 추상 클래스는 순수 가상 함수(순수 가상 멤버 함수)를 가지는 클래스로, 객체를 직접 생성할 수 없습니다. 추상 클래스를 상속받은 파생 클래스에서 순수 가상 함수를 구현함으로써 각각의 독립적인 동작을 수행할 수 있습니다.

가상 소멸자(Virtual Destructor): 다형성을 사용할 때는 기본 클래스의 소멸자를 가상으로 선언해야 합니다. 이는 파생 클래스의 객체를 기본 클래스의 포인터로 삭제할 때, 파생 클래스의 소멸자가 호출되도록 보장합니다.

다형성을 사용하면 다음과 같은 이점을 얻을 수 있습니다:

코드의 재사용성: 동일한 인터페이스를 사용하여 다양한 객체를 처리할 수 있으므로, 유사한 동작을 가진 객체들에 대해 코드를 재사용할 수 있습니다.

유연성과 확장성: 새로운 객체 타입을 추가하거나 기존 객체 타입을 변경하여도, 코드의 변경을 최소화하면서 다형성을 활용할 수 있습니다. 이는 프로그램의 유연성과 확장성을 향상시킵니다.

가독성과 유지 보수성: 다형성은 객체 간의 관계를 명확하게 표현할 수 있으며, 코드의 가독성과 유지 보수성을 향상시킵니다. 객체의 실제 타입이 실행 시간에 결정되므로, 코드를 이해하고 수정하기 쉬워집니다.

C++에서 다형성은 객체 지향 프로그래밍의 핵심 개념 중 하나로, 상속, 가상 함수, 추상 클래스 등을 활용하여 구현됩니다. 이를 통해 유연하고 확장 가능한 코드를 작성할 수 있으며, 객체의 동작을 동적으로 결정할 수 있습니다.

 

#include <iostream>

// 추상 클래스: 도형
class Shape {
public:
    virtual void draw() const = 0; // 순수 가상 함수
    virtual double area() const = 0; // 순수 가상 함수
};

// 파생 클래스: 직사각형
class Rectangle : public Shape {
private:
    double width;
    double height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    void draw() const override {
        std::cout << "직사각형을 그립니다." << std::endl;
    }
    double area() const override {
        return width * height;
    }
};

// 파생 클래스: 원
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    void draw() const override {
        std::cout << "원을 그립니다." << std::endl;
    }
    double area() const override {
        return 3.14 * radius * radius;
    }
};

int main() {
    // 추상 클래스의 포인터를 사용하여 다양한 도형 처리
    Shape* shapes[2];
    shapes[0] = new Rectangle(8, 5);
    shapes[1] = new Circle(3.7);

    for (int i = 0; i < 2; i++) {
        shapes[i]->draw();
        std::cout << "넓이: " << shapes[i]->area() << std::endl;
        delete shapes[i];
    }

    return 0;
}

/* 실행결과
직사각형을 그립니다.
넓이: 40
원을 그립니다.
넓이: 42.9866      
*/

이 예제는 다형성을 활용하여 추상 클래스를 통해 도형의 다양한 타입을 처리할 수 있도록 구현한 것입니다. Shape 포인터를 사용하면 실행 시간에 각 도형의 실제 타입에 맞게 함수가 호출되며, 결과적으로 도형의 동작이 동적으로 결정됩니다.

추상 클래스의 예제와 유사합니다. 다만 다형성이라는 것이 형태가 다양하다는 것에서 기반한 것이므로 Shape 클래스 형태의 배열로 선언 후 할당 된 구현 클래스는 다양하게 변할 수 있습니다. 이것이 다형성의 핵심입니다. 다형성을 기반으로 한 디자인 패턴 중에는 팩토리 패턴, 추상 팩토리 패턴이 대표적입니다.

 

다음은 상속 관계에서의 생성, 소멸에 대해 알아보겠습니다.