C언어

c++ 공부 요점정리 13

뮹실이 2013. 11. 23. 00:08 








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

// =====================================================
// 28 클래스와 const
// =====================================================
//
const double PI = 3.14;
PI = 3.1315; // 컴파일 오류


//
// 포인터 선언시 데이터 상수화
//
// pN이 가리키는 대상을 상수화
// pN이라는 포인터를 통해 접근할 경우에만
// 값의 변경을 허용하지 않음
//
int n = 10;
const int* pN = &n;
n = 30;
*pN = 20; // 커파일 오류


//
// 포인터 선언시 포인터 상수화
//
// pN이라는 포인터 자체를 상수화한다
// pN은 n1만 가리켜야한다
// 가리키는 대상을 바꿔 다른 대상을 가리키지 못한다.
//
int n1 = 10;
int n2 = 20;
int* const pN = &n1;
*pN = 20;
pN = &n2; // 컴파일 오류

//
// 멤버 변수의 상수화, 그리고 초기화의 예제
//
// class의 객체를 생성시 1. 메모리를 항당하고
// (메모리의 값들은 쓰레기 값으로 채워져있다.)
// 2. 생성자에 의해 초기화된다.
//
class Student
{
	// 메모리 할당시 쓰레기 값으로 채워져있는데
	// const 로 선언하면 나중에 생성자가 
	// 값을 변경하지 못하므로 에러 발생
	// 그럼 클래스에서는 const를 사용하지 못하느냐
	// 그래서 등장한 문법적 요소가 
	// 멤버 이니셜라이저(member initializer)
	// 생성자의 선언부와 몸체부 사이에
	// :id(_id) 라고 선언해주면
	// 멤버 변수 id에 전달 인자 _id의 값을 대입한다
	// :id(_id) 이 부분은 생성자가 호출되기 이전에 
	// (생성자의 몸체부분이 실행되기 이전에)
	// 완료가 된다.
	// 즉 const 멤버 변수를 초기화 시켜주기위한
	// 예외적인 문법
	const int id; 
	int age;
	char name[20];
	char major[30];
public:
	Student(int _id, int _age, char* _name, char* _major)
	{
		id=_id;
		age=_age;
		strcpy(name, _name);
		strcpy(major, _major);
	}
};
// Student(int _id, int _age, char* _name, char* _major)는
// 생성자의 선언부이고
// {}의 내용은 생성자의 몸체부이다.


//
// const 멤버 함수
//
// 멤버 함수가 상수화 되면 그 멤버 함수가 속해있는
// 클래스의 멤버 변수 값 변경을 허용하지 않는다.
// 멤버 변수 값의 변경에 대한 기회제공도 불가능하다
//
// 예제 1
//
class Student
{
	const int id;
	int age;
	char name[20];
	char major[30];
public:
	Student(int _id, int _age, char* _name, char* _major):id(_id), age(_age)
	{
		strcpy(name, _name);
		strcpy(major, _major);
	}

	// showdata라는 함수를 상수화
	// 함수 몸체부분과 함수 선언부 사이에
	// const를 선언한다.
	// 멤버변수 변경이 불가능하다
	// 변경시 컴파일 에러 발생
	// 여기서는 멤버변수를 변경하지 않고
	// 출력하기 위해서 참조만 하고 있다
	void ShowData() const
	{
		cout<<"이름: "<<name<<endl;
		cout<<"나이: "<<age<<endl;
		cout<<"학번: "<<id<<endl;
		cout<<"학과: "<<major<<endl;
	}
};


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

class Count
{
	int cnt;
public :
	Count() : cnt(0){}
	
	// 멤버 함수가 상수화되면
	// 멤버 변수의 직접적인 조작만 불가능한것이 아니라
	// 멤버 변수를 조작할 수 있는 기회제공도 허용이 안된다
	// cnt 값을 직접적으로 조작하고 있지는 않지만
	// 멤버 변수의 포인터를 리턴해주고있다.
	// cnt 포인터를 통해 값을 변경할 수 있기때문에
	// 멤버변수를 조작할 기회를 제공하는 것이다.
	// 그래서 컴파일 에러가 발생한다.
	// 이런 경우에는 const 키워드를 빼는게 아니라
	// 멤버 변수의 포인터를 리턴하되
	// 리턴하는 포인터의 데이터를 상수화시켜
	// 리턴하는 포인터를 이용해서는
	// 멤버변수를 변경할 수 없고 참조만 가능하도록 한다.
	int* GetPtr() const{
		return &cnt;  // Compile Error
	}
	// 위 함수를 다음 함수로 수정하면
	// 컴파일에러가 발생하지 않는다.
	const int* GetPtr() const{
		return &cnt;
	}

	void Increment(){
		cnt++;
	}

	// 컴파일시 컴파일러가 인식하는 방법은
	// showdata는 상수화된 함수이다.
	// 그래서 함수내에서 멤버 변수를 조작하는지 검사하는데
	// showintro를 호출하네
	// showintro는 상수화 되지 않은 함수이다.
	// showintro로 가서 멤버 변수를 조작하는지 검사하는게 아니라
	// showintro가 상수화된 함수인지 아닌지 검사
	// 만약 showintro가 상수화된 함수이면 멤버 변수 조작을
	// 하지 않는게 확실하지만
	// 상수화된 함수가 아니면 멤버 변수를 조작할 
	// 가능성이 있기 때문에 컴파일 에러가 발생한다.
	// 컴파일 에러 해결 방법은 
	// showintro 함수가 멤버 변수 조작을 하지 않는 함수이므로
	// 함수를 상수화 시켜 멤버변수 조작의 가능성을 
	// 제거 하면 컴파일 에러가 발생하지 않는다.
	void ShowData() const {
		ShowIntro();  // Compile Error
		cout<<cnt<<endl;		
	}
	void ShowIntro() {
		cout<<"현재 count의 값 : "<<endl;
	}
};

int main()
{
	Count count;
	count.Increment();
	count.ShowData();

	return 0;
}










저작자표시 비영리 변경금지 (새창열림)