U E D R , A S I H C RSS

AcceleratedC++/Chapter10

1. Chapter 10 Managing memory and low-level data structures

μ§€κΈˆκΉŒμ§€λŠ” vector, stringλ“± STL이 기본적으둜 μ œκ³΅ν•˜λŠ” μžλ£Œκ΅¬μ‘°λΌ ν†΅ν•΄μ„œ ν”„λ‘œκ·Έλž˜λ°μ„ ν•˜μ˜€λ‹€.
이제 κ·Έ λ™μž‘μ›λ¦¬λΌ μ•Œμ•„λ³Ό μ°¨λ€μ΄λ‹€.
low-levelμ΄λΌλŠ” ν‘œν˜„μ€ 이런 λ‚΄μš©λ“€μ΄ STLκ΅¬ν˜„μ˜ 근간을 이루며, ν•˜λ“œμ›¨μ–΄μ˜ λ™μž‘ 방식과 맀우 ν‘μ‚¬ν•˜κΈ° λ•Œλ¬Έμ΄λ‹€.

1.1. 10.1 Pointers and arrays

λ°°μ—΄(array) vector와 μœ μ‚¬ν•˜μ§€λ§Œ vector만큼 νŽΈλ¦¬ν•˜μ§€λŠ” μ•Šλ‹€.
포인터(pointer) μž„μ˜ μ ‘κ·Ό λ°˜λ³΅μžλ‘œμ„œ, λ°°μ—΄μ˜ μš”μ†Œλ“€μ„ μ ‘κ·Όν•˜κΈ° μœ„ν•΄μ„œλŠ” ν•„μˆ˜, λ‹€λ₯Έ μš©λ„λ‘œλ„ 많이 μ΄μš©λœλ‹€.

1.1.1. 10.1.1 포인터

포인터(pointer) μ£Όμ†ŒλΌ λ‚˜νƒ€λ‚΄λŠ” κ°’
μ£Όμ†Œ μ—°μ‚°μž(address operator) 객체의 μ£Όμ†ŒλΌ λ¦¬ν„΄ν•œλ‹€.
μ—­μ°Έμ‘° μ—°μ‚°μž(dereference operator) 포인터 pκ°€ κ°€λ¦¬ν‚€λŠ” κ°μ²΄λΌ λ¦¬ν„΄ν•œλ‹€.
보톡 ν”„λ‘œκ·Έλž˜λ¨Έκ°€ ν¬μΈν„°λΌ μ΄ˆκΈ°ν™”μ‹œν‚€λŠ” κ°’μœΌλ‘œ μ΄μš©ν•˜λŠ” 값은 0이닀. 흔이 μ΄λΌ λ„ 포인터(null pointer)라고 λΆ€λ₯Έλ‹€.
포인터도 νƒ€μž…μ„ κ°–λŠ”λ° 일반적으둜 type-name * 으둜 μ •μ˜ν•œλ‹€.
~cpp  int *p;    // *pλŠ” int νƒ€μž…μ„ κ°–λŠ”λ‹€.
int* p;    // pλŠ” int*λΌλŠ” 것을 κ°•μ‘°ν•˜λŠ” ν‘œν˜„μ΄λ‹€. Cμ»΄νŒŒμΌλŸ¬λŠ” * μ£Όλ³€μ˜ 곡백을 λ¬΄μ‹œν•˜κΈ° λ•Œλ¬Έμ— μƒκΈ°μ˜ 2개 ν‘œν˜„μ€ μ™„μ „νžˆ λ™μΌν•˜λ‹€.
 

ν”Όν•΄μ•Όν•  μ •μ˜ 방식
~cpp  int* p, q;      // pλŠ” int* 인 포인터 ν˜•μ‹, qλŠ” int ν˜•μ„ 가리킨닀.
 

예제
~cpp 
//pointer_example.cpp
#include <iostream>

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

int main()
{
	int x = 5;

	// `p' points to `x'
	int* p = &x;
	cout << "x = " << x << endl;

	// change the value of `x' through `p'
	*p = 6;
	cout << "x = " << x << endl;
	return 0;
}
 

1.1.2. 10.1.2 ν•¨μˆ˜μ— λŒ€ν•œ 포인터

β€» ν•¨μˆ˜ν¬μΈν„°λΌ μ²˜μŒμœΌλ‘œ λ‹€λ£¨λŠ” μ‚¬λžŒμ€ 쑰금 μ–΄λ €μšΈ 지도 λͺ¨λ₯΄κ² μŠ΅λ‹ˆλ‹€. μ€ μ–΄λ ΅λ”λΌλ„ C, C++μ—μ„œ 많이 μ΄μš©λ˜λŠ” ν…Œν¬λ‹‰μ΄λ‹ˆ μ΅νžˆλŠ” 건 ν•„μˆ˜μ΄κ² μ§€μš”?

