[C++] 상속(Inheritance)

📌상속

코드의 중복을 줄이고 재사용성을 높이기 위해 클래스 간의 상속 관계를 정의할 수 있다.

예를 들어 `name`과 `address`를 갖는 `RagularEmployee`와 `TemporaryEmployee`가 있을 때, 둘을 ` Employee`로 일반화하여 정의하고 상속받아 사용할 수 있다.

 

 

#include <iostream>

using namespace std;

class Employee {

public : 
	Employee() {

	}

	Employee(const char* name, const char* address) {
		this->name = new char[strlen(name) + 1];
		this->address = new char[strlen(address) + 1];

		strcpy_s(this->name, strlen(name) + 1, name);
		strcpy_s(this->address, strlen(address) + 1, address);
	}

	~Employee() {
		delete[] name;
		delete[] address;
	}

	char* getName() {
		return this->name;
	}

	char* getAddress() {
		return this->address;
	}

	void print() {
		cout << "이름: " << this->getName() << ", 주소: " << this-> getAddress() << endl;
	}

protected:
	char* name;
	char* address;
};

 

class RegularEmployee : public Employee {

private :
	int 연봉;

};

class TemporaryEmployee : public Employee {

private :
	int 주급;
};

 

 

 

둘은 클래스 내부에 또 다시 속성을 정의하지 않더라도 상속을 받았기 때문에 이름과 주소를 가진다. 멤버 함수도 함께 상속받으므로 `getter()` 와 `print()` 도 사용할 수 있다.

이때 `private` 으로 선언된 멤버 변수는 상속이 되더라도 접근 제한을 받기 때문에, 만약 자식에게 접근 권한을 주고 싶다면 `protected` 로 설정해야한다.

 

객체 생성 시에는 무조건 부모의 생성자를 먼저 호출한다.(부모가 존재하는지 확인한 후 부모를 먼저 만들기 때문이다.) 부모의 어떤 생성자를 호출할지 명시하지 않으면 무조건 기본 생성자를 호출한다.

원하는 부모의 생성자를 사용하기 위해서는 부모의 생성자 중 어떤 생성자를 호출할지 생성자의 시그니처에 명시해야한다.

 

 

객체가 스택에 생성되기 때문에, 하위 클래스가 먼저 소멸되고 상위 클래스가 소멸된다. 이때 자식 클래스의 소멸자를 먼저 호출하고, 부모 클래스의 소멸자를 호출한다.

 

class RegularEmployee : public Employee {

public : 

	RegularEmployee() {
		cout << "reg 디폴트 생성자 " << endl;
	}

	RegularEmployee(const char* name, const char* address, double salary) 
	: Employee(name, address) {
		cout << "reg 인자 세개 생성자 " << endl;
		
		this->salary = salary;
	}

	~RegularEmployee() {
		cout << "rag 소멸자 호출" << endl;
	}

	double PayCheck() {
		return this->salary;
	}

private :
	double salary;

};

 

void main() {

	Employee e("회사원", "회사원 주소");
	e.print();

	RegularEmployee re("정규직원", "정규직원 주소", 5500);
	cout << re.PayChack() << endl;

	TemporaryEmployee te("계약직", "계약직 주소", 10, 20);
	cout << te.PayCheck() << endl;
}

 

emp 인자 두개 생성자
이름: 회사원, 주소: 회사원 주소
emp 인자 두개 생성자
reg 인자 세개 생성자
5500
emp 인자 두개 생성자
temp 인자 세개 생성자
2400
temp 소멸자 호출
emp 소멸자 호출
rag 소멸자 호출
emp 소멸자 호출
emp 소멸자 호출

 

 

📌다형성(Polymorphism)

사전: 같은 종의 생물이면서도 어떤 형태나 성질이 다양하게 나타나는 현상. 'poly(많은)' 과 'morphism(형태)'의 합성어.

