[C++] 상속과 다형성 | 가상함수(virtual function) | 참조자

🌟객체의 주소값을 저장하는 객체 포인터 변수

C++에서 AAA형 포인터 변수는 AAA 객체 또는 AAA를 직접 혹은 간접적으로 상속하는 모든 객체를 가리킬 수 있다.

👉 객체의 주소값을 저장할 수 있다.

 

EX) Person ⊃ Student ⊃ PartTimeStudent

Person * ptr = new Student();
Person * ptr = new PartTimeStudent();
Student * ptr = new PartTimeStudent();

 

IS-A 관계로 봐보자!

"학생은 사람의 일종이다"

"근로학생은 학생의 일종이다"

"근로학생은 사람의 일종이다"

 

👉 하위 클래스 객체를 상위 클래스 객체로 바라볼 수 있는 증거

"학생은 사람이다"

"근로학생은 학생이다"

"근로학생은 사람이다"

 

EX2) 모든 클래스의 객체를 Employee 클래스의 객체로 간주(처리)할 수 있다.

 

C++ 컴파일러는 포인터 연산의 가능성 여부를 판단할 때,

포인터의 자료형을 기준으로 판단하지, 실제 가리키는 객체의 자료형을 기준으로 판단하지 않는다.

따라서 포인터 형에 해당하는 클래스의 멤버에만 접근 가능하다.

이해하기 어렵다면, 사람과 학생을 대입해서 생각해보면 쉽게 풀린다! ( •̀ ω •́ )✧

class A{
public:
	void AFunc();
}

class B : public A{
public:
	void BFunc();
}


// case1
int main(void){
	A * a = new B();   // 컴파일 ok
    a -> BFunc();      // 컴파일 error. a가 가리키는 것음 A의 주소이기 때문에 BFunc에 접근X
}

// case2
int main(void){
	A * a = new B();   // 컴파일 ok
    B * b = a;         // 컴파일 error. a와 b는 가리키는 것이 다르다.
}

// case3
int main(void){
	B * b = new B();   // 컴파일 ok
    A * a -> b;        // 컴파일 ok. B가 A를 상속하였기 때문에, B 객체는 A의 객체이기도 하다.
}

 

한번 더 정리!

class First{
public:
	void FirstFunc();
}

class Second : public First{
public:
	void SecondFunc();
}

class Third : public Second{
public:
	void ThirdFunc();
}

int main(void){
	Third * tptr = new Third();
    Second * sptr = tptr;
    First * fptr = sptr;
    
    tptr -> FirstFunc(); (O)
    tptr -> SecondFunc(); (O)
    tptr -> ThirDFunc(); (O)
    
    sptr -> FirstFunc(); (O)
    sptr -> SecondFunc(); (O)
    sptr -> ThirDFunc(); (X)
    
    fptr -> FirstFunc(); (O)
    fptr -> SecondFunc(); (X)
    fptr -> ThirDFunc(); (X)
}

함수를 호출할 때 사용이 된 포인터의 형에 따라서 호출되는 함수가 결정된다.

포인터 형에 정의된 함수가 호출된다.

 

🟩 가상함수(virtual)

함수를 오버라이딩했다는 것은, 해당 객체에서 호출되어야 하는 함수를 바꾼다는 의미인데, 포인터 변수의 자료형에 따라 호출되는 함수의 종류가 달라지는 것은 문제가 있어 보인다.

가상함수 선언은 virtual 키워드 선언을 통해 이루어진다.

#include <iostream>
using namespace std;

class First {
public:
 	virtual void MyFunc() { cout << "FirstFunc" << endl; } 
    // 가상함수가 선언되고 나면, 이 함수를 오버라이딩 하는 함수도 가상함수가 된다.
};

class Second : public First {
public:
 	virtual void MyFunc() { cout << "SecondFunc" << endl; } 
    // virtual를 추가하지 않아도 괜찮음. 
};

class Third : public Second {
public:
 	virtual void MyFunc() { cout << "ThirdFunc" << endl; } 
    // virtual를 추가하지 않아도 괜찮음.
};

int main() {	
	Third* tptr = new Third();
	Second* sptr = tptr;
	First* fptr = sptr;

	fptr->MyFunc();
	sptr->MyFunc();
	tptr->MyFunc();

	// 함수가 가상함수로 선언되면, 해당 함수 호출 시, 포인터의 자료형을 기반으로 호출대상을 결정 X
	// 포인터 변수가 실제로 가리키는 객체를 참조하여, 호출의 대상을 결정 O

	delete tptr;
	return 0;
}

 