6.2.2 μ ˆμ—μ„œ λ‹€λ₯Έ ν•¨μˆ˜μ˜ 인자둜 ν•¨μˆ˜λΌ μ „λ‹¬ν•˜λŠ” 것을 λ³΄μ•˜λ‹€.
ν•¨μˆ˜μ— λŒ€ν•΄μ„œ μš°λ¦¬κ°€ ν•  수 μž‡λŠ” 것은 κ·Έ ν•¨μˆ˜μ˜ μ£Όμ†ŒλΌ μ·¨ν•˜κ±°λ‚˜, μ‹€ν–‰ν•˜λŠ” 것 λ°–μ—λŠ” μ—†λ‹€.
ν•¨μˆ˜μ— λŒ€ν•œ ν¬μΈν„°λΌ μΈμžλ‘œ μ „λ‹¬ν•˜κ³  μ—­μ°Έμ‘° μ—°μ‚°μžλΌ ν†΅ν•΄μ„œ κ·Έ 포인터에 μ ‘κ·Όν•˜λ©΄ μš°λ¦¬λŠ” μ›λž˜μ˜ ν•¨μˆ˜μ— μ ‘κ·Όν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
~cpp 
int (*fp)(int);
		
int next(int n)
{
	return n+1;
}
fp = &next;
fp = next;		// μƒκΈ°μ˜ 2가지 ν‘œν˜„ λͺ¨λ‘ nextν•¨μˆ˜μ˜ ν¬μΈν„°λΌ fp에 λŒ€μž…ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
		
int i = 0;
int n =1;
		
i = (*fp)(i);
i = fp(i); 		// λ§ˆμ°¬κ°€μ§€λ‘œ 이 2개의 ν‘œν˜„λͺ¨λ‘ μœ νš¨ν•œ ν‘œν˜„μ΄λœλ‹€. 
 
6.2.2μ ˆμ— μ‘΄μž¬ν•˜λŠ” write_ayalysis의 선언ꡬ문을 μ‚΄νŽ΄λ³΄λ„λ‘ ν•˜μž.
~cpp 
void write_analysis(std::ostream& out, const std::string& name,
                    double analysis(const std::vector<Student_info>&),
                    const std::vector<Student_info>& did,
                    const std::vector<Student_info>& didnt);		
 
μƒκΈ°μ—μ„œ 3번째 λ§€κ°œλ³€μˆ˜λΌ μ‚΄νŽ΄λ³΄λ„λ‘ ν•˜μž.
~cpp double analysis(const std::vector<Student_info>&)
 

C++은 상기와 같은 ν‘œν˜„μœΌλ‘œ λ§€κ°œλ³€μˆ˜λΌ μ§€μ •ν•˜λ”λΌλ„ μ΄λΌ μžλ™μœΌλ‘œ λ‹€μŒκ³Ό 같은 ν˜•μœΌλ‘œ μžλ™ ν˜• λ³€ν™˜μ‹œν‚¨λ‹€.
~cpp double (*analysis)(const std::vector<Student_info>&)
 
λ”°λΌμ„œ μš°λ¦¬κ°€ 일반적으둜 μ‚¬μš©ν•˜λŠ” ν•¨μˆ˜μ˜ ν‘œν˜„λ§ŒμœΌλ‘œλ„ λ§€κ°œλ³€μˆ˜λ‘œ ν•¨μˆ˜λΌ μ „λ‹¬μ‹œν‚€λŠ” 것이 κ°€λŠ₯ν•œ 것이닀.
ν•˜μ§€λ§Œ μ΄λŸ¬ν•œ μžλ™ ν˜• λ³€ν™˜μ€ ν•¨μˆ˜μ˜ λ¦¬ν„΄ν˜•μ—λŠ” μ μš©λ˜μ§€ μ•ŠλŠ”λ‹€. λ”°λΌμ„œ ν•¨μˆ˜λΌ λ¦¬ν„΄ν•˜λŠ” κ²½μš°μ—λŠ” λͺ…μ‹μ μœΌλ‘œ ν¬μΈν„°μž„μ„ λ‚˜νƒ€λ‚΄μ•Όν•  ν•„μš”κ°€ μžˆλ‹€.
~cpp 
//μ˜¬λ°”λ₯Έ ν‘œν˜„
typedef double (*analysis_fp)(const vector<Student_info>&);
analysis_fp get_analysis_ptr();		// 이와 같이 μ΄μš©ν•˜λŠ” 것이 κ°€λŠ₯ν•©λ‹ˆλ‹€.
 
