몽쉘통통

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

// ##########################################
//
// 46 다중 상속에 대한 이해
//
// ##########################################
//
// 다중상속은 문법적 가치가 아주 낮아서 
// 사용을 권장하지 않는다.
// 
//
// 다중 상속의 예
//
#include <iostream>
using std::cout;
using std::endl;

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

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

class CCC : public AAA, public BBB{
public:
	void ShowString(){
		String1();
		String2();
	}
};

int main(void)
{
	CCC ccc;
	ccc.ShowString();

	return 0;
}

//
// 다중 상속의 모호성
//
#include <iostream>
using std::cout;
using std::endl;

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

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

class CCC : public AAA, public BBB{
public:
	void ShowString(){
		// 아래는 에러 발생
		String();  
		String();  
		// 다음과 같이 에러 해결
		// 그러나 이렇게 사용하는건
		// 코드가 지저분해지는 길..
		// 이래서 다중상속을 하면안된다..
		// AAA::String();
		// BBB::String();
	}
};

int main(void)
{
	CCC ccc;
	ccc.ShowString();

	return 0;
}

//
// virtual base 클래스 예제
//
// BBB, CCC 클래스가 AAA 클래스를 각각 상속하고 있는데
// DDD 클래스가 BBB 클래스와 CCC 클래스를 상속하게되어
// DDD 클래스의 객체 내에는 AAA 클래스를 상속하는
// BBB 클래스와 AAA 클래스를 상속하는 CCC 클래스를 
// 가지게 된다.
// 즉, AAA 클래스가 DDD 클래스속에 중복으로 존재하게 된다.
//
//
#include <iostream>
using std::cout;
using std::endl;

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

class BBB : public AAA{   // class BBB : virtual public AAA
public:
	void String2(){
		cout<<"BBB::String"<<endl;
	}
};

class CCC : public AAA{  // class CCC : virtual public AAA
public:
	void String3(){
		cout<<"CCC::String"<<endl;
	}
};

class DDD : public BBB, public CCC {
public:
	void ShowString(){
		String1();// error
		// 이런식으로 사용해야한다.
		// AAA 클래스가 두번 상속되었기 때문에
		// 어디 클래스의 string1을 호출할지 
		// 결정해줘야 한다.
		// 
		// BBB::String1();
		// CCC::String1();
		
		String2();
		String3();
	}
};


int main(void)
{
	DDD ddd;
	ddd.ShowString();

	return 0;
}

// 이러한 문제를 해결하기 위해서
// 추가된 개념이 있다.
// BBB 클래스가 AAA 클래스를 가상으로 상속하고
// CCC 클래스가 AAA 클래스를 가상으로 상속할 때
// BBB 클래스와 CCC 클래스를 동시에 상속하는 
// 클래스 내에서는 AAA 클래스를 한번만 선언한다.
// 상속 선언시 virtual 을 선언해주면된다.
//
//
#include <iostream>
using std::cout;
using std::endl;

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

class BBB : virtual public AAA{   // class BBB : virtual public AAA
public:
	void String2(){
		cout<<"BBB::String"<<endl;
	}
};

class CCC : virtual public AAA{  // class CCC : virtual public AAA
public:
	void String3(){
		cout<<"CCC::String"<<endl;
	}
};

class DDD : public BBB, public CCC {
public:
	void ShowString(){
		// error가 발생하지 않는다.
		// AAA 클래스가 하나만 상속되기 때문에
		String1();
		
		String2();
		String3();
	}
};


int main(void)
{
	DDD ddd;
	ddd.ShowString();

	return 0;
}

//
// 이러한 다중 상속들은 사용하지 말아야한다.!!!!
//

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// ##########################################
//
// 45 가상함수가 동작하는 원리
//
// ##########################################
//
//
// 다음과 같이 fct1, fct2, fct3는 모두 코드영역의
// 메모리 공간으로 올라가는데
// 클래스에 멤버함수중에서 하나라도 virtual로 선언되면
// 그 클래스의 멤버함수 정보를 지니는 버추얼테이블이 
// 형성된다.
// 모슨 A 클래스의 객체는 함수를 호출할 때 마다
// 버추얼테이블을 참조하게 된다.
// 이 버추얼테이블은 A 클래스의 fct1 함수가 어디에 있는지의
// 정보를 가지고 있고
// A 클래스의 fct2 함수가 어디에 있는지의 정보를 
// 가지고 있다.
// 즉 모든 멤버함수의 정보를 가지고 있다. 
// A 클래스의 aaa 객체의 fct1 함수를 호출하면
// 무조건 버추얼 테이블의 키값을 참조하게된다.
// fct1 함수의 key값을 찾고 value에 있는 위치찾아가 
// fct1 함수를 호출하게 된다.
// 즉, 가상함수를 선언함으로 인해서 버추얼테이블에 의한
// 메모리 소모와 버추얼 테이블을 참조함으로 인한 
// 함수 호출단계가 추가되어 함수 호출이 늦어지는 
// 단점이 있다.
// 
// B 클래스의 경우 A 클래스를 상속하기 때문에
// A 클래스의 멤버 함수도 멤버로 가지게 된다.
// 따라서 A클래스의 fct1, fct2, B 클래스의 fct1, fct3함수
// 의 정보를 버추얼테이블에서 가지고 있어야한다.
// 그러나 B클래스의 fct1에 의해서 오버라이딩된
// A 클래스의 fct1함수는 B 클래스의 버추얼테이블에
// 정보를 가지고 있지 않는다.
// 그래서 A 클래스의 포인터로 fct1 함수를 호출하던
// B 클래스의 포인터로 fct1 함수를 호출하던
// B 클래스의 fct1 함수만이 호출되는 것이다.
//
#include <iostream>
using std::endl;
using std::cout;