배열을 구성하는 포인터 변수가 A 클래스이면, A 클래스의 멤버가 아닌 함수들은 에러가 발생할 수 있다.

가상함수를 사용하면 포인터 변수가 아닌 실제 객체의 형을 대상으로 연산을 처리하기 때문에 해결 가능하다.

 

🌟 상속을 하는 이유

상속을 통해 연관된 일련의 클래스에 대해, 공통적인 규약을 정의할 수 있기 때문이다.

실제로, EmployeeHandler 클래스는, 저장되는 모든 객체를 Employee 객체로 바라보고 있다.

따라서, 새로운 클래스가 추가되어도, EmployeeHandler 클래스는 변경될 필요가 없다.

물론, 객체의 자료형에 따라 호출되는 함수의 차이는 있어야 한다. 그런 경우엔 가상함수로 해결 가능하다.

 

🟩 순수 가상함수와 추상(abstract) 클래스

class Employee { // 고용인 클래스
private:
 	char name[100]; // 이름 변수
public:
    Employee(const char* name) { // 고용인 생성자
        strcpy_s(this->name, name);
    }

     void ShowYourName() const { // 정보(name) 출력 함수
        cout << "name: " << name << endl;
     }

     virtual int GetPay() const { // 급여 반환 가상함수 
        return 0;
     }

     virtual void ShowSalaryInfo() const{ } // 정보(name, salary) 출력 가상함수 
};

이 클래스는 기초 클래스로서만 의미를 가질 뿐, 객체의 생성을 목적으로 정의된 클래스가 아니다.

이와 같이 클래스 중에는 객체 생성을 목적으로 정의되지 않은 클래스도 존재한다.

ex ) Employee * emp = new Employee("Lee Dong Sook");

 // 이와 같은 문장은 프로그래머의 실수이다.

 // 이러한 실수는 문제가 없는 문장이기 때문에, 컴파일러에 의해 발견되지 않는다.

 

👉 따라서, 이러한 문제를 해결하기 위해, '순수 가상함수'를 선언하여, 객체의 생성을 문법적으로 막는 것이 좋다.

 

🌟 순수 가상함수

함수의 몸체가 정의되지 않은 함수

= 0을 통해, 명시적으로 몸체를 정의하지 않았음을 컴파일러에게 알린다.

class Employee { // 고용인 클래스
private:
 	char name[100]; // 이름 변수
public:
 	Employee(const char* name) { // 고용인 생성자
   		strcpy_s(this->name, name);
 	}

 	void ShowYourName() const { // 정보(name) 출력 함수
   		cout << "name: " << name << endl;
 	}

	virtual int GetPay() const = 0; // 순수 가상함수
	virtual void ShowSalaryInfo() const = 0; // 순수 가상함수
 }

이와 같이 멤버 함수를 순수 가상함수로 선언한 클래스를 가리켜 추상 클래스(abstract class)라 한다.

 

🟩 다형성

모습은 같지만, 형태가 다르다. 👉 문장은 같은데, 결과는 다르다.

EX) 포인터 변수 ptr이 참조하는 객체의 자료형이 다르기 때문에 실행결과는 다르다.

class First{
public:
 	virtual void SimpleFunc() { cout<<"First"<<endl; }
};

class Second : public First{
public:
 	virtual void SimpleFunc() { cout<<"Second"<<endl;}
};

int main(){
	First * ptr = new First();
	1) ptr->SimpleFunc(); // 동일한 문장 존재
	delete ptr;

	ptr = new Second();
	2) ptr ->SimpleFunc(); // 동일한 문장 존재
	delete ptr;
	return 0;
}

 

🟩 가상 소멸자

가상함수 외에도, virtual 키워드를 붙어야할 대상

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

class First{ // First 클래스
private:
 	char * strOne;
public:
 	First(const char *str){ // First 생성자
   		strOne = new char[strlen(str)+1]; // 생성자 내부의 동적할당
 	}
 
 	~First(){ // First 소멸자
   		cout<<"~First()"<<endl;
   		delete [] strOne; // 생성자 동적할당 소멸
 	}
};