//μ˜¬λ°”λ₯΄μ§€ μ•Šμ€ ν‘œν˜„
double (*get_analysis_ptr()) (const vector<Student_info>&);
 
μƒκΈ°μ˜ μ½”λ“œμ—μ„œ ν”„λ‘œκ·Έλž˜λ¨Έκ°€ μ›ν•œ κΈ°λŠ₯은 get_analysis_ptr()을 ν˜ΈμΆœν•˜λ©΄ κ·Έ κ²°κ³ΌλΌ μ—­μ°Έμ‘°ν•˜μ—¬μ„œ const vector<Student_info>&λΌ μΈμžλ‘œ κ°–κ³  double ν˜•μ„ λ¦¬ν„΄ν•˜λŠ” ν•¨μˆ˜λΌ μ–»λŠ” κ²ƒμž…λ‹ˆλ‹€.
κ·Έλ ‡μ§€λ§Œ μ–Έλœ»λ³΄κΈ°μ—λ„ μ½”λ“œκ°€ 2번째의 경우 μ½”λ“œκ°€ μƒλ‹Ήνžˆ λ³΅μž‘ν•˜λ‹€λŠ” 것을 μ•Œ 수 μž‡μŠ΅λ‹ˆλ‹€.
μ΄λŸ°μ‹μ˜ 문법은 많이 μ‚¬μš©λ˜μ§€λŠ” μ•ŠμŠ΅λ‹ˆλ‹€. (Addition 1μ—μ„œ μ„λͺ…ν•©λ‹ˆλ‹€.)
ν•¨μˆ˜ ν¬μΈν„°λŠ” ν”νžˆ λ‹€λ₯Έ ν•¨μˆ˜μ˜ 인자둜 μ΄μš©λœλ‹€.
~cpp 
template<class In, class Pred>
In find_if(In begin, In end, Pred f) {
	while (begin != end && if f(*begin))		//μ—¬κΈ°μ„œ PredλŠ” Pred(*begin)이 의λΈλΌ κ°–λŠ” λͺ¨λ“  νƒ€μž…μ΄ κ°€μš©ν•©λ‹ˆλ‹€.
		++begin;
	return begin;
}

bool is_negative(int n) {
	return n<0;
}

vector<int>::iterator i = find_if(v.begin(), v.end(), is_negative);		// &is_negative λΌ μ‚¬μš©ν•˜μ§€ μ•ŠλŠ” μ΄μœ λŠ” μžλ™ν˜•λ³€ν™˜μœΌλ‘œ ν¬μΈν„°ν˜•μœΌλ‘œ λ³€ν™˜λ˜κΈ° λ•Œλ¬Έμž„. 
 

1.1.3. 10.1.3 λ°°μ—΄

λ°°μ—΄(Array)
ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬κ°€ μ•„λ‹Œ κΈ°λ³Έμ–Έμ–΄μ˜ μΌλΆ€λ‘œμ„œ ν•˜λ‚˜ μ΄μƒμ˜ 같은 νƒ€μž…μ˜ κ°μ²΄λ“€λ‘œ 이루어진 μ‹œν€€μŠ€μž…λ‹ˆλ‹€. 단 λ°°μ—΄ μš”μ†Œμ˜ κ°μˆ˜λŠ” 컴파일 μ‹œμ— μ•Œ 수 μžˆμ–΄μ•Όν•©λ‹ˆλ‹€.
β€» C99 ν‘œμ€μ—μ„œλŠ” λ³€μˆ˜λ‘œ ν¬κΈ°λΌ λ°›μ•„μ„œ λ™μ μœΌλ‘œ ν• λ‹Ήν•˜λŠ” 일이 κ°€λŠ₯ν•©λ‹ˆλ‹€.
배열은 클래슀 νƒ€μž…μ΄ μ•„λ‹ˆκΈ° λ•Œλ¬Έμ— λ°°μ—΄μ˜ ν¬κΈ°λΌ λ‚˜νƒ€λ‚΄λŠ” size_typeκ³Ό 같은 μš”μ†ŒλŠ” μ—†μŠ΅λ‹ˆλ‹€. λŒ€μ‹ μ— C Standard Definition μ΄ν•˜ <cstddef> 에 size_t둜 μ§€μ •λœ unsigned νƒ€μž…μœΌλ‘œ λ°°μ—΄μ˜ ν¬κΈ°λΌ μ‚¬μš©ν•΄μ•Όν•©λ‹ˆλ‹€.
~cpp 
const size_t NDim = 3;
const size_t PTriangle = 3;
double coords[NDim];
double coords1[PTriangle];
 
