가상 함수는 원칙적으로 파생 클래스에서 재정의할 수 있다. 그렇다고 해서
반드시 파생 클래스에서 가상 함수를 재정의해야 한다는 것은 아니며 기반 클
래스의 가상 함수를 그대로 상속받고자 할 경우는 가상 함수를 재정의하지 않
아도 된다. 그러나 재정의할 때는 기반 클래스의 가상 함수와 함수의 형이 같
아야 한다. 여기서 함수의 형이란 인수의 개수와 인수의 데이터 타입을 말한다.
파생 클래스에서 가상 함수의 형을 다르게 하여 재정의할 경우는 두 가지 경우
로 나누어진다.
1 파생 클래스에서 인수의 형이 다르게 가상 함수를 정의한 경우
이 경우는 기반 클래스의 가상 함수가 무시되고 새로운 함수가 만들어진다.
함수의 이름이 같더라도 데이터 타입이 다르면 다른 함수로 인식되므로 인수
가 다른 함수를 정의하는 것은 다른 함수를 아예 새로 정의하는 것이 된다.
기반 함수의 가상 함수는 상속이 되지 않는다.
2 리턴값을 다르게 한 경우
이 경우는 에러로 처리된다. 리턴값이야 어쨌든 인수가 같으므로 기반 클래
스의 가상 함수와 같은 함수로 인식되는데 같은 함수를 다른 리턴값으로 재
정의하는 것은 허용되지 않는다. 리턴값은 다형성의 재료가 되지 못한다.
가상 함수를 재정의하는 여러 가지 예를 보자.
#include <iostream.h>
class classA { //
기반 class
public:
virtual void outdata()
{
cout << "I'm classA" << endl;
}
};
class classB:public classA { // 같은 이름 같은 인수로 가상 함수
public: //
를 재정의한다.
void outdata()
{
cout << "I'm classB" << endl;
}
};
class classC:public classA { }; // 가상 함수 정의를 하지 않음
class classD:public classA { // 인수의 형이 다른 가상 함수
정의
public:
void outdata(int i)
{
cout << "I'm classD" << endl;
}
};
/*
class classE:public classA { // return값이 다른 가상 함수 정의
public:
int outdata()
{
cout << "I'm classE" << endl;
}
};
*/
void main()
{
classA A;
classB B;
classC C;
classD D;
//classE E;
A.outdata();
B.outdata();
C.outdata();
D.outdata(1);
//D.outdata();
//E.outdata();
}
classA를 제외한 나머지 클래스들은 모두 classA로부터 파생된 클래스이다.
classA에 outdata라는 가상 함수가 선언되어 있으며 각각의 파생 클래스에서는
가상 함수를 재정의하는 방법이 다양하다. 실행 결과를 보이면 다음과 같다.
I'm classA // classA의 객체가 출력
I'm classB // classB의 객체가 출력
I'm classA // classC의 객체가 출력
I'm classD // classD의 객체가 출력
classA의 객체가 호출한 outdata 함수는 당연히 classA의 멤버 함수인 classA
::outdata일 것이며 classB의 객체가 호출한 outdata 함수는 classB에서 재정
의한 classB의 멤버 함수인 classB::outdata이다. classC에서는 가상 함수를
별도로 정의하지 않았으므로 classA의 멤버 함수인 classA::outdata를 그대로
상속받아 사용한다.
classD에서는 인수를 별도로 취하는 가상 함수를 정의하였으므로 가상 함수를
호출할 때도 인수를 반드시 주어야 한다. 예제에서 주석으로 처리해 놓은 문구
들은 모두 에러를 일으키는 문장들이다. 먼저 classE는 리턴값이 다른 가상 함
수를 다시 정의하였으므로 에러를 발생시키며 classD의 객체에서 인수없이 out
data를 호출하는 것도 안된다.
라. 상속과 포인터
기반 클래스의 포인터는 파생 클래스의 객체를 포인트할 수 있다. 그러나 그
반대로 파생 클래스의 포인터는 기반 클래스의 객체를 포인트할 수 없다. 다음
에 예를 보인다.
class A { ... };
class B:public A { ... };
A objA;
B objB;
A *ptrA;
B *ptrB;
ptrA=&objB; // 가능
ptrB=&objA; // 불가능
기반 클래스의 포인터가 파생 클래스의 객체를 포인트함으로써 발생하는 문제
는 포인터 변수를 사용하여 객체의 멤버를 참조할 경우 어떠한 멤버를 참조하
느냐 하는 문제이다. 이때 포인터의 데이터 타입을 따를 것인가 아니면 포인터
가 실제로 포인트하고 있는 객체를 참조할 것인가의 문제가 발생하는데 C++에
서는 포인터의 타입보다는 포인트하는 객체에 따라 멤버를 참조하도록 되어 있
다. 예제를 보자.
#include <iostream.h>
class classA {
public:
int dataA;
classA(int a)
{dataA=a;}
};
class classB:public classA {
public:
int dataA;
classB(int a):classA(a)
{ }
};
class classC:public classA {
public:
int dataA;
classC(int a):classA(a)
{ }
};
void main()
{
classA A(2); // 각 클래스의 객체를 만듦
classB B(3);
classC C(4);
classA *ptr; // classA형의 포인터 변수 선언
ptr=&A; //
A의 번지를 대입
cout << ptr->dataA << endl;
ptr=&B; //
B의 번지를 대입
cout << ptr->dataA << endl;
ptr=&C; //
C의 번지를 대입
cout << ptr->dataA << endl;
}
classA로부터 classB와 classC를 파생시키고 있으며 각 클래스는 모두 개별적
으로 dataA라는 데이터 멤버를 가지고 있다. main 함수에서 세개의 객체를 만
들고 각 객체의 dataA를 별도로 다른 값을 주어 정의하고 있다. classA형의 객
체를 포인트하는 변수 ptr을 만들어 이 변수에 세 객체의 번지를 차례로 대입
하여 ptr이 포인트하는 객체의 dataA 멤버를 참조하고 있다.
ptr은 비록 classA형의 객체를 포인트하도록 되어 있지만 파생 클래스의 객체
를 포인트할 경우 포인터 변수의 타입에 상관없이 파생 클래스의 객체를 참조
한다. 실행 결과는 다음과 같다.
2
3
4