class Second : public First{ // Second 클래스
private:
 	char * strTwo;
public:
 	Second(const char * str1, const char * str2):First(str1){ // Second 생성자
   		strTwo = new char[strlen(str2)+1];
 	}
    
 	~Second(){ // Second 소멸자
   		cout<<"~Second()"<<endl;
   		delete [] strTwo;
 	}
};

int main(){
	First * ptr = new Second("simple","complex"); // 객체 생성
	delete ptr; // ptr 소멸 (First 소멸자, Second 소멸자 동시 호출 필요)
	return 0;
}

 

객체의 소멸을 First형 포인터로 명령했기 때문에, 메모리 누수 현상이 발생하였다.

객체의 소멸과정에서는 delete 연산자에 사용된 포인터 변수의 자료형에 상관없이, 모든 소멸자가 호출되어야 한다.

👉 소멸자에 virtual 선언을 추가한다.

virtual ~First(){
	cout<<"~First()"<<endl;
	delete [] strOne;
}

소멸자도 상위 클래스의 소멸자만 virtual로 선언하면, 상속하는 유도 클래스의 소멸자들도 모두 '가상 소멸자'로 선언된다.

class First{
...
public:
 	virtual ~First() { ... }
};

class Second : public First{
...
public:
 	virtual ~Second() { ... }
};

class Third : public Second{
...
public:
 	virtual ~Third(){ ... }
};

int main(){
	First * ptr = new Third();
	delete ptr;
	...
}

 

🌟 소멸자 호출과정

 

 

🟩 참조자

🌟 포인터/상속

C++에서 AAA형 포인터 변수는, AAA객체 도는 AAA를 직/간접적으로 상속하는 모든 객체를 가리킬 수 있다. (객체의 주소값을 저장할 수 있다)

First형 포인터 변수 👉 First 클래스에 정의된 MyFunc() 함수 호출

Second형 포인터 변수 👉 Second 클래스에 정의된 MyFunc() 함수 호출

Third형 포인터 변수 👉 Third 클래스에 정의된 MyFunc() 함수 호출

🌟 위의 특성들은 참조자의 경우에도 적용된다.

C++에서 AAA형 참조자는, AAA객체 또는 AAA를 직/간접적으로 상속하는 모든 객체를 참조할 수 있다.

First형 참조자 👉 First 클래스에 정의된 MyFunc() 함수 호출

Second형 참조자 👉 Second 클래스에 정의된 MyFunc() 함수 호출

Third형 참조자 👉 Third 클래스에 정의된 MyFunc() 함수 호출

int main(){
	Third obj; // Third형 객체 obj 생성

    obj.FirstFunc();
    obj.SecondFunc();
    obj.ThirdFunc();
    obj.SimpleFunc();

    Second & sref = obj; // Second형 참조자는, Second/Third형 객체를 참조할 수 있다.
    sref.FirstFunc();
    sref.SecondFunc(); // 컴파일러는 참조자의 자료형을 가지고 함수의 호출 가능성을 판단한다. 따라서, Second형 참조자이기 때문에, ThirdFunc()는 실행할 수 없다.
    sref.SimpleFunc(); // SimpleFunc()는 가상함수이기 때문에, 실제 객체인 Third형을 따라가서 Third 클래스에 정의된 SimpleFunc() 함수를 호출한다.

    First & fref = obj; // First형 참조자는, First/Second/Third형 객체를 참조할 수 있다
    fref.FirstFunc(); // 컴파일러는 참조자의 자료형을 가지고 함수의 호출 가능성을 판단한다. 따라서, First형 참조자이기 때문에, SecondFunc(), ThirdFunc()는 실행할 수 없다.
    fref.SimpleFunc(); // SimpleFunc()는 가상함수이기 때문에, 실제 객체인 Third형을 따라가서 Third 클래스에 정의된 Simplefunc() 함수를 호출한다.
    return 0;
}

 

void Function(const First & ref) {..}

First 객체 또는 First를 직/간접적으로 상속하는 클래스의 객체가 인자의 대상이 된다.

인자로 전달되는 객체의 실제 자료형에 상관없이, 함수 내에서는 First 클래스에 정의된 함수만 호출될 수 있을 것이다.

그러나, 가상함수의 경우에는 실제 객체의 자료형을 가지고 판단하기 때문에, 호출 가능하다.

---

참고

https://vansoft1215.tistory.com/46?category=491026