몽쉘통통

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

// =====================================================
// 20 객체의 생성 과정
// =====================================================
// 객체의 생성
// : 메모리 할당하고, 생성자의 호출한다
//
//
// ex
//
#include<iostream>
using std::cout;
using std::endl;

const int SIZE=20;

class AAA
{
	int i, j;
public:
	AAA(int _i, int _j) //생성자.
						// 생성자 호출시 인자를 
						// 전달해야한다
						// 전달하지 않도록 생성자를
						// 코딩하면
						// AAA 클래스 선언시 항상 같은
						// 값으로 초기화 할수밖에
						// 없음
	{ 
		i=_i, j=_j;
	}
	void ShowData()
	{
		cout<<i<<' '<<j<<endl;
	}
};

int main()
{
	AAA aaa(111, 222); // AAA 클래스의 객체를 생성하는데
						// 객체의 이름은 aaa이고
						// 111,222를 인자로 받을수 있는
						// 생성자를 호출
						// 클래스 외부에서 생성자를
						// 호출하므로 외부 접근이다.
						// 즉, 생성자를 public으로 선언
						//해야지 private로 선언하면 안됨
	aaa.ShowData();

	return 0;
}



// =====================================================
// 21 public 생성자, private 생성자
// =====================================================
//
// public 생성자 : 어디서든 객체 생성 가능
// private 생성자 : 클래스 내부에서만 가능
//
// 객체를 생성할 때
// 다음 두줄은 같은 의미이지만 
// 보통 아래 줄과 같이 사용한다.
// "aa","bb",22를 인자로 받는
// 생성자를 호출하면서 person 클래스인 
// 객체 p를 선언한다
Person p = Person("aa","bb",22)
Person p("aa","bb",22);

// 다음은 객체 생성이 아니라
// 함수의 선언이다
// a라는 이름의 함수인데 
// 리턴타입이 A 클래스인 객체이고
// 인자값을 받지 않는 void 형태의
// 함수 선언이다.
// 객체 생성으로 오해하지 않도록 주의 필요
// 
// 다음줄을 void 형태의 생성자를 호출하는 
// 클래스를 생성하는 것으로 인정하면
// 함수를 선언하는건지
// 클래스를 선언하는건지 알수없으므로
Person p();

// void 형태의 생성자를 호출하는
// 클래스를 선언할때는 
// 다음과 같이 괄호를 빼준다
Person p;

// 인자를 받는 생성자를 호출하는
// 클래스의 객체를 선언할때는 다음과 같이
// 선언
Person p("aa","bb",22);

// default 생성자
// : 생성자가 하나도 정의되어 있지 않은 경우
//   자동으로 삽입 되는 생성자
//   디폴트 생성자가 하는일은 아무거도 없다
// ex
// 다음과 같이 클래스에 생성자를 
// 선언해주지 않아도
class point
{
	int x,y;
	public:
	void show(){...}
}

// 컴파일시 자동으로 point(){}가 추가된다
// 즉, 위에 선언한 클래스와 다음의 클래스는 
// 같은 의미이다.
class point
{
	int x,y;
	public:
	point(){}
	void show(){...}
}

// 생성자는 오버로딩도 가능하다
// 다음과 같이 생성자를 여러개 
// 선언할 수도 있다.
class point
{
	int x,y;
	public:
	point()
	{...}
	point(int x, int y)
	{...}
	void show(){...}
}

// 생성자는
// 함수이다. 즉 함수의 특징을 가진다.
// 함수 오버로딩이 가능하다
// 디폴트 매개 변수의 설정도 가능하다

// 디폴트 매개 변수
class point
{
	int x,y;
	public:
	// 전달되는 인자가 없으면 0으로 
	// 대체한다
	point(int x=0, int y=0)
	{...}
	void show(){...}
}

