C++에서의 다형성(Polymorphism)

다형성(Polymorphism)

다형성은 객체 지향 프로그래밍(Object-Oriented Programming, OOP)의 핵심 원리 중 하나로, 하나의 인터페이스가 여러 형태의 동작을 수행할 수 있게 하는 기능이다. 이를 통해 코드의 재사용성과 확장성이 향상된다.

다형성에는 크게 두 가지 종류가 있다.

1. 정적 다형성(Static Polymorphism)

정적 다형성은 컴파일 타임에 다형성이 결정되는 방식이다. C++에서는 함수 오버로딩(Function Overloading)과 템플릿(Template)을 통해 정적 다형성을 구현할 수 있다.

• 함수 오버로딩(Function Overloading): 같은 이름의 함수를 여러 개 정의하되, 매개변수의 타입이나 개수가 다른 경우를 말한다. 컴파일러는 함수를 호출할 때 매개변수의 타입과 개수를 통해 적절한 함수를 선택한다.

#include <iostream>

void print(int num) {
    std::cout << "정수: " << num << std::endl;
}

void print(double num) {
    std::cout << "실수: " << num << std::endl;
}

int main() {
    print(42);      // 정수: 42
    print(3.14);    // 실수: 3.14
    return 0;
}

• 템플릿(Template): 함수나 클래스를 일반화하여 여러 타입에 대응할 수 있는 코드를 작성할 수 있다. 이를 통해 다양한 타입에 대해 동일한 코드를 재사용할 수 있다.

#include <iostream>

template <typename T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int a = 10;
    int b = 20;
    double c = 3.14;
    double d = 1.41;

    std::cout << add(a, b) << std::endl;    // 30
    std::cout << add(c, d) << std::endl;    // 4.55
    return 0;
}

2. 동적 다형성(Dynamic Polymorphism)

동적 다형성은 런타임에 다형성이 결정되는 방식이다. C++에서는 상속(Inheritance)과 가상 함수(Virtual Function)를 통해 동적 다형성을 구현할 수 있다.

• 상속(Inheritance): 기존의 클래스를 확장하여 새로운 클래스를 정의하는 것이다. 기반 클래스의 속성과 메서드를 파생 클래스가 상속받아 사용할 수 있다.
• 가상 함수(Virtual Function): 기반 클래스에서 선언된 가상 함수는 파생 클래스에서 재정의(Override)될 수 있다. 이를 통해 기반 클래스의 포인터나 참조를 통해 파생 클래스의 메서드를 호출할 수 있게 된다.

#include <iostream>

class Animal {
public:
    virtual void speak() {
        std::cout << "동물의 소리" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "멍멍!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void speak() override {
        std::cout << "야옹!" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog();
    Animal* animal2 = new Cat();

    animal1->speak();    // 멍멍!
    animal2->speak();    // 야옹!

    delete animal1;
    delete animal2;
    return 0;
}