class A
{
	int a;
	int b;
public:
	virtual void fct1(){
		cout<<"fct1(...)"<<endl;
	}
	virtual void fct2(){
		cout<<"fct2(...)"<<endl;
	}	
};

class B : public A
{
	int c;
	int d;
public:
	virtual void fct1(){
		cout<<"overriding fct1(...)"<<endl;
	}
	void fct3(){
		cout<<"fct3(...)"<<endl;
	}
};

int main(void)
{
	A* aaa=new A();
	aaa->fct1();

	B* bbb=new B();
	bbb->fct1();
	
	return 0;
}

//
// 이러한 가상함수의 단점에도 불구하고
// 가상함수의 장점이 훨씬 크기 때문에
// 가상함수를 많이 사용한다.
//

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

// ##########################################
//
// 44 멤버 함수의 위치
//
// ##########################################
//
// 객체에 의해서 공유되는 멤버 함수
//
// 
class AAA
{
	int n;
	
	public :
		A(int n){
			this->n = n;
		}
		
		void add(){
			n++;
		}
}

void main()
{
	// AAA 객체를 생성 할 때마다 add 함수가 
	// 각 객체 내에 중복으로 존재하면
	// 비효율적이다.
	// 실제는 각 객체들은 하나의 add 함수를 공유한다.
	// 일단, 컴파일하면
	// 코드자체가 코드영역이라 불리는 메모리 영역에 
	// 올라간다.
	// AAA 클래스의 add 함수 또한 코드 영역의 메모리
	// 공간에 올라간다.
	// a1 객체의 add 함수를 호출하면 코드 영역의 메모리
	// 공간에 올라간 add 함수를 호출하고
	// a2 객체의 add 함수를 호출하면 코드 영역의 메모리
	// 공간에 올라간 add 함수를 호출한다.
	// 즉 각 객체의 멤버함수는 코드영역의 함수를 공유한다.
	// 그러면 코드영역의 add 함수는 어떻게
	// a1에서 add 함수를 호출하면 a1의 멤버변수를 조작하고
	// a2에서 add 함수를 호출하면 a2의 멤버변수를 조작하느냐면
	// add 함수가 코드 영역에 올라갈때 
	// AAA 클래스의 포인터를 인자로 받도록 변경되어 
	// 올라간다.
	// void add(AAA* a)
	// { (a->n)++;}
	// 이런식으로 객체의 포인터를 전달 인자로 전달하기
	// 때문에 함수의 공유가 가능하다.
	//
	AAA a1(10);
	AAA a2(20);
	
	a1.add();
	a2.add();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// ##########################################
//
// 43 Virtual 소멸자의 필요성
//
// ##########################################

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

class AAA
{
	char* str1;
public:
	AAA(char* _str1){
		// 생성자 내에서 동적할당하므로
		str1= new char[strlen(_str1)+1];
		strcpy(str1, _str1);
	}
	~AAA(){			// virtual ~AAA()
		cout<<"~AAA() call!"<<endl;
		// 소멸자에서 메모리 해제한다.
		delete []str1;
	}
	virtual void ShowString(){
		cout<<str1<<' ';
	}
};

// bbb 클래스가 소멸될 때는 bbb 클래스의 소멸자도
// 호출되지만
// 상속하고 있는 aaa 클래스의 소멸자도 호출된다.
// bbb 클래스 객체가 생성될때
// bbb 클래스의 생성자에 의해서 동적할당하고
// aaa 클래스의 생성자에 의해서 동적할당하고
// 두군데에서 할당된 메모리공간이 
// 각각의 소멸자에 의해서 적절히 해제된다.
//
class BBB : public AAA
{
	char* str2;
public:
	BBB(char* _str1, char* _str2) : AAA(_str1){
		// 생성자 내에서 동적할당하므로
		str2= new char[strlen(_str2)+1];
		strcpy(str2, _str2);
	}
	~BBB(){
		cout<<"~BBB() call!"<<endl;
		// 소멸자에서 메모리 해제한다.
		delete []str2;
	}
	virtual void ShowString(){
		AAA::ShowString();
		cout<<str2<<endl;
	}
};

/***** main function **************/
int main()
{
	// bbb 클래스 객체를 생성하면
	// aaa 클래스의 생성자도 호출된다.
	BBB * b=new BBB("Good", "morning");
	b->ShowString();
	delete b;
	// bbb 클래스의 객체가 소멸될때는
	// 상속하는 aaa 클래스의 소멸자도 호출된다.
	
	// bbb 클래스의 객체를 생성하면
	// aaa 클래스의 생성자도 호출되지만
	AAA * a=new BBB("Good", "evening");
	a->ShowString();	
	delete a;
	// aaa 클래스의 객체가 소멸될때는
	// bbb 클래스의 소멸자가 호출되지 않아
	// 메모리 유출이 발생한다.
	// bbb 클래스의 객체를 생성했지만
	// 소멸의 주체가 aaa 클래스이기 때문에
	// aaa 클래스의 소멸자만 호출하기 때문에
	// 문제 발생
	// 이문제를 해결하기 위해서는
	// aaa 클래스의 소멸자를 가상함수로 선언하면된다.
	// aaa 클래스의 소멸자를 가상함수로 선언하면
	// aaa 클래스의 소멸자를 호출할때 가상함수이므로
	// bbb 클래스의 소멸자가 대신 호출된다.
	// 소멸자를 오버라이딩할순없지만 소멸자의 경우는
	// 오버라이딩이 소멸자끼리 된다.
	// 따라서 bbb 클래스의 소멸자가 호출되고
	// bbb 클래스가 상속하고 있는
	// 다시 aaa 클래스의 소멸자가 호출되어 완전히
	// 메모리 해제가 된다.
		
	return 0;
}