다형성, 추상 클래스

Polymorphism

다형성(Polymorphism)은 객체 지향 프로그래밍의 핵심 개념 중 하나로, 동일한 인터페이스를 통해 다양한 객체를 처리할 수 있다.

오버라이딩(Overriding) vs 오버로딩(Overloading)

• 오버로딩(Overloading): 동일한 함수 이름을 사용하되, 매개변수의 타입, 개수, 순서 등을 달리하여 여러 버전의 함수를 제공하는 방식입니다. 컴파일 타임 다형성을 구현합니다.

• 오버라이딩(Overriding): 부모 클래스의 메서드를 자식 클래스에서 재정의하는 방식으로, 런타임 다형성을 구현합니다. 오버라이딩을 할 때 부모 클래스에서 해당 함수가 가상 함수여야만 다형성이 적용됩니다.

특징	오버로딩(Overloading)	오버라이딩(Overriding)
정의	함수 이름은 같고, 매개변수로 구분	부모 클래스의 메서드를 자식 클래스에서 재정의
매개변수	매개변수의 개수/타입/순서가 달라야 함	부모 메서드와 동일한 시그니처(반환 타입 포함)
반환 타입	다를 수 있음	동일해야 함
컴파일/실행	컴파일 시 결정	실행 시 결정
가상 함수 여부	필요 없음	부모 클래스 메서드는 가상 함수여야 함
예시	함수 이름이 같고 매개변수로 구분	부모 클래스 함수 재정의

오버라이딩(Overriding)

상속 받은 가상 함수를 재정의 한다.

가상함수(Virtual function)

C++에서 가상 함수는 부모 클래스에서 선언되고 자식 클래스에서 재정의할 수 있는 함수.

class Animal
{
public:
	virtual void walk()
	{
		cout << "걷는다.\n";
	}

	virtual void speak() {
		cout << "운다.\n";
	}; 
};

class Dog :public Animal
{
public:
	void speak() override
	{
		cout << "멍멍.\n";
	}
};

순수가상함수(Pure virtual function)

순수 가상 함수는 구현이 없는 가상 함수이다. 순수 가상 함수가 하나라도 포함된 클래스는 추상 클래스(Abstract Class)가 된다. 추상 클래스는 객체를 생성할 수 없으며, 상속을 통해서만 사용 가능하다.

class Animal
{
public:
	virtual void walk()
	{
		cout << "걷는다.\n";
	}

	virtual void speak() {
		cout << "운다.\n";
	}; 
};

class Dog :public Animal
{
public:
	void speak() override
	{
		cout << "멍멍.\n";
	}
};

포인터(Pointer) : 객체를 가리키는 객체 포인터

포인터를 사용하면 부모 객체로 포인터를 생성하여 자식 클래스를 모두 포인터로 참조할 수 있다. 단, 부모 클래스에서 정의한 멤버만 접근 가능하다.

class Animal
{
public:
	virtual void walk()
	{
		cout << "걷는다.\n";
	}

	virtual void speak() = 0; 
};

class Dog :public Animal
{
public:
	void speak() override
	{
		cout << "멍멍.\n";
	}
};

class Cat :public Animal
{
public:
	void speak() override  // overriding: 함수의 재정의
	{
		cout << "야옹.\n";
	}
};

int main()
{
	Animal* ptr = nullptr;  
	
	ptr = new Dog;
	// ptr = new Cat;
	ptr->speak();
	ptr->walk();
	delete ptr; 
		
	return 0;
}

실습 예제

Car 클래스와 이를 상속받은 SportCar 클래스를 사용하여, 다양한 차량 객체의 정보를 출력하고 생성된 차량의 수를 세는 코드를 작성한다.

+---------------------+        +------------------------+
|        Car          |        |       SportCar         |
+---------------------+        +------------------------+
| - brand: string     |<-------| - max_speed: int       |
| - model: string     |        +------------------------+
| - door: int         |        | + SportCar(brand, model, door, max_speed) |
| - static int count  |        | + print()              |
+---------------------+        +------------------------+
| + Car(brand, model, door)    |
| + print()            |
| + static getCarCount()       |
| + ~Car()             |
+---------------------+ 

ch07ex04_Car_다형성.cpp