상기와 같은 ν‘œν˜„μ€ const둜 μ§€μ •λœ λ³€μˆ˜λ‘œ λ³€μˆ˜λΌ μ΄ˆκΈ°ν™”ν•˜κΈ° λ•Œλ¬Έμ— μ»΄νŒŒμΌμ‹œμ— κ·Έ ν¬κΈ°λΌ μ•Œ 수 μžˆλ‹€. λ˜ν•œ 상기와 같은 λ°©μ‹μœΌλ‘œ 코딩을 ν•˜λ©΄ coord에 의λΈλΌ λΆ€μ—¬ν•  수 μž‡κΈ° λ•Œλ¬Έμ— μž₯점이 μ‘΄μž¬ν•œλ‹€.
λ˜ν•œ λ°°μ—΄μ˜ 이름은 κ·Έ λ°°μ—΄μ˜ μš”μ†Œμ˜ 첫번째 μš”μ†ŒλΌ κ°€λ¦¬ν‚€λŠ” ν¬μΈν„°ν˜•μœΌλ‘œ μ΄ˆκΈ°ν™” 되기 λ•Œλ¬Έμ— λ°°μ—΄κ³Ό ν¬μΈν„°λŠ” λ°€μ ‘ν•œ 상관 κ΄€κ³„λΌ κ°–κ³  μž‡λ‹€.
~cpp 
*coord = 1.5;			//coord λ°°μ—΄μ˜ 첫번째 μš”μ†ŒλΌ 1.5둜 ν• λ‹Ήν•œλ‹€. 즉, coord[1] = 1.5; 와 λ™μΌν•œ ν‘œν˜„μ΄ λœλ‹€. 
 

1.1.4. 10.1.4 포인터 μ‚°μˆ  μ—°μ‚°

포인터도 μΌμ’…μ˜ λ°˜λ³΅μžμ΄λ‹€. μ΄μ‚¬μ‹€μ—μ„œ λ°°μ—΄μ˜ ν¬μΈν„°λΌ μ΄μš©ν•œ 접근을 생각해볼 수 μž‡λ‹€.
coordκ°€ coord의 0번째 μš”μ†ŒλΌ κ°€λ₯΄ν‚€λ€λ‘œ
coord+1 1번째 μš”μ†Œ
coord+2 2번째 μš”μ†Œ
coord+3 3번째 μš”μ†Œ. λ°°μ—΄μ—μ„œλŠ” μœ νš¨ν•˜μ§€ μ•Šμ§€λ§Œ 포인터 κ·Έ μžμ²΄λ‘œλŠ” μœ νš¨ν•œ 포인터이닀.
coord+4 μœ νš¨ν•˜μ§€ μ•Šμ€ 포인터
coord-1 -1번째 μš”μ†Œ. λ°°μ—΄μ—μ„œλŠ” μœ νš¨ν•˜μ§€ μ•Šμ§€λ§Œ 포인터 κ·Έ μžμ²΄λ‘œλŠ” μœ νš¨ν•œ 포인터이닀.

~cpp 
vector<double> v;
copy(coords, coords + NDim, back_inserter(v)); 
 
coord+NDim 은 coord의 λ§ˆμ§€λ§‰ μš”μ†Œμ—μ„œ 1κ°œκ°€ 더 μ§€λ‚œ 값을 가리킀λ€λ‘œ μƒκΈ°μ˜ ν‘œν˜„μ€ μœ νš¨ν•œ ν‘œν˜„μ‹μ΄λ‹€.
p, qκ°€ 같은 λ°°μ—΄μ˜ μš”μ†Œλ“€μ˜ 포인터라면, p-qλŠ” p와 q사이에 μžˆλŠ” μš”μ†Œλ“€μ˜ κ±°λ¦¬λΌ λ‚˜νƒ€λ‚΄λŠ” μ •μˆ˜κ°€ λœλ‹€.
κ·ΈλŸ¬λ‚˜ 이 μ°¨μ΄λΌ λ‚˜νƒ€λ‚΄λŠ” 값은 κ΅¬ν˜„ μ‹œμŠ€ν…œ λ§ˆλ‹€ λ‹€λΌ μˆ˜ μž‡κ³ , μŒμˆ˜κ°€ λ‚˜νƒ€λ‚΄λŠ” κ²½μš°κ°€ 있기 λ•Œλ¬Έμ— <cstddef>μ—λŠ” ptrdiff_tλΌλŠ” 약칭을 ν†΅ν•΄μ„œ κ·Έ 데이터 ν˜•μ„ μ œκ³΅ν•œλ‹€.
aκ°€ n개 μš”μ†Œμ˜ 배열이라면, a+iκ°€ μœ νš¨ν•˜κΈ° μœ„ν•΄μ„œλŠ” 0<=i<=n, a+iκ°€ a의 μš”μ†Œλ₯Ό 가리킀기 μœ„ν•œ ν•„μš” μΆ©λΆ„ 쑰건은, 0<=i