하나의 객체를 다른 자료형의 변수로 참조하여 다양한 결과를 얻어낼 수 있는 성질. 클래스가 상속 관계에 있을 때 나타나는 다채로운 성질을 말한다.

 

동적 결합/동적 바인딩(Dynamic Binding)

실행 도중에 결합(바인딩)이 이루어지는 것을 동적 결합이라고 한다. 동적 바인딩으로 인해 포인터가 어떤 타입이든 상관 없이 그 실제 객체를 기준으로 함수를 호출한다. 이 동적 바인딩 덕분에 다형성이 적용되는 것!

 

 

📌오버라이딩(Overriding)

사전적 의미: '~에 덮어쓰다.', '~에 우선한다.' 

부모 클래스로부터 상속 받은 멤버 함수를 자식 클래스에서 재정의하여 새로운, 또는 수정 및 확장된 기능을 만드는 것. 함수의 시그니처가 동일해야한다. (이름 동일, 매개변수의 타입 및 개수 동일, 반환 타입 동일)

 

부모 클래스의 객체 포인터는 자식 클래스 객체에 접근이 가능하다. 즉, 부모 타입으로 선언된 포인터로 자식 타입의 객체를 다룰 수 있다. 

 

 

📌가상 함수(Virtual Function)

다형성을 지원하기 위해 자식 클래스의 객체가 재정의한 함수로 동작할 수 있도록 하는 것. C++에서는 함수를 가상함수로 등록하지 않으면 자식 객체에서 함수를 오버라이딩 했더라도, 부모 타입의 변수로 자식 객체를 참조했을 때 부모 타입에 정의된 함수로 동작한다.

 

가상 함수가 포함된 클래스는 추상 클래스로 객체를 생성할 수 없다. 

자바에서는 모든 함수가 가상함수로 선언되어 있기 때문에, 부모 타입의 변수로 자식 타입의 객체를 참조하더라도 자식 객체에서 재정의된 함수로 동작한다.

 

가상함수 미사용

#include <iostream>

class Base {
public:
    void display() {  // 비가상 함수
        std::cout << "Base display" << std::endl;
    }
};

class Derived : public Base {
public:
    void display() {  // 함수 재정의 (오버라이딩이 아님)
        std::cout << "Derived display" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();  // 부모 타입 포인터로 자식 객체 참조
    basePtr->display();  // Base의 display 호출
    delete basePtr;
    return 0;
}

 

 

 

 

가상함수 사용

#include <iostream>

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

class Derived : public Base {
public:
    void display() override {  // 가상 함수 재정의
        std::cout << "Derived display" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();  // 부모 타입 포인터로 자식 객체 참조
    basePtr->display();  // Derived의 display 호출
    delete basePtr;
    return 0;
}

 

 

 

 

 

C#에서의 가상함수

가상함수 미사용

using System;

class Base
{
    public void Display()  // 비가상 메서드
    {
        Console.WriteLine("Base display");
    }
}

class Derived : Base
{
    public new void Display()  // 메서드 숨기기
    {
        Console.WriteLine("Derived display");
    }
}

class Program
{
    static void Main()
    {
        Base baseRef = new Derived();  // 부모 타입 참조로 자식 객체 참조
        baseRef.Display();  // Base의 Display 호출
    }
}

 

 

 

 

가상함수 사용

using System;

class Base
{
    public virtual void Display()  // 가상 메서드로 변경
    {
        Console.WriteLine("Base display");
    }
}

class Derived : Base
{
    public override void Display()  // 재정의된 가상 메서드
    {
        Console.WriteLine("Derived display");
    }
}

class Program
{
    static void Main()
    {
        Base baseRef = new Derived();  // 부모 타입 참조로 자식 객체 참조
        baseRef.Display();  // Derived의 Display 호출
    }
}

 

 

📌 상속 예시

#include <iostream>

using namespace std;

class Employee {

public : 
	Employee() {
		cout << "emp 디폴트 생성자 " << endl;
	}