#include <iostream>
#include <string>
using namespace std;

class Car
{
protected:
	string brand;
	string model;
	int door;
	static int count;
public:
	Car(string brand, string model, int door)
		: brand(brand), model(model), door(door) {
		count++;
	}
	virtual void print() {
		cout << model << "(" << brand << ")의 문은" << door << "개이다." << endl;
	}
	static int getCarCount() {
		return count;
	}
	~Car() {}
};
int Car::count = 0;

class SportCar : public Car
{
private:
	int max_speed;
public:
	SportCar(string brand, string model, int door, int max_speed = 300)
		: Car(brand, model, door), max_speed(max_speed) {
	}

	void print() override {
		cout << model << "(" << brand << ")의 최고 속력은 " << max_speed << "km/s이다." << endl;
		cout << "문은 " << door << "개이다." << endl;
	}

	~SportCar() {};
};

int main()
{
	Car c1("Tesla", "model3", 4);
	SportCar s1("Tesla", "modelS", 4);
	SportCar s2("Porscher", "Tycaan", 2, 400);

	c1.print();
	s1.print();
	s2.print();

	cout << "생성된 차량 수: " << Car::getCarCount() << "대" << endl;

	return 0;
}

ch07ex05_Animal_다형성.cpp

Animal 클래스와 그를 상속받은 Dog 및 Cat 클래스에서 각 동물의 이름과 소리를 출력합니다. 코드에서 다형성의 핵심은 makeSound() 함수에 있으며, 각 클래스에서 이 함수가 다르게 동작하는 것을 확인할 수 있습니다.

1. Animal 클래스:

   • Animal 클래스는 동물의 공통 속성인 name을 저장하고 있으며, makeSound()라는 가상 함수를 제공합니다. 기본적으로 "울음소리"를 출력합니다.

   • printName() 함수는 동물의 이름을 출력합니다.

   • 소멸자는 가상 함수로 선언되어, 동적 할당된 객체가 안전하게 삭제될 수 있도록 합니다.

2. Dog 클래스:

   • Dog 클래스는 Animal 클래스를 상속받아 makeSound() 함수를 재정의하여 "멍멍!"을 출력합니다.

3. Cat 클래스:

   • Cat 클래스도 Animal 클래스를 상속받고, makeSound() 함수를 재정의하여 "야옹!"을 출력합니다.

4. main 함수:

   • Animal 포인터를 사용하여 Animal, Dog, Cat 객체를 동적으로 생성하고, 각 객체의 printName() 및 makeSound() 함수를 호출하여 동물의 이름과 소리를 출력합니다.

   • new로 생성된 객체는 delete를 통해 메모리를 해제합니다.

#include <iostream>
#include <string>
using namespace std;

class Animal
{
protected:
	string name;

public:
	Animal(string name) : name(name) {}
	virtual void makeSound() const {
		cout << "울음소리" << endl;
	}
	void printName() const {
		cout << "동물의 이름: " << name << endl;
	}
	~Animal() {};
};

class Dog : public Animal
{
public:
	Dog(string name) : Animal(name) {}
	virtual void makeSound() const override {
		cout << "멍멍!" << endl;
	}
};

class Cat : public Animal
{
public:
	Cat(string name) : Animal(name) {}
	virtual void makeSound() const override {
		cout << "야옹!" << endl;
	}
};

int main()
{
	Animal* myAnimal = new Animal("동물");
	Animal* myDog = new Dog("몽실");
	Animal* myCat = new Cat("콩이");

	myAnimal->printName();
	myAnimal->makeSound();

	cout << "-----------" << endl;

	myDog->printName();
	myDog->makeSound();

	cout << "-----------" << endl;
	myCat->printName();
	myCat->makeSound();

	delete myAnimal;
	delete myDog;
	delete myCat;

	return 0;
}

부모 클래스 포인터 배열로 구현한 코드

Animal* pet[3];
pet[0] = new Animal("동물");
pet[1] = new Dog("몽실");
pet[2] = new Cat("콩이");

for (int i = 0; i < 3; i++) {
	pet[i]->printName();
	pet[i]->makeSound();
}

for (int i = 0; i < 3; i++) {
	delete pet[i];
}