// 디폴트 매개 변수
// 같은 의미
point p1;     == point1(0,0);
point p2(10); == point p2(10,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
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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312

// =====================================================
// 16 클래스의 내부 접근과 외부 접근
// =====================================================
// 멤버 변수 or 멤버 함수에 접근함에 있어서
// 내부 접근과 외부 접근방식이 있다
//
// 내부 접근 ; 자기가 선언된 클래스 내의 접근
// 외부 접근 : 내부 접근 외의 접근
//
// ex 1
#include <iostream>
using std::cout;
using std::endl;

class Counter {
public:
	int val;
	void Increment(void)
	{
		val++; 			//내부 접근.
						// 같은 영역에 선언되어
						// 있는 멤버에 접근
	}
};

int main(void)
{
	Counter cnt; 		 // 지역 변수의 특징을 가지는 
						 // 지역 객체
	cnt.val=0; 			 // 카운터라는 자료형의 외부에서
						// 접근하므로 외부 접근.
	cnt.Increment(); 	 //외부 접근.
	cout<<cnt.val<<endl; //외부 접근.

	return 0;
}

//
// c++에서는 접근 제어에 관련된 키워드 3가지를 제공한다
// 접근 제어 키워드 : 멤버 변수나 멤버 함수를 선언하는데 있어서
// 					  접근 허용 범위를 이야기함
//
// 아래로 내려갈수록 접근 범위가 작아짐
// (접근을 최소한으로 허용함)
// 즉, public이 접근범위가 가장 큼
//
// public    : 외부 접근과 내부 접근을 모두 허용함
// protected
// private   : 클래스 내부 접근만 허용함
//			   public이나 protected or private 중 
//			   아무거도 입력하지 않으면 default로
//			   private 가 적용된다
//
// ex 2
//
#include <iostream>
using std::cout;
using std::endl;

const int OPEN=1;
const int CLOSE=2;

class Door{	
private: // 지금부터 선언하는 멤버 변수나 멤버 함수는
		// 접근 제어를 private로 하겠다는 의미
	int state;

public:// 지금부터 선언하는 멤버 변수나 멤버 함수는
		// 접근 제어를 public으로 하겠다는 의미
	void Open(){
		state=OPEN;
	}
	void Close(){
		state=CLOSE;
	}
	void ShowState(){
	    cout<<"현재 문의 상태 : ";
		cout<<((state==OPEN)? "OPEN" : "CLOSE")<<endl;	
	}
};

int main()
{
	Door d;
	d.state=OPEN; // 외부 접근이므로 private로
				// 선언된 state는 접근할 수 없다.
				// 컴파일 시 에러발생
	d.Open();		// public이므로 외부접근 가능
	d.ShowState(); // public이므로 외부접근 가능

	return 0;
}



// =====================================================
// 17 정보 은닉
// =====================================================
//
// 클래스 다자인 기본 원칙 : 캡슐화, 정보 은닉
//
// 정보 은닉을 통해
// 프로그램의 안정적 구현이 용이함
//
// 캡슐화 : 관련잇는 데이터와 함수를 하나로 묶는 것
//
// 클래스 객체의 생성과 소멸 : 생성자, 소멸자
//

// 정보 은닉전 예제
// 메인에서 클래스의 변수를
// 마음대로 변경시킬수 있다
#include<iostream>
using std::cout;
using std::endl;
using std::cin;

class Point
{
public:
	int x;   // x좌표의 범위 : 0 ~ 100
	int y;   // y좌표의 범위 : 0 ~ 100
};

int main()
{
	int x, y;
	cout<<"좌표입력 : ";
	cin>>x>>y;

	Point p;
	p.x=x;
	p.y=y;

	cout<<"입력 된 데이터를 이용해서 그림을 그림"<<endl;
	return 0;
}

// 정보 은닉 후 예제
// 메인에서(클래스 밖에서) 변수를 마음대로
// 변경 시킬 수 없고 클래스의 멤버 함수를
// 이용해 변수의 값을 변경시키므로
// (멤버 함수는 멤버 변수에 이상한 값을
// 입력 할 수 없는 기능을 하도록 선언하면)
// 변수 값에 이상한 값이 들어가는것을 막을 
// 수 있다.
#include<iostream>
using std::cout;
using std::endl;
using std::cin;

class Point
{
	int x;   // x좌표의 범위 : 0 ~ 100
	int y;   // y좌표의 범위 : 0 ~ 100
public:
	int GetX(){	return x; }
	int GetY(){	return y; }

	void SetX(int _x);
	void SetY(int _y);
};

void Point::SetX(int _x)
{
	if(_x<0 || _x>100)	
	{
		cout<<"X좌표 입력 오류, 확인 요망"<<endl;
		return;
	}
	x=_x;
}
void Point::SetY(int _y)
{
	if(_y<0 || _y>100)
	{
		cout<<"Y좌표 입력 오류, 확인 요망"<<endl;
		return;
	}
	y=_y;
}


int main()
{
	int x, y;
	cout<<"좌표입력 : ";
	cin>>x>>y;

	Point p;
	p.SetX(x);
	p.SetY(y);

	cout<<"입력 된 데이터를 이용해서 그림을 그림"<<endl;
	return 0;
}



// =====================================================
// 18 캡슐화(encapsulation)
// =====================================================
// 캡슐화 : 관련잇는 데이터와 함수를 하나로 묶는 것

// 캡슐화 전 예제
class Point
{
	int x;   // x좌표의 범위 : 0 ~ 100
	int y;   // y좌표의 범위 : 0 ~ 100
public:
	int GetX(){	return x; }
	int GetY(){	return y; }

	void SetX(int _x);
	void SetY(int _y);
};

class PointShow
{
public:
	void ShowData(Point p)
	{
		cout<<"x좌표: "<<p.GetX()<<endl;
		cout<<"y좌표: "<<p.GetY()<<endl;
	}

};

// 캡슐화 후 예제
class Point
{
	int x;   // x좌표의 범위 : 0~100
	int y;   // y좌표의 범위 : 0~100
public:
	int GetX(){	return x; }
	int GetY(){	return y; }

	void SetX(int _x);
	void SetY(int _y);

	void ShowData();  //캡슐화를 위해 추가된 함수.
};




// =====================================================
// 19 생성자
// =====================================================
// 생성자 : 객체를 생성과 동시에 초기화시켜준다
//          생성과 동시에 초기화되는것이 좋은 구조이다
//          객체 생성시 반드시 한번 호출되는 함수
//          클래스와 같은 이름의 함수이다.
//          리턴형이 없으며 리턴하지도 않는다
// ex
//
#include<iostream>
using std::cout;
using std::endl;
using std::cin;

const int SIZE=20;

class Person
{
	char name[SIZE];
	char phone[SIZE];
	int age;
public:
	void ShowData();
};

int main()
{
	// 클래스 default인 privateㄷ로 선언되어있기
	// 때문에 외부접근은 불가능한데
	// 외부접근을 시도했으므로
	// 컴파일시 에러발생
	Person p={"KIM", "013-113-1113", 22};
	return 0;
}

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

const int SIZE=20;

class Person
{
	char name[SIZE];
	char phone[SIZE];
	int age;
public:
	void ShowData();
	void SetData(char* _name, char* _phone, int _age);
};

int main()
{
	Person p;
	// 클래스 생성과 동시에 초기화는 아니다
	// 초기화시키기 위한 방법일뿐
	p.SetData("KIM", "013-333-5555", 22);
	p.ShowData();

	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
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

// =====================================================
// 11 구조체의 유용성
// =====================================================
// 구조체의 유용성
// : 관련있는 데이터를 하나의 자료형으로 묶을 수 있다.
//   따라서 프로그램의 구현 및 관리가 용이해짐
//   함께 움직이는 데이터들을 묶어주는 효과

// c언어는
// : 모든 사용자 정의 자료형을
//   기본 자료형으로 인식해 주지 않는다.
// ex
struct person{
	int age;
	char name[10];
}

int main(void)
{
	int a = 10;
	person p; 	// 에러발생
				// struct person p; 로 선언해야함
				// c에서는 사용자 자료형을 기본자료형
				// 처럼 선언할 수 없다.
}
// c++은 기본자료형이나 사용자 정의 자료형의 차이가 없다.
// 즉, person p;로 선언가능함




// =====================================================
// 12 함수에 넣으면 좋은 구조체
// =====================================================
// c에서는 구조체에 함수를 정의할 수 없지만
// c++에서는 구조체에 함수를 정의 할 수 있다.
// ex
#include <iostream>
using std::cout;
using std::endl;

struct Account {
	char accID[20];    // 구조체의 멤버 변수
	char secID[20];    // 구조체의 멤버 변수
	char name[20];     // 구조체의 멤버 변수
	int balance;       // 구조체의 멤버 변수

	void Deposit(int money){ // 구조체의 멤버 함수
		balance+=money; // 구조체 멤버 함수는 
						// 같은 구조체의 멤버 변수를
						// 참조할 수 있다.
						// 같은 이름으로 구조체 멤버 함수안에
						// 지역변수를 선언할 경우
						// 같은 이름의 구조체 멤버 변수는
						// 가려지게 되어 사용할 수 없다
						// 
	}
	void Withdraw(int money){ // 구조체의 멤버 함수
		balance-=money;
	}

};

int main(void)
{
	Account yoon={"1234", "2321", "yoon", 1000};

	yoon.Deposit(100); // 구조체의 변수에 접근하기 위해
						// 접근 연산자 "."을 사용하는 것처럼
						// 구조체의 함수에 접근하기 위해서도
						// 접근 연산자 "."을 사용한다
	cout<<"잔    액 : "<<yoon.balance<<endl;

	yoon.Withdraw(200);
	cout<<"잔    액 : "<<yoon.balance<<endl;

	return 0;
}




// =====================================================
// 13 함수에 넣으면 좋은 구조체
// =====================================================
// 클래스 : 멤버 변수 + 멤버 함수
//          클래스를 이용해 변수를 선언할 경우
//          그 변수는 객체라고 부른다
//          변수가 아니라 객체(object 완전한 대상체)


// c에서는
//
// 기본 자료형   : int, double, ...
// 사용자 자료형 : 구조체, 공용체, enum, ...
//               구조체 : 기본자료형과 기존에 만들어진
//                        사용자 자료형을 이용해만듬,
//                        변수만을 이용해서

// c++에서는
//
// 기본 자료형   : int, double, ...
// 사용자 자료형 : 클래스
//                 클래스 : 변수와 함수를 이용해 만듬
//
// c++에서 구조체는 클래스에 포함된다.
// 즉, 구조체는 클래스의 하위개념
// 특정 구조체 안의 함수를 호출하는 행위를 
// mesage passing이라고 부른다.

// 변수와 함수를 하나로 묶어서 하나의 자료형을 만드는데 있어서
// struct라는 자료형을 이용할 수도 있고
// class라는 자료형을 이용해 만들 수도 있다.
// 두가지 방법은 거의 일치하나 딱 한가지 차이가 있다
// 
//

// 왜 클래스가 나타났는가
// 왜 변수와 함수를 묶어서 자료형을 선언해야하는가
// : 

// 왜 변수가 아니라 객체라 부르는가
// : 


// =====================================================
// 14 구조체가 아니라 클래스
// =====================================================

// =====================================================
// 15 클래스와 객체
// =====================================================

// =====================================================
// 16 클래스의 내부 접근과 외부 접근
// =====================================================

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
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229

// =====================================================
// 8 레퍼런스의 이해
// =====================================================
// 레퍼런스와 변수는 
// 생성되는 방법에 있어서만 차이를 보일 뿐
// 만들어지고 나면 완전히 같은 것

// 레퍼런스의 제약
// 1 이름이 존재하지 않는 대상을 레퍼런스 할 수 없다
int &ref2 = 10; // 상수가 올수 없으므로 에러
// 2 선언과 동시에 반드시 초기화 되어야 한다.
int &ref1; // 초기화 되지 않았으므로 에러


// =====================================================
// 9 레퍼런스 함수
// =====================================================
// 포인터를 이용한 call-by-reference
// : 함수 외부에 선언된 변수의 접근이 가능
// 포인터 연산에 의해서 가능한 것임
// 포인터 연산의 위험성 존재
// ex
void swap(int *a, int *b)
{
	int temp = *a;
	a++; // 실수로 입력하게 되면 치명적 오류 발생가능
		// 4바이트가 증가되어 원래 a가 가리키던 메모리
		//에서 4바이트를 건너뛰게 되어 어딘지 모르는
		// 곳의 메모리 값을 참조하게 되어 위험
	*a = *b;
	*b = temp;
}

// 레퍼런스를 이용한 call-by-reference
// : 함수 외부에 선언된 변수의 접근이 가능
// 포인터 연산을 할 필요가 없으므로 보다 안정적임
// 함수의 호출형태를 구분하기 어렵다.
// ex
int main(void)
{
	int val1 = 10;
	int val2 = 20;
	
	swap(val1, val2); // 이것만 봐서는 call-by-value인지
					// call-by-reference인지 알수없다
					// swap함수의 매개변수를 확인해봐야
					// 알수 있다.
	return 0;
}

void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
// 위 예제는 포인터를 사용하지 않는다.
// 포인터를 사용할 때는 오류를 발생시킬 위험성이 높음
// 따라서 레퍼런스를 이용해 구현하면 보다 안정적임

// call-by-value
// : 함수 호출 시 인자 전달 과정에서 발생
// 데이터를 복사하는 과정에서 발생
// ex
void main(void)
{
	showdata(man);
}
void showdata(person p)
{
// ...
}

// 대신할 수 있는 call-by-reference
// : 전달되는 인자를 레퍼런스로 받으면, 데이터의
// 복사 연산이 필요없다.
// 원본 데이터가 변경될수 있으므로, 
// const로 선언하면 원본 변경 방지 가
// ex
void showdata(const person &p)
{
// ...
}


// =====================================================
// 10 레퍼런스를 리턴하는 함수
// =====================================================
//
// ex
//
#include <iostream>
using std::cout;
using std::endl;

// 레퍼런스 타입으로 리턴
int& increment(int &val)
{
	val++; // 지역변수 val
	return val;
}// 이 함수 호출이 끝나면 val변수는 사라짐

int main(void)
{
	int n=10;
	int &ref=increment(n);
	// increment가 인수로 리턴하면 상수로 리턴하므로
	// 에러 발생
	// 레퍼런스는 상수에 이름을 붙일 수 없으므로.

	cout<<"n  : "<<n<<endl;
	cout<<"ref: "<<ref<<endl;

	return 0;
}

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

int& function()
{
	int val=10;
	return val;
}

int main(void)
{
	int &ref=function();
	cout<<ref<<endl; // 에러 발생가능
					// 권장하지 않음
					// 지역변수로 선언된 변수를 
					// 리턴하므로..........??

	return 0;
}

// new와 delete 연산자의 기능
//
// c에서는
//
// int 형 변수를 힙에다가 할당해주고
// 그 포인터를 리턴받는 형태
// malloc은 인자로 전달되는 인자의 크기만을
// 할당하고 
// 어떤식으로 사용될지 모르니 void 포인터 타입으로 
// 반환된다.
// 따라서 크기를 직접 계산해서 인자로 주고
// 리턴되는 포인터도 용도에 맞게 형변환해서
// 사용해야함
// 할당한 메모리 공간을 해제할때는 free함수 사용
int *val = (int *)malloc(sizeof(int));
free(val);
// 배열 동적할당
// 
int *arr = (int *)malloc(sizeof(int)* size);
free(arr);
//
// c++에서는
//
// new와 delete가 자동으로 할당해줌
// 인자에 크기계산과 포인터 형변환을 해줄 필요없음
// 힙에다가 int형 데이터 저장하기 위한 메모리공간 할당하라
// 4바이트 메모리 공간을 힙에다가 할당하고 
// 알아서 인트형 포인터로 반환해줌
// 할당한 메모리 공간을 해제할때는 
// 할당한 메모리 공간이 int인 경우에는 
// delete 사용하고
// 할당한 메모리 공간이 배열인 경우에는
// delete에 인덱스연산자를 붙여 arr이 가리키는 공간이
// 배열임을 명시적으로 선언해줘야함
int *val = new int;
delete val;
// 배열 동적할당
// 길이가 size인 인트형 배열을 힙에다가 할당하라
// 리턴될때 자동으로 인트형 포인터로 리턴됨
int *arr = new int[size];
delete []arr;

// 메모리 공간 할당에 실패할 경우
// NULL 포인터를 리턴한다.
// ex
int *arr = new int[size];
if (arr == NULL)
{
	cout<<"에러"<<endl;
	return -1;
}
// 이런식의 메모리 할당 실패 검사는 비효율적이므로
// 다음과 같은 방식으로 사용 추천
#include <iostream>

//#define DEBUG 1;
#define DEBUG  0;

using std::cin;
using std::cout;
using std::endl;

int main(void)
{
	int size;
	cout<<"할당하고자 하는 배열의 크기: ";
	cin>>size;

	int* arr=new int[size];  // 배열의 동적 할당.

#if DEBUG==1 
	cout<<"디버그 모드 입니다"<<endl;
	if(arr==NULL)
	{
		cout<<"메모리 할당 실패"<<endl;
		return -1; //프로그램 종료.
	}
#endif

	for(int i=0; i<size; i++)
		arr[i]=i+10;

	for(int j=0; j<size; j++)
		cout<<"arr["<<j<<"]= "<<arr[j]<<endl;

    delete []arr;  // 할당된 메모리 소멸.

	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
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

// =====================================================
// 5 편의를 위한 using 선언
// =====================================================

// A_COM이라는 이름공간안에 정의된 "func"함수를 콜
// 할때는 "A_COM::func" 대신 "func"으로만 사용
using A_COM::func;

// A_COM이라는 이름공간안에 정의된 변수 및 함수 전체를
// 그냥 사용하겠다
using namespace A_COM;

// 범위 지정 연산자 기반 전역변수 접근
int val = 100;

int main(void)
{
	int val = 100;
	::val += 1; // 지역변수는 가려지게됨
				// 이런식으로 전역변수에 접근 가능
	return 0;
}



// =====================================================
// 6 들어가기에 앞서서
// =====================================================

// const 키워드의 의미
// : 변수를 상수화 시킴
// 데이터 상수화, n이 가리키는 메모리 공간의 값을 상수화
// n이라는 포인터를 이용해 값을 변경하는 것을 막는것
const int* n; 
// 포인터 상수화, n이 가리키는 곳을 바꿀수 없다
int* const n;
// n이 가리키는 곳과 가리키는 곳의 값을 바꿀수 없다
const int* const n;

// ex
// 운영체제는 프로그램이 실행되면 메모리를 할당
// 메모리를 효율적으로 사용하기 위해 용도에 맞게 나눔 
// 데이터 영역, 힙(heap) 영역, 스택(stack) 영역
// 데이터 영역 : 프로그램 시작과 동시에 할당되어
//				프로그램 종료되어야지만 할당해제되는 영역
//				전역변수, static 변수가 여기에 해당됨
//				static 변수는 프로그램 시작과 동시에 
//				데이터 영역에 할당되고 static 이 선언된
//				함수가 콜되면 static 변수가 초기화 되는것임
// 힙(heap) 영역 : 런타임의 크기가 결정되는 변수나
//				 배열과 같은 것을 저장하기 위한 공간
//				and 프로그래머가 할당할 수 있음(관리)
//				(malloc, free함수를 이용해서)
// 스택(stack) 영역 : 컴파일 타임의 크기가 결정될수 있는
//					것들을 메모리 공간에 올리기 위한 공간
//					지역변수, 매개변수가 여기에 해당
void func(int);

// main 함수에서 요구되는 메모리는 int 형인 4바이트가 필요
// 즉 컴파일시에 요구되는 메모리 공간의 크기 결정가능
void main(void)
{
	int size; // 이렇게 일반적으로 선언하면
			  // stack에 올리라는 의미가 됨
	cin>>size;
	func(size);
}
// 컴파일시에 func에서 요구되는 메모리 공간의 크기를 
// 결정할 수 없음
// i 값은 입력에 따라 다르므로
// 컴파일시에 알수 없고 런타임시 알수 있음
// 즉 힙영역에 올라감
void func(int i)
{
	int array[i]; // 이렇게 일반적으로 선언하면
				  // stack에 올리라는 의미가 됨
				  // 그러나 지금과 같은 상황에서는 
				  // 스택에 올릴수 없다
				// 그래서 힙영역에 올리기 위해서
				// malloc, free 함수를 사용한다
				// malloc은 힙영역에 할당하기 위해 사용됨
				// free는 malloc으로 할당한 메모리를 해지
				// 하기 위해서 사용되는 함수
}
// end of ex




// =====================================================
// 7 자료형 bool
// =====================================================
// 자료형 bool : 기본 자료형
//				true(참), false(거짓) 중의 하나의 값을 지님
//				int 형으로 형 변환시 1 or 0이 됨

// 레퍼런스(reference)의 이해
// 이름을 지니는 대상에 별명을 붙여주는 행위
//
// 변수 : 메모리 공간에 붙은 이름
// 하나의 메모리 공간에 하나의 변수만 붙여줄수 있었지만
// c++에서는 하나의 메모리 공간에 둘이상의 변수를 붙여
// 줄수 있다. 이것이 레퍼런스의 기본 문법적 요소이다.

// & : c에서는 주소값을 얻기 위한 용도로 사용됨
//		c++에서는 레퍼런스 선언을 위한 용도로도 
//		사용될수 있음

// p를 포인터로 선언
int *p;
// p라는 포인터가 가리키는 값을 참조하겠다는 의미
*p;

// 레퍼런스 선언
int &p;
// p의 주소값을 반환하라는 의미
&p;

// int 형 변수를 참조할 수 있는
// ref를 레퍼런스로 선언하겠다.
// 즉 val가리키는 공간에 ref라는 이름을
// 하나 더 붙여라는 의미
int val = 10;
int &ref = val;

int *pVal = &val; // 주소값을 얻기 위해 & 연산자 사용
int &rVal = val; // 레퍼런스 선언을 위해 & 연산자 사용
				// val이 가리키는 값과 rVal이 가리키는 
				// 값은 같음

// b라는 이름을 가진 메모리에 c라는 이름도 부여해
// 한 메모리공간에 b, c의 이름을 가지게됨
char b;
char &c = b;