1.1.5. 10.1.5 인덱싱(Indexing)

ν¬μΈν„°λŠ” μž„μ˜ μ ‘κ·Ό λ°˜λ³΅μžμ΄λ‹€. λ”°λΌμ„œ vector와 같이 μž„μ˜ 접근이 λœλ‹€.
λ§Œμ•½ pκ°€ μš”μ†Œμ˜ m번째 μš”μ†ŒλΌ κ°€λ¦¬ν‚¨λ‹€λ©΄ pn은 m+n번째 μš”μ†ŒλΌ κ°€λ¦¬ν‚¨λ‹€. (μš”μ†Œμ˜ μ£Όμ†Œκ°€ μ•„λ‹ˆλΌ μš”μ†ŒλΌ κ°€λ¦¬ν‚¨λ‹€.)

1.1.6. 10.1.6 λ°°μ—΄ μ΄ˆκΈ°ν™”

STL의 μ»¨ν…Œμ΄λ„ˆλ“€κ³ΌλŠ” 달리 배열은 μ΄ˆκΈ°ν™”μ— μžˆμ–΄μ„œ λ‹€λ₯Έ 문법을 μ œκ³΅ν•œλ‹€.
이 문법을 μ‚¬μš©ν•¨μœΌλ‘œμ¨ λ°°μ—΄μ˜ μ΄ˆκΈ°ν™”μ‹œμ— μ‚¬μš©μžκ°€ λͺ…μ‹œμ μœΌλ‘œ λ°°μ—΄μ˜ ν¬κΈ°λΌ λ‚˜νƒ€λ‚΄μ§€ μ•Šμ•„λ„ λœλ‹€.

~cpp 
const int month_length[] = {
	31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};		// μœ€λ…„μ€ λ¬΄μ‹œ 
 
μƒκΈ°μ˜ μ˜ˆμ œμ—μ„œ month_length의 λ°°μ—΄μ˜ ν¬κΈ°λΌ λͺ…μ‹œμ μœΌλ‘œ λ‚˜νƒ€λ‚΄μ§€ μ•Šμ•˜λ‹€λŠ” 사싀에 유의. λŒ€μ‹ μ— μ»΄νŒŒμΌλŸ¬κ°€ μ΄ˆκΈ°ν™”λœ κ°μˆ˜μ— λ§žμΆ”μ–΄μ„œ 배열을 ν• λ‹Ήν•œλ‹€.

1.2. 10.2 String literals revisited

"hello"와 같은 λ¬Έμžμ—΄ λ¦¬ν„°λŸ΄μ€ 사싀은 const charν˜•μ˜ 배열이닀. 이 배열은 μ‹€μ œλ‘œ μ‚¬μš©ν•˜λŠ” 문자의 κ°μˆ˜λ³΄λ‹€ ν•œκ°œκ°€ 더 λ§Žμ€ μš”μ†ŒλΌ ν¬ν•¨ν•˜λŠ”λ°, μ΄λŠ” λ¬Έμžμ—΄ λ¦¬ν„°λŸ΄μ˜ 끝을 λ‚˜νƒ€λ‚΄λŠ” '\0' 즉 널 μΊλ¦­ν„°λΌ λ„£μ–΄μ•Όν•˜κΈ° λ•Œλ¬Έμ΄λ‹€.
~cpp 
		const char hello[] = { 'h', 'e', 'l', 'l', 'o', '\0' };		//이 ν‘œν˜„μ€ const char hello[] = "hello";와 λ™μΌν•œ ν‘œν˜„μ΄λ‹€. 
 
<cstring> strlen
~cpp 
size_t strlen(const char* p) {		// μ‰¬μš°λ‹ˆ 기타 μ„λͺ…은 μƒλž΅ 
	size_t size = 0;
	while (*p++ != '\0')
		++size;
	return size;
}
 
μƒκΈ°μ˜ λ‚΄μš©μ„ λ°”νƒ•μœΌλ‘œ stringμ—μ„œ μš°λ¦¬λŠ” λ‹€μŒκ³Ό 같은 μ΄ˆκΈ°ν™”λΌ ν–‰ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
~cpp 
string s(hello);
string s("hello");
string s(hello, hello+strlen(hello));
 
μƒκΈ°μ˜ 3가지 ν‘œν˜„μ€ λͺ¨λ‘ κ°™λ‹€.

1.3. 10.3 Initializing arrays of character pointers

~cpp 
//letter_grade.cpp
#include <cstddef>
#include <string>

using std::string;

