c++ 공부 요점정리 24

C언어
c++ 공부 요점정리 24

뮹실이 2013. 12. 4. 00:28
// ##########################################
//
// 41 상속된 객체와 참조 관계
//
// ##########################################
//
// 객체 레퍼런스
// : 객체를 참조할 수 있는 객체 레퍼런스는
//   클래스 포인터의 특성과 같다.
//
// 클래스 객체의 포인터는 클래스의 객체 뿐만아니라
// 클래스를 상속하고 있는 클래스의 객체도 가리킬있다.
// 
// 다음과 같이 상속관계에 있으면
// 사람 클래스의 포인터를 이용해
// 사람, 학생, 파트타임 객체를 가리킬 수 있다.
// 마찬가지로
// 사람 클래스의 참조도
// 사람, 학생, 파트타임 객체를 가리킬 수 있다.
// 또한 학생 클래스의 참조는
// 학생, 파트타임 객체를 가리킬 수 있다.
// 
#include <iostream>
using std::endl;
using std::cout;

class Person
{
public:
	void Sleep(){ 
		cout<<"Sleep"<<endl;
	}
};

class Student : public Person
{
public:
	void Study(){
		cout<<"Study"<<endl;
	}
};

class PartTimeStd : public Student
{
public:
	void Work(){
		cout<<"Work"<<endl;
	}
};

int main(void)
{
	// 파트타임 클래스는 학생, 사람 클래스를
	// 상속하고 있기 때문에
	PartTimeStd p;
	
	// 학생 클래스의 레퍼런스를 이용해 
	// 파트타임 클래스의 객체를 참조한다.
	Student& ref1=p;
	
	// 사람 클래스의 레퍼런스를 이용해 
	// 파트타임 클래스의 객체를 참조한다.
	Person& ref2=p;
	
	p.Sleep();
	ref1.Sleep();
	ref2.Sleep();

	return 0;
}


// 객체 레퍼런스의 권한
// : 객체를 참조하는 레퍼런스의 권한은
//   클래스 포인터의 권한과 일치
//
//
//
#include <iostream>
using std::endl;
using std::cout;

class Person
{
public:
	void Sleep(){ 
		cout<<"Sleep"<<endl;
	}
};

class Student : public Person
{
public:
	void Study(){
		cout<<"Study"<<endl;
	}
};

class PartTimeStd : public Student
{
public:
	void Work(){
		cout<<"Work"<<endl;
	}
};

int main(void)
{
	PartTimeStd p;
	p.Sleep();
	p.Study();
	p.Work();

	// 사람 클래스의 참조는
	// 학생, 파트타임 객체를 참조할 수 있지만
	// 접근할 수 있는 영역은 사람 클래스의 
	// 내에 선언되어 있거나 사람 클래스가 상속
	// 하고있는 멤버로 제한된다.
	Person& ref=p;
	ref.Sleep();
//	ref.Study(); // Error의 원인
//	ref.Work();  // Error의 원인

	return 0;
}

//
// 오버라이딩(overriding)의 이해
// : 오버라이딩과 오버로딩을 혼돈하지 않도록 주의
// : base 클래스에 선언된 멤버와 같은 형태의
//   멤버를 derived 클래스에서 선언하는것
//   base 클래스의 멤버를 가리는 효과를 가짐
//   보는 시야(pointer)에 따라서 달라지는
//   효과를 가짐
//
#include <iostream>
using std::endl;
using std::cout;

class AAA
{
public:
	void fct(){
		cout<<"AAA"<<endl;
	}
};

class BBB : public AAA
{
public: 
	//AAA 클래스의 fct() 함수를 오버라이딩.
	// aaa 클래스의 fct 함수는
	// bbb 클래스의 fct 함수에 의해서
	// 오버라이딩 되었다.
	void fct(){ 
		cout<<"BBB"<<endl;
	}
};

int main(void)
{
	// b 객체를 생성하면
	// b 객체에는 bbb 클래스의 fct 함수가 있고
	// aaa 클래스의 fct 함수도 있다.
	// 그리고 aaa 클래스의 fct 함수는
	// bbb 클래스의 fct 함수에 의해
	// 오버라이딩 되어있는 상태이다.
	// 즉, 가려진 상태이다.(은닉되어졌다.)
	BBB b;
	
	// 그래서 b 객체의 fct 함수를 호출하면
	// 다음과 같이 호출하면
	// bbb 클래스의 fct 함수가 호출된다.
	// 은닉된 멤버는 보는 시야를 달리하면
	// 볼수도 있다. 다음 예제 참조
	b.fct();

	return 0;
}

//
//
//
#include <iostream>
using std::endl;
using std::cout;

class AAA
{
public:
	void fct(){
		cout<<"AAA"<<endl;
	}
};

class BBB : public AAA
{
public:
	void fct(){
		cout<<"BBB"<<endl;
	}
};

int main(void)
{
	// bbb 클래스의 포인터로 객체 b를 가리키고있다.
	BBB* b=new BBB;
	
	// 포인터가 "보는 시야"에 해당한다.
	// b 객체를 bbb 클래스의 포인터로 가리키면
	// bbb 클래스로 바라보는 것
	// 그렇기 때문에 bbb 클래스의 fct 함수가
	// 호출되고 bbb 클래스의 객체내의 모든
	// 멤버에 접근가능
	b->fct();

	// aaa 클래스의 포인터로 객체 b를 가리키고있다.
	AAA* a=b;
	
	// bbb 클래스의 객체이지만
	// aaa 클래스의 포인터로 가리키면
	// aaa 클래스의 객체로 바라보는 것이기 때문에
	// aaa 클래스의 멤버에만 접근가능하므로
	// aaa 클래스의 fct 함수가 보이게 되어
	// 가려졌던 aaa 클래스의 fct 함수
	// 호출이 가능해진다.
	a->fct();

	delete b;
	return 0;
}

//
// 멤버 함수를 가상(virtual)으로 선언하기
// : 오버라이딩 되는 경우의 특징
//
//
#include <iostream>
using std::endl;
using std::cout;

class AAA
{
public:
	// virtual 키워드가 추가됨
	// 즉, fct 함수를 가상으로 선언하겠다는 의미
	// 없는 함수로 인식하라 라는 의미
	virtual void fct(){
		cout<<"AAA"<<endl;
	}
};

class BBB : public AAA
{
public:
	void fct(){
		cout<<"BBB"<<endl;
	}
};

int main(void)
{
	// bbb 클래스의 포인터로 객체 b를 가리키고있다.
	BBB* b=new BBB;
	b->fct();

	// aaa 클래스의 포인터로 객체 b를 가리키고있다.
	AAA* a=b;
	
	// aaa 클래스의 포인터로 객체 b를 가리키면
	// 가려졌던 aaa 클래스의 fct 함수가 보이게 되어
	// aaa 클래스의 포인터로 fct 함수를 호출하면
	// aaa 클래스의 fct 함수가 호출되어야하지만
	// aaa 클래스의 fct 함수가 가상함수이므로
	// aaa 클래스의 fct 함수를 오버라이딩 하고있는
	// bbb 클래스의 fct 함수가 대신 호출된다.
	// 이 특성을 재정의 라고 한다.
	// 오버라이딩에서 버추얼 키워드를 사용하지 않으면
	// 은닉의 특성을 지니게 되고 
	// 버추얼 키워드를 사용하면 재정의의 특성을 지니게 된다.
	//
	a->fct();

	delete b;
	return 0;
}

//
// 멤버 함수를 가상(virtual)으로 선언하기
// : virtual 특성도 상속된다.
//
//
저작자표시 비영리 변경금지 (새창열림)