	Employee(const char* name, const char* address) {
		cout << "emp 인자 두개 생성자 " << endl;
		this->name = new char[strlen(name) + 1];
		this->address = new char[strlen(address) + 1];

		strcpy_s(this->name, strlen(name) + 1, name);
		strcpy_s(this->address, strlen(address) + 1, address);
	}

	~Employee() {
		cout << "emp 소멸자 호출" << endl;
		delete[] name;
		delete[] address;
	}


	char* getName() {
		return this->name;
	}

	char* getAddress() {
		return this->address;
	}

	void Print() {
		cout << "이름: " << this->getName() << ", 주소: " << this-> getAddress() << endl;
	}

	virtual double PayCheck() const = 0;

protected :
	char* name;
	char* address;
};

class RegularEmployee : public Employee {


public : 

	RegularEmployee() {
		cout << "reg 디폴트 생성자 " << endl;
	}

	RegularEmployee(const char* name, const char* address, double salary)
		: Employee(name, address) {
		cout << "reg 인자 세개 생성자 " << endl;
		
		this->salary = salary;
	}

	~RegularEmployee() {
		cout << "rag 소멸자 호출" << endl;
	}

	double PayCheck() const override {
		return salary * 12;
	}

private :
	double salary;

};

class TemporaryEmployee : public Employee {


public : 

	TemporaryEmployee() {
		cout << "temp 디폴트 생성자 " << endl;
	}

	TemporaryEmployee(const char* name, const char* address, double dailyPayCheck, int days)
		: Employee(name, address) {
		cout << "temp 인자 세개 생성자 " << endl;

		this->dailyPayCheck = dailyPayCheck;
		this->days = days;
	}


	~TemporaryEmployee() {
		cout << "temp 소멸자 호출" << endl;
	}

	double PayCheck() const override {
		return this->dailyPayCheck * days * 12;
	}

private :
	double dailyPayCheck;
	int days;
};

class SalesMan : public RegularEmployee {

public : 

	SalesMan() {
		cout << "sales 디폴트 생성자 " << endl;
	}

	SalesMan(const char* name, const char* address, double salary, double allowance) 
		: RegularEmployee(name, address, salary) {
		cout << "sales 인자 네개 생성자 " << endl;
		this->allowance = allowance;
	}

	~SalesMan() {
		cout << "sales 소멸자 호출" << endl;
	}

	double PayCheck() const override {
		return RegularEmployee::PayCheck() + (allowance * 12);
	}

private:
	double allowance;
};

// Employee 관리 클래스
class Department {
public :
	Department() {
		this->count = 0;
	}

	~Department() {
	}

	// 객체를 전달 인자로 받아 객체 배열에 넣어 관리
	void Insert(Employee& emp) {
		this->emp[count] = &emp;
		count++;
	}

	// 현재 관리 중인 객체의 급여 출력
	void Print() const {
		for (int i = 0; i < count; i++) {
			cout <<"[" << this->emp[i]->getName() << "] ";
			cout << this->emp[i]->PayCheck() << endl;
		}
	}

private:
	Employee* emp[10];
	int count;
};


void main() {

	//Employee e("회사원", "회사원 주소");
	//e.print();

	RegularEmployee re("정규직원", "정규직원 주소", 550);
	//cout << re.PayCheck() << endl;

	TemporaryEmployee te("계약직", "계약직 주소", 10, 20);
	//cout << te.PayCheck() << endl;

	SalesMan sm("jung", "분당", 300, 50);
	//cout << sm.PayCheck() << endl;

	/*Employee* salesMan = (Employee*) new SalesMan("정영업", "분당", 500, 50);
	cout << salesMan->PayCheck() << endl;*/

	Department dpt;
	dpt.Insert(re);
	dpt.Insert(te);
	dpt.Insert(sm);

	dpt.Print();

}

 

 

 

📎참고

[C++] 동적 바인딩, 정적 바인딩