string letter_grade(double grade)
{
	// range posts for numeric grades
	static const double numbers[] = {
		97, 94, 90, 87, 84, 80, 77, 74, 70, 60, 0
	};

	// names for the letter grades
	static const char* const letters[] = {
		"A+", "A", "A-", "B+", "B", "B-", "C+", "C", "C-", "D", "F"
	};

	// compute the number of grades given the size of the array
	// and the size of a single element
	static const size_t ngrades = sizeof(numbers)/sizeof(*numbers);

	// given a numeric grade, find and return the associated letter grade
	for (size_t i = 0; i < ngrades; ++i) {
		if (grade >= numbers[i])
			return letters[i];
	}

	return "?\?\?";
}
static ν‚€μ›Œλ“œλΌ μ‚¬μš©ν•˜μ—¬μ„œ λ°°μ—΄μ˜ μ΄ˆκΈ°ν™”μ— μ†Œμš”λ˜λŠ” μ‹œκ°„μ„ λ‹¨μΆ•ν•œλ‹€.
μš”μ†Œ 배열은 λ³€ν™”ν•˜μ§€ μ•ŠλŠ 값이λ€λ‘œ const ν‚€μ›Œλ“œ 이용
array_pointer / sizeof(*array_pointer) λΌ μ΄μš©ν•˜λ©΄ arrayκ°€ 가지고 μžˆλŠ” μš”μ†Œμ˜ κ°μˆ˜λΌ μ•Œ 수 μžˆλ‹€. μžμ£Όμ“°λŠ” ν‘œν˜„μ΄λ€λ‘œ 잘 μ΅νžŒλ‹€.

1.4. 10.4 Arguments to main

λŒ€λΆ€λΆ„μ˜ μš΄μ˜μ²΄μ œλŠ” ν”„λ‘œκ·Έλž¨μ΄ μ‹€ν–‰λ λ•Œ μΈμžλ‘œμ„œ λ¬Έμžμ—΄μ„ μ£ΌλŠ” 것이 κ°€λŠ₯ν•˜λ‹€. 이것은 mainν•¨μˆ˜κ°€ int, char** 의 2κ°€μ§€μ˜ μΈμžλΌ κ°€μ§€κΈ° λ•Œλ¬Έμ΄λ‹€.
~cpp 
#include <iostream>

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

int main(int argc, char** argv)
{
	// if there are command-line arguments, write them
	if (argc > 1) {
		cout << argv[1];               // write the first argument

		// write each remaining argument with a space before it
		for (int i = 2; i != argc; ++i)
			cout << " " << argv[i];    // `argv[i]' is a `char*'
	}
	cout << endl;
	return 0;
}
char**λŠ” (char*)λΌ μš”μ†Œλ‘œ κ°–λŠ” 배열이라고 μƒκ°ν•˜λ©΄ λœλ‹€. 즉 λ¬Έμžμ—΄ λ¦¬ν„°λŸ΄μ„ μš”μ†Œλ‘œ κ°–λŠ” 배열이닀.
κΈ°νƒ€μ˜ λ‚΄μš©μ€ κ°„λ‹¨ν•˜λ€λ‘œ μƒλž΅.

1.5. 10.5 Reading and writing files

1.5.1. 10.5.1 ν‘œμ€ μ—λŸ¬ 슀트림

C++μ—μ„œλŠ” 일반적인 ν‘œμ€ μΆœλ ₯ 슀트림 λΏλ§Œμ•„λ‹ˆλΌ ν‘œμ€ μ—λŸ¬ μŠ€νŠΈλ¦Όμ„ ν†΅ν•΄μ„œ ν”„λ‘œκ·Έλž¨μ˜ μ£Όμ„μ˜ λ‚΄μš©λ“€. 즉 ν”„λ‘œκ·Έλž¨μ΄ μ‹€ν–‰λ˜λŠ” λ™μ•ˆμ˜ μƒνƒœμ •λ³΄λΌ μΆœλ ₯ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
λŒ€λΆ€λΆ„μ˜ μš΄μ˜μ²΄μ œμ—μ„œλŠ” 이런 2κ°€μ§€μ˜ 좜λ ₯을 λΆ„λ¦¬ν•˜μ—¬ μ²˜λ¦¬ν•˜λŠ” 방법을 μ œκ³΅ν•œλ‹€.
cerr 버퍼링을 μ‚¬μš©ν•˜μ§€ μ•Šκ³ , 즉각적인 좜λ ₯을 ν•œλ‹€. μ˜€λ²„ν—€λ“œκ°€ 크닀.
clog 버퍼링을 μ΄μš©ν•˜κ³ , μ λ‹Ήν•œ μ‹œκΈ°μ— 좜λ ₯ν•œλ‹€.
β€» 좜λ ₯ 버퍼링에 κ΄€ν•œ λ‚΄μš©μ€ μžμ„Έν•˜κ²Œ λ‚˜μ˜¨ 책이 많으λ€λ‘œ μ°Έκ³ ν•˜λ©΄ 쒋을 λ“. Cμ±…μ΄κΈ°λŠ” ν•˜μ§€λ§Œ 터보 C 정볡을 보면 좜λ ₯ 슀트림의 버퍼링에 κ΄€ν•œ μžμ„Έν•œ μ„λͺ…이 μžˆλ‹€.

1.5.2. 10.5.2 μ—¬λŸ¬ μž…λ ₯ 파일과 좜λ ₯ 파일 닀루기

파일의 μž…μΆœλ ₯을 μœ„ν•΄μ„œ iostream을 파일 μž…μΆœλ ₯에 λ§žλ„λ‘ μƒμ†μ‹œν‚¨ ofstream, ifstream객체듀을 μ΄μš©ν•œλ‹€. 이듀 ν΄λž˜μŠ€λŠ” <fstream>에 μ •μ˜ λ˜μ–΄μžˆλ‹€.
<fstream>μ—μ„œ μ‚¬μš©ν•˜λŠ” 파일 이름은 char* ν˜•μ΄λ©°, string νƒ€μž…μ΄ μ•„λ‹ˆλ‹€. μ΄λŠ” fstream library κ°€ λ§Œλ“€μ–΄μ§„ μ‹œκΈ°κ°€ STL이 λ§Œλ“€μ–΄μ§„ μ‹œκΈ° 보닀 μ•žμ„œκΈ° λ•Œλ¬Έμ΄λ‹€.
~cpp 
//copy_file.cpp
#include <fstream>
#include <string>

using std::endl;
using std::getline;
using std::ifstream;
using std::ofstream;
using std::string;

int main()
{
	ifstream infile("in");
	ofstream outfile("out");

	string s;

	while (getline(infile, s))
		outfile << s << endl;
	return 0;
}
 
λ§Œμ•½ 파일의 μ΄λ¦„μœΌλ‘œ string ν˜•μ„ μ΄μš©ν•˜κ³  μ‹Άλ‹€λ©΄ stringν˜•μ˜ λ©€λ²„ν•¨μˆ˜μΈ c_str() 을 μ΄μš©ν•΄μ„œ μ‚¬μš©ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
~cpp 
string file("out");
ifstream infile(file.c_str());
 
~cpp 
//concat_files.cpp
#include <iostream>
#include <fstream>
#include <string>

using std::cerr;
using std::cout;
using std::endl;
using std::getline;
using std::ifstream;
using std::string;

int main(int argc, char **argv)
{
	int fail_count = 0;
	// for each file in the input list
	for (int i = 1; i < argc; ++i) {
		ifstream in(argv[i]);

		// if it exists, write its contents, otherwise generate an error message
		if (in) {
			string s;
			while (getline(in, s))
				cout << s << endl;
		} else {
			cerr << "cannot open file " << argv[i] << endl;
			++fail_count;
		}
	}
	return fail_count;
}
 
λ‹¨μˆœν•œ ν”„λ‘œκ·Έλž¨μ΄λ€λ‘œ μ„λͺ…은 μƒλž΅ν•¨. ν•œλ²ˆ 쳐보자.

1.6. 10.6 Three kinds of memory management

~cpp 
int* invalid_pointer() {
	int x;
	return &x;		//ν•¨μˆ˜μ˜ μ’…λ£Œμ™€ ν•¨κ»˜ xκ°€ ν•΄μ œλ˜λ€λ‘œ λ¦¬ν„΄λ˜λŠ” 값은 λ¬΄νš¨ν•œ λ©”λͺ¨λ¦¬μƒμ˜ 곡간을 가리킨닀. 
}

~cpp 
int* pointer_to_static() {
	static int x;
	return &x;		//μœ νš¨ν•˜λ‹€. static 으둜 ν•¨μˆ˜ μ•ˆμ—μ„œ μ„ μ–Έν•˜λ©΄ ν•¨μˆ˜κ°€ 처음 μ‹€ν–‰λ λ•Œ λ©”λͺ¨λ¦¬ 곡간이 ν•œλ²ˆ ν• λ‹Ήλ˜κ³  κ·Έ 함

μˆ˜κ°€ μ’…λ£Œλ˜λ”λΌλ„ ν•΄μ œλ˜μ§€ μ•Šκ³  ν”„λ‘œκ·Έλž¨μ΄ μ’…λ£Œλ λ•Œ ν•΄μ œλœλ‹€.  λ”°λΌμ„œ λ©”λͺ¨λ¦¬κ°€ ν•΄μ œλ˜μ§€ μ•Šμ€ static λ³€μˆ˜λΌ λ¦¬ν„΄ν•˜λŠ” 것이기에 μœ νš¨ν•˜λ‹€.
}
μžλ™λ©”λͺ¨λ¦¬ 관리 μ§€μ—­λ³€μˆ˜, μ§€μ—­λ³€μˆ˜λΌ μ°Έμ‘°ν˜•, ν¬μΈν„°ν˜•μœΌλ‘œ λ¦¬ν„΄ν•˜λ©΄ κ·Έ 리턴값은 λ¬΄νš¨ν•œ κ°’μ΄λœλ‹€.
μ‚¬μš©ν•˜κ³  μ‹Άλ‹€λ©΄ static ν‚€μ›Œλ“œλΌ μ΄μš©ν•΄μ•Όν•œλ‹€.
정적메λͺ¨λ¦¬ ν• λ‹Ή 정적 λ³€μˆ˜κ°€ μ‘΄μž¬ν•˜λŠ” 블둝이 처음 μ‹€ν–‰λ˜λŠ” λ™μ•ˆ ν• λ‹Ήλ˜μ–΄ ν”„λ‘œκ·Έλž¨μ΄ μ‹€ν–‰λ˜λŠ” λ™μ•ˆ 계속 μœ νš¨ν•œ μƒνƒœλ‘œ λ‚¨λŠ”λ‹€.
동적메λͺ¨λ¦¬ ν• λ‹Ή new, delete ν‚€μ›Œλ“œλΌ μ΄μš©ν•΄μ„œ ν”„λ‘œκ·Έλž˜λ¨Έκ°€ μ›ν•˜λŠ” μ‹œκΈ°μ— λ©”λͺ¨λ¦¬μƒμ— ν• λ‹Ήν•˜κ³  ν•΄μ œλΌ ν•  수 μžˆλ‹€.

1.6.1. 10.6.1 객체 ν• λ‹Ή 및 ν•΄μ œ

객체의 νƒ€μž…μ„ T라고 κ°€μž₯ν•˜κ³ , λ©”λͺ¨λ¦¬ 상에 λ™μ μœΌλ‘œ ν• λ‹Ήν•˜κΈ° μœ„ν•΄μ„œλŠ”
~cpp 
new T(args)
 
와 같은 ν‘œν˜„μ„ μ΄μš©ν•˜λ©΄ λœλ‹€.
μ΄λ ‡κ²Œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬ 곡간은 ν”„λ‘œκ·Έλž˜λ¨Έκ°€ λ°˜λ“œμ‹œ ν•΄μ œν•΄μ•Όν•  μ±…μž„μ„ κ°–λŠ”λ‹€.

1.6.2. 10.6.2 λ°°μ—΄ ν• λ‹Ή 및 ν•΄μ œ

객체의 νƒ€μž…μ„ T, κ°μˆ˜λΌ μŒμ΄μ•„λ‹Œ μ •μˆ˜ n이라 κ°€μž₯ν•˜κ³ , λ©”λͺ¨λ¦¬ 상에 λ™μ μœΌλ‘œ ν• λ‹Ήν•˜κΈ° μœ„ν•΄μ„œλŠ”
~cpp 
new T[n]
 
와 같은 ν‘œν˜„μ„ μ΄μš©ν•˜λ©΄ λœλ‹€.
μ΄λ ‡κ²Œ λ°°μ—΄λ‘œ ν• λ‹Ήλ˜μ—ˆμ„λ•Œ λ¦¬ν„΄λ˜λŠ” 값은 T* ν˜•μœΌλ‘œ κ·Έ λ°°μ—΄μ˜ 첫번째 μš”μ†Œμ˜ 포인터가 λœλ‹€.
λ°°μ—΄μ˜ μš”μ†ŒλŠ” λ””ν΄νŠΈ μƒμ„±μžλ‘œ μ΄ˆκΈ°ν™”λœλ‹€.
μ΄λ ‡κ²Œ μƒμ„±λœ λ°°μ—΄μ˜ μš”μ†ŒλŠ” delete[] ν‚€μ›Œλ“œλ‘œ ν•΄μ œκ°€ κ°€λŠ₯ν•˜λ‹€.
~cpp 
char* duplicate_chars(const char* p) {
	size_t length = strlen(p) + 1;
	char* result = new char[length];
	
	copy(p, p+length, result);
	return result; 
 
κ°„λ‹¨ν•œ μ†ŒμŠ€μ΄λ€λ‘œ μ„λͺ…μƒλž΅

Valid XHTML 1.0! Valid CSS! powered by MoniWiki
last modified 2021-02-07 05:22:24
Processing time 0.0550 sec