U E D R , A S I H C RSS

AcceleratedC++/Chapter11

1. Chapter 11 Defining abstract data types

3μž₯μ—μ„œ μž‘μ„±ν•œ Student_info νƒ€μž…μ€ 볡사, λŒ€μž…, μ†Œλ©Έμ‹œμ— μ–΄λ–€ 일이 μˆ˜ν–‰λ˜λŠ”μ§€ λͺ…μ„Έλ˜μ–΄μžˆμ§€ μ•ŠμŒ.
μ‹€μ œλ‘œ ν΄λž˜μŠ€λΌ μ œμž‘ν•  κ²½μš°μ—λŠ” 클래슀의 생성, 볡사, λŒ€μž…, μ†Œλ©Έμ˜ κ³ λ €ν•˜μ—¬ μ„κ³„λ˜μ–΄μ•Όν•œλ‹€.
이μž₯μ—μ„œλŠ” STL vector클래슀의 약식 버전을 λ§Œλ“€μ–΄ λ³΄λ©΄μ„œ 일반적인 ν˜•νƒœμ˜ μžλ£Œν˜•μ„ λ§Œλ“œλŠ” 방식을 μ΅νžŒλ‹€.

1.1. 11.1 The Vec class

ν΄λž˜μŠ€λΌ μ„κ³„ν• λ•Œμ—λŠ” μš°μ„  μΈν„°νŽ˜μ΄μŠ€λΌ κ²°μ •ν•΄μ•Όν•œλ‹€. μΈν„°νŽ˜μ΄μŠ€μ˜ κ²°μ •μ—λŠ” μ‹€μ œλ‘œ κ·Έ κ°μ²΄λΌ μ΄μš©ν•œ ν”„λ‘œκ·Έλž¨μ„ μž‘μ„±ν•΄λ³΄λŠ” 것이 μ’‹λ‹€.
~cpp 
//vector 생성
vector<Student_info> vs;
vector<double> v(100);

//vectorκ°€ μ‚¬μš©ν•˜λŠ” νƒ€μž…μ˜ 이λ₯΄μ„ μ–»λŠ”λ‹€.
vector<Student_info>::const_iterator b, e;
vector<Student_info>::size_type i = 0;

//vector의 κ°μš”μ†ŒλΌ μ‚΄νŽ΄λ³΄κΈ° μœ„ν•΄, size 및 index μ—°μ‚°μžλΌ μ‚¬μš©
for(i = 0; i != vs.size(); ++1)
	cout<<vs[i].name();

//첫번재 μš”μ†Œμ™€ λ§ˆμ§€λ§‰ μš”μ†Œμ— λŒ€ν•œ 반볡자 리턴
b=vs.begin();
e=vs.end();
μ΄μƒμ˜ 것듀이 이μž₯μ—μ„œ κ΅¬ν˜„ν•  vector 의 clone 버전인 Vec ν΄λž˜μŠ€λΌ κ΅¬ν˜„ν•  λ©”μ†Œλ“œλ“€μ΄λ‹€.

1.2. 11.2 Implementing the Vec class

1.2.1. 11.2.1 λ©”λͺ¨λ¦¬ ν• λ‹Ή

연산을 κ²°μ •ν•œν›„μ—λŠ” μ–΄λ–€ λ°©μ‹μœΌλ‘œ VecλΌ κ΅¬ν˜„ν• μ§€λΌ κ²°μ •ν•˜λŠ” 것이닀.
μ—¬κΈ°μ„œλŠ” template classλΌ μ΄μš©ν•œλ‹€.
ν…œν”Œλ¦Ώμ€ ν•¨μˆ˜λΏλ§Œ μ•„λ‹ˆλΌ ν΄λž˜μŠ€μ—μ„œλ„ μ‚¬μš©ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
~cpp 
template <class T> class Vec {
public:
	//interface
private:
	//implementation
};
 
begin, end, size ν•¨μˆ˜λΌ κ΅¬ν˜„ν•΄μ•Ό ν•˜λ€λ‘œ μ΄λŸ¬ν•œ μž‘μ—…μ„ μœ„ν•΄μ„œ 첫 μš”μ†Œμ˜ μ£Όμ†Œ, λ§ˆμ§€λ§‰ μš”μ†ŒλΌ ν•˜λ‚˜ μ§€λ‚œ μ£Όμ†Œ, μš”μ†Œλ“€μ˜ κ°œμˆ˜λΌ μ €μž₯ν•  수 μžˆμ–΄μ•Όν•œλ‹€.
sizeλŠ” begin, end λΌ ν†΅ν•΄μ„œ κ·Έ ν¬κΈ°λΌ κ΅¬ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ€λ‘œ μ—¬κΈ°μ„œλŠ” 첫 μš”μ†Œμ˜ μ£Όμ†Œ, λ§ˆμ§€λ§‰ μš”μ†ŒλΌ ν•˜λ‚˜ μ§€λ‚œ μ£Όμ†ŒλΌ μ €μž₯ν•˜κ³  κ°œμˆ˜λŠ” 계산을 ν†΅ν•΄μ„œ κ΅¬ν˜„ν•œλ‹€.
~cpp 
template <class T> class Vec {
public:
	//interface
private:
	T* data;	// 첫번째 μš”μ†Œ
	T* limit;	// λ§ˆμ§€λ§‰ μš”μ†Œμ—μ„œ ν•˜λ‚˜λΌ μ§€λ‚œ 곳의 포인터
};
 
ν…œν”Œλ¦Ώμ€ 단지 틀일 뿐이며, μ‚¬μš©ν• λ•Œ type parameter둜 μ€ ν˜•μ— λ”°λΌμ„œ μ‹€μ œμ˜ ν΄λž˜μŠ€λΌ μƒμ„±ν•œλ‹€.
λ”°λΌμ„œ μ–΄λ–€ νƒ€μž…μ΄ Vecμ—μ„œ μ‚¬μš©λ˜λŠ”μ§„λŠ” μ •μ˜λΆ€κ°€ instiation 되기 μ „μ—λŠ” μ•Œ 수 μ—†λ‹€.

1.2.2. 11.2.2 μƒμ„±μž(Constructor)

μ•žμ˜ μΈν„°νŽ˜μ΄μŠ€ λͺ…μ„Έμ—μ„œ μ•„λž˜μ˜ 2κ°€μ§€λΌ κ°€λŠ₯ν•˜κ²Œ ν•˜λ„λ‘ ν–ˆκΈ° λ•Œλ¬Έμ— μƒμ„±μž 2κ°œλŠ” μ΅œμ†Œν•œ κ΅¬ν˜„ν•΄μ•Όν•œλ‹€.
~cpp 
Vec<Student_info> vs;		// default constructor
Vec<Student_info> vs(100);	// Vec의 μš”μ†Œμ˜ ν¬κΈ°λΌ μ·¨ν•˜λŠ” μƒμ„±μž
				// ν‘œμ€ vector ν΄λž˜μŠ€λŠ” 크기와 ν•¨κ»˜ μ΄ˆκΈ°ν™” μš”μ†ŒλΌ μΈμžλ‘œ λ°›λŠ” μƒμ„±μžλ„ μ œκ³΅ν•œλ‹€.
 

~cpp 
template <class T> class Vec {
public:
	Vec() { create(); }	// μ•„μ§μœΌλ‘œμ„ λŠ κ΅¬ν˜„λΆ€λΆ„μ—μ„œ 정해진 것이 μ—†κΈ° λ•Œλ¬Έμ— μž„μ‹œμ μœΌλ‘œ ν•¨μˆ˜λΌ λ§Œλ“€μ–΄μ„œ λ„£μ—ˆλ‹€.
	explicit Vec(size_type n, const T& val = T()) { create(n, val); }
private:
	T* data;	// 첫번째 μš”μ†Œ
	T* limit;	// λ§ˆμ§€λ§‰ μš”μ†Œμ—μ„œ ν•˜λ‚˜λΌ μ§€λ‚œ 곳의 포인터
};
 
2번째 μƒμ„±μžλŠ” μ΄ˆκΈ°ν™”μ˜ 인자둜 인자 νŒŒλΌλ©”ν„°μΈ T의 μƒμ„±μžλΌ μ΄μš©ν•œλ‹€.
인자의 κΈ°λ³Έν˜•μ„ 지정해주면 ν•œκ°œμ˜ ν•¨μˆ˜μ •μ˜λ‘œλ„ 2κ°€μ§€μ˜ μƒμ„±μžμ˜ 역할을 ν•  수 있기 λ•Œλ¬Έμ— νŽΈλ¦¬ν•˜λ‹€.
explicit ν‚€μ›Œλ“œ
μƒμ„±μžκ°€ ν•˜λ‚˜μ˜ μΈμžλΌ λ°›λŠ” 경우. 일반적인 λŒ€μž… μƒμ„±μžμ™€ 혼용이 될 κ°€λŠ₯성이 μ‘΄μž¬ν•˜κΈ° λ•Œλ¬Έμ— λͺ…μ‹œμ μΈ μƒμ„±λ§Œμ„ ν—ˆμš©μ‹œν‚€λŠ” 방법이닀. (12.2 μ ˆμ—μ„œ μžμ„Έν•œ λ…Όμ˜)
~cpp 
Vec<int> vi(100);	// Working. int λΌ ν†΅ν•΄ λͺ…μ‹œμ μΈ 생성
Vec<int> vi = 100;	// not working. μ•”λ¬΅μ μœΌλ‘œ VecλΌ μƒμ„±ν•˜κ³  κ·Έ 값을 vi 에 λ³΅μ‚¬ν•œλ‹€. refer 11.3.3
 

1.2.3. 11.2.3 νƒ€μž… μ •μ˜

const_iterator, iteratorλΌ μ •μ˜ν•΄μ•Όν•¨.
back_inserter(T)ν•¨μˆ˜λΌ ν†΅ν•΄μ„œ λ™μ μœΌλ‘œ ν¬κΈ°λΌ λ³€κ²½μ‹œν‚€κΈ° μœ„ν•΄μ„œ value_type, push_back νƒ€μž…μ„ μ •μ˜ν•¨. (value_type 은 ν˜„μž¬ μ €μž₯된 μš”μ†Œκ°€ μ–΄λ–€ νƒ€μž…μΈμ§€λΌ μ•Œλ €μ€Œ)
list의 λ°˜λ³΅μžλΌ κ΅¬ν˜„ν•˜λŠ” 경우라면 ++ 연산을 ν†΅ν•΄μ„œ λ…Έλ“œλ‘œ μ—°κ²°λœ λ‹€μŒ λ…Έλ“œλΌ λ¦¬ν„΄ν•˜λŠ” ν•¨μˆ˜λΌ μ˜€λ²„λ‘œλ”©ν•΄μ•Όν•˜λ‚˜, μ—¬κΈ°μ„œλŠ” λ°°μ—΄μ˜ μš”μ†ŒλΌ κ°€λ¦¬ν‚€λ€λ‘œ λ‹¨μˆœμ΄ ν¬μΈν„°λΌ λ¦¬ν„΄ν•˜λŠ” 것 만으둜 μš°λ¦¬λŠ” μž„μ˜ μ ‘κ·Ό λ°˜λ³΅μžλΌ κ΅¬ν˜„ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.

value_type은 Tκ°€ λ˜μ–΄μ•Όν•˜λŠ” 것은 λ‹Ήμ—°ν•˜λ‹€. λ°°μ—΄μ˜ κ°œμˆ˜λΌ ν‘œν˜„ν•˜λŠ” size_type은 cstddef 에 μ‘΄μž¬ν•˜λŠ” size_tλ‘œμ„œ μ •μ˜ν•˜λŠ” 것이 ν•©λ‹Ήν•˜λ‹€.

~cpp 
template <class T> class Vec {
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	typedef size_t size_type;
	typedef T value_type;

	Vec() { create(); }	// μ•„μ§μœΌλ‘œμ„ λŠ κ΅¬ν˜„λΆ€λΆ„μ—μ„œ 정해진 것이 μ—†κΈ° λ•Œλ¬Έμ— μž„μ‹œμ μœΌλ‘œ ν•¨μˆ˜λΌ λ§Œλ“€μ–΄μ„œ λ„£μ—ˆλ‹€.
	explicit Vect(size_type n, const T& val = T()) { create(n, val); }
private:
	iterator data;	// 첫번째 μš”μ†Œ
	iterator limit;	// λ§ˆμ§€λ§‰ μš”μ†Œμ—μ„œ ν•˜λ‚˜λΌ μ§€λ‚œ 곳의 포인터
};
 
μ ˆμ ν•œ typedefλΌ μΆ”κ°€ν•˜κ³ , 멀버 λ°μ΄ν„°μ˜ ν˜•λ„ 여기에 λ§žμΆ”μ–΄μ„œ λ³€κ²½ν•˜μ˜€μŒ.

1.2.4. 11.2.4 인덱슀 및 size


~cpp 
for (i = 0; i != vs.size(); ++)
	cout<<vs[i].name();
 
μƒκΈ°μ˜ 연산을 κ°€λŠ₯ν•˜κ²Œ ν•˜κΈ° μœ„ν•΄μ„œλŠ” operator[], size() ν•¨μˆ˜λΌ μ •μ˜ ν•΄μ•Όν•œλ‹€.

μ—°μ‚°μž μ˜€λ²„λ‘œλ”©(operator overload)
μ˜€λ²„λ‘œλ“œ μ—°μ‚°μžμ˜ λͺ…칭은 operatorop 의 ν˜•νƒœλ‘œ λ‚˜νƒ€λ‚œλ‹€. 즉 ~cpp []의 κ²½μš°μ—λŠ” ~cpp operator[]둜 λ‚˜νƒ€λ‚Ό 수 μžˆλ‹€.
λ§Œμ•½ μ˜€λ²„λ‘œλ“œ μ—°μ‚°μžκ°€ λ©€λ²„ν•¨μˆ˜κ°€ μ•„λ‹ˆλΌλ©΄(friend ν•¨μˆ˜) 쒌츑 ν”Όμ—°μ‚°μžλŠ” 첫번째 인수, 우츑 ν”Όμ—°μ‚°μžλŠ” λ‘λ²ˆμž¬ 인수둜 λ‚˜νƒ€λ‚Ό 수 μžˆλ‹€.
λ§Œμ•½ 멀버 ν•¨μˆ˜λ‘œ μ—°μ‚°μžκ°€ μ •μ˜ λ˜μ–΄ μžˆλ‹€λ©΄ 쒌츑 ν”Όμ—°μ‚°μžλŠ” ν•¨μˆ˜λΌ ν˜ΈμΆœν•œ 객체둜 κ°„μ£Όλ˜κ³  μ˜€λ²„λ‘œλ“œ μ—°μ‚°μžλŠ” 인자둜 우츑의 ν”Όμ—°μ‚°μžλ§Œμ„ 인자둜 μ·¨ν•œλ‹€.
~cpp []연산은 인자둜 size_type을 μ·¨ν•˜κ³ , λ¦¬ν„΄κ°’μœΌλ‘œ value_type의 λ ˆνΌλŸ°μŠ€λΌ μ·¨ν•΄μ•Όν•  것이닀.
~cpp 
template <class T> class Vec {
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	typedef size_t size_type;
	typedef T value_type;

	Vec() { create(); }	// μ•„μ§μœΌλ‘œμ„ λŠ κ΅¬ν˜„λΆ€λΆ„μ—μ„œ 정해진 것이 μ—†κΈ° λ•Œλ¬Έμ— μž„μ‹œμ μœΌλ‘œ ν•¨μˆ˜λΌ λ§Œλ“€μ–΄μ„œ λ„£μ—ˆλ‹€.
	explicit Vect(size_type n, const T& val = T()) { create(n, val); }

	size_type size() const { return limit - data; }

	T& operator[](size_type i) { return data[i]; }
	const T& operator[](size_type i) const { return data[i]; };	// μ΄κ²½μš°μ—λ„ λ ˆνΌλŸ°μŠ€λΌ μ“°λŠ” μ΄μœ λŠ” μ„±λŠ₯μƒμ˜ μ΄μœ λ•Œλ¬Έμ΄λ‹€.
private:
	iterator data;	// 첫번째 μš”μ†Œ
	iterator limit;	// λ§ˆμ§€λ§‰ μš”μ†Œμ—μ„œ ν•˜λ‚˜λΌ μ§€λ‚œ 곳의 포인터
};
 
operator[] 의 2가지 버전을 μ˜€λ²„λ‘œλ”© ν•  수 μž‡λŠ” κ·Όκ±°
λͺ¨λ“  λ©€λ²„ν•¨μˆ˜λŠ” μ•”λ¬΅μ μœΌλ‘œ ν•œκ°€μ§€μ˜ μΈμžλΌ λ” λ°›λŠ”λ‹€. 그것은 κ·Έ ν•¨μˆ˜λΌ ν˜ΈμΆœν•œ 객체인데, 이경우 κ·Έ 객체가 constμ΄κ±°λ‚˜ const κ°€ μ•„λ‹Œ 버전 2가지가 μ‘΄μž¬ν•˜λŠ” 것이 κ°€λŠ₯ν•˜κΈ° λ•Œλ¬Έμ— parameter specification 이 λ™μΌν•˜μ§€λ§Œ μ˜€λ²„λ‘œλ”©μ΄ κ°€λŠ₯ν•˜λ‹€.

1.2.5. 11.2.5 λ°˜λ³΅μžλΌ λ¦¬ν„΄ν•˜λŠ” μ—°μ‚°


~cpp 
template <class T> class Vec {
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	typedef size_t size_type;
	typedef T value_type;

	Vec() { create(); }	// μ•„μ§μœΌλ‘œμ„ λŠ κ΅¬ν˜„λΆ€λΆ„μ—μ„œ 정해진 것이 μ—†κΈ° λ•Œλ¬Έμ— μž„μ‹œμ μœΌλ‘œ ν•¨μˆ˜λΌ λ§Œλ“€μ–΄μ„œ λ„£μ—ˆλ‹€.
	explicit Vect(size_type n, const T& val = T()) { create(n, val); }

	size_type size() const { return limit - data; }

	T& operator[](size_type i) { return data[i]; }
	const T& operator[](size_type i) const { return data[i]; };	// μ΄κ²½μš°μ—λ„ λ ˆνΌλŸ°μŠ€λΌ μ“°λŠ” μ΄μœ λŠ” μ„±λŠ₯μƒμ˜ μ΄μœ λ•Œλ¬Έμ΄λ‹€.

	//λ°˜λ³΅μžλ“€μ„ λ¦¬ν„΄ν•˜λŠ” μƒˆλ‘œμš΄ ν•¨μˆ˜λ“€
	iterator begin() { return data; }
	const_iterator begin() const { return data; }

	iterator end() { return limit; }
	const_iterator end() const { return limit; }

private:
	iterator data;	// 첫번째 μš”μ†Œ
	iterator limit;	// λ§ˆμ§€λ§‰ μš”μ†Œμ—μ„œ ν•˜λ‚˜λΌ μ§€λ‚œ 곳의 포인터
};
 

1.3. 11.3 Copy control

μš°λ¦¬κ°€ 볡사, λŒ€μž…, μ†Œλ©Έμ‹œ ν•˜λŠ” 일에 λŒ€ν•΄μ„œ λͺ…μ‹œμ μœΌλ‘œ μ •ν•˜μ§€ μ•ŠμœΌλ©΄ μ»΄νŒŒμΌλŸ¬λŠ” 정해진 μžμ‹ λ§Œμ˜ λ°©λ²•μœΌλ‘œ 이런 일을 ν•˜λŠ” μ •μ˜λΌ λ§Œλ“€μ–΄μ„œ μž‘λ™ν•˜κ²Œ λœλ‹€.
사싀 μ΄λ ‡κ²Œ μƒμ„Έν•œ 객체의 행동양식을 κ·œμ œν•  수 μž‡λŠ” μ–Έμ–΄λ‘œλŠ” C++이 μœ μΌν•˜λ‹€. (그만큼 ν΄λž˜μŠ€λΌ μž‘μ„±ν• λ•Œ λ§Žμ€ 것듀이 κ³ λ €λ˜μ–΄μ•Όν•œλ‹€.)

1.3.1. 11.3.1 Copy μƒμ„±μž

implicit copy constructor
~cpp 
vector<int> vi;
double d;
d = median (vi);		// copy constructor work

string line;
vector<string> words = split(words);	// copy constructor work
 

explicit copy constructor
~cpp 
vector<Student_info> vs;
vector<Student_info> v2 = vs;	// copy constructor work (from vs to v2)
 
볡사 μƒμ„±μž
볡사 μƒμ„±μžλŠ” μƒμ„±μžμ˜ 이름은 기타 μƒμ„±μžμ™€ κ°™μœΌλ‚˜ 인자둜 μžμ‹ μ΄ 호좜된 객체의 νƒ€μž…μ„ κ°–λŠ” μƒμ„±μžλΌ μ˜λΈν•œλ‹€.
ν•¨μˆ˜μ˜ μΈμžλΌ λ³΅μ‚¬ν•˜λŠ” 것을 ν¬ν•¨ν•΄μ„œ, 볡사본을 λ§Œλ“ λ‹€λŠ” 의λΈλΌ μ •μ˜ν•˜κ³  있기 λ•Œλ¬Έμ— λ§€κ°œλ³€μˆ˜λΌ λ ˆνΌλŸ°μŠ€ νƒ€μž…μœΌλ‘œ ν•˜λŠ” 것이 μ’‹λ‹€.
~cpp 
template <class T> class Vec {
public:
	Vec(const Vec& v);	// copy constructor
	// 이전과 κ°™μŒ
};
 

보톡 λ””ν΄νŠΈ 볡사 μƒμ„±μžμ˜ κ²½μš°μ—λŠ” 클래슀의 멀버 λ³€μˆ˜λ“€μ„ λ‹¨μˆœνžˆ λ³΅μ‚¬λ§Œ ν•˜κ²Œ λ©λ‹ˆλ‹€. μ΄λ•Œ λ§Œμ•½ κ·Έ 멀버 λ³€μˆ˜κ°€ ν¬μΈν„°μ˜ ν˜•νƒœλΌκ³  ν•œλ‹€λ©΄ λ¬Έμ œκ°€ λ°œμƒν•˜κ²Œ λœλ‹€.
이 경우 ν•œμͺ½μ˜ 객체가 μˆ˜μ •λ˜κ±°λ‚˜ μ†Œλ©Έλ˜λ©΄ μ΄λΌ λ³΅μ‚¬ν•œ 객체도 κ·Έ 영ν–₯을 λ°›κ²Œλ˜κΈ° λ•Œλ¬Έμ΄λ‹€.
λ”°λΌμ„œ ν¬μΈν„°μ˜ 경우 μƒˆλ‘œμš΄ μ£Όμ†Œ 곡간을 ν• λ‹Ήλ°›κ³  κ·Έ λŒ€μƒμ΄ λ˜λŠ” 값을 볡사해야지 이런 λ¬Έμ œκ°€ λ°œμƒν•˜μ§€ μ•ŠλŠ”λ‹€.
μ—­μ‹œ λ‹€λ₯Έ μƒμ„±μžμ™€ λ§ˆμ°¬κ°€μ§€λ‘œ create() ν•¨μˆ˜λΌ μ΄μš©ν•΄μ„œ λ³΅μ‚¬λΌ ν–‰ν•˜λ„λ‘ λ§Œλ“ λ‹€.
~cpp 
template <class T> class Vec {
public:
	Vec(const Vec& v) { create(v.begin(), v.end() ); }	// copy constructor
	// 이전과 κ°™μŒ
};
 

1.3.2. 11.3.2 λŒ€μž…(Assignment)

λŒ€μž… μ—°μ‚°μž(assignment operator)
operator=() 의 μ—¬λŸ¬κ°€μ§€ μΈμŠ€ν„΄μŠ€μ€‘μ—μ„œ 인자둜 μžμ‹ μ˜ 클래슀 ν˜• μžμ²΄μ— λŒ€ν•œ const λ ˆνΌλŸ°μŠ€λΌ μ·¨ν•˜λŠ” ν˜•νƒœλΌ λŒ€μž…μ—°μ‚°μžλΌ μΉ­ν•œλ‹€.
리턴값을 C++ κΈ°λ³Έ λŒ€μž…μ—°μ‚°μžμ™€μ˜ μΌκ΄€μ„±μ˜ μœ μ§€λΌ μœ„ν•΄μ„œ μ—°μ‚°μžμ˜ μ™Έμͺ½ν•­(left-hand side)μ—λŒ€ν•œ λ ˆνΌλŸ°μŠ€λΌ μ·¨ν•œλ‹€.
~cpp 
template <class T> class Vec {
public:
	Vec& operator=(const Vec&);	// copy constructor
	// 이전과 κ°™μŒ
};
 
λŒ€μž… μ—°μ‚°μž μ˜€λ²„λ‘œλ”©μ‹œ μ£Όμ˜ν•΄μ•Όν•  사항
λŒ€μž… μ—°μ‚°μžλŠ” 볡사 μ—°μ‚°μžμ™€ 달리 μ™Όμͺ½ν•­μ„ μ œκ±°ν•˜κ³  μƒˆλ‘œμš΄ κ°’μœΌλ‘œ λŒ€μ²΄μ‹œν‚΅λ‹ˆλ‹€. 볡사 μƒμ„±μžλŠ” μˆ˜ν–‰ μ‹œμ μ— μ™Όμͺ½ν•­μ˜ 객체가 처음 λ§Œλ“€μ–΄μ§„ μƒνƒœμ΄κΈ° λ•Œλ¬Έμ— ν•΄μ œν•  λŒ€μƒμ΄ μ—†μ§€λ§Œ, λŒ€μž… μ—°μ‚°μžλŠ” 기쑴데이터가 μžˆλŠ” μƒνƒœμ—μ„œλ„ λŒ€μž…μ„ ν•  수 있기 λ•Œλ¬Έμ— 볡사 μƒμ„±μžμ™€ λΉ„μŠ·ν•˜κ²Œ κ΅¬μ„±λ˜μ–΄μ•Ό ν•œλ‹€.
λ˜ν•œ 자기 λŒ€μž… (self-assignment)을 μœ„ν•œ κ³ λ €κ°€ ν•„μš”ν•˜λ‹€.
~cpp 
template<class T> Vec<T>& Vec<T>::operator=(const Vec& rhs) {
	// self-assignment check
	if (&rhs != this) {
		//lhs memory deallocation
		uncreate();
		create(rhs.begin(), rhs.end());
	{
	return *this;
}
 
  • ν—€λ”νŒŒμΌμ—μ„œμ˜ λ¦¬ν„΄νƒ€μž…μ΄ Vec& 둜 μ‚¬μš©λ˜μ—ˆμŒ
    ν…œν”Œλ¦Ώμ˜ μŠ€μ½”ν”„ μ•ˆμ—μ„œλŠ” νƒ€μž… λ§€κ°œλ³€μˆ˜λΌ μƒλž΅ν•˜λŠ” μ‹μ˜ 더 μ‰¬μš΄ ν‘œν˜„μ„ μ‚¬μš©ν•  수 μžˆλ‹€.
    Vec::operator= 이 μ•„λ‹ˆλΌ, Vec<T>::operator= κ°€ μ›λž˜μ˜ 이름이닀. κ·ΈλŸ¬λ‚˜ 일단 operator=κ°€ Vec<T>의 λ©€λ²„λΌλŠ” 사싀이 λ°ν˜€μ§€λ©΄ 더이상 ν…œν”Œλ¦Ώ ν•œμ •μžλΌ λ°˜λ³΅ν•  ν•„μš”κ°€ μ—†λ‹€.
  • this ν‚€μ›Œλ“œμ˜ μ‚¬μš©
    thisλŠ” λ©€λ²„ν•¨μˆ˜ μ•ˆμ—μ„œ μœ νš¨ν•˜λ‹€. thisλŠ” λ©€λ²„ν•¨μˆ˜λΌ ν˜ΈμΆœμ‹œν‚¨ 객체의 ν¬μΈν„°λΌ λ¦¬ν„΄ν•œλ‹€.
    λ§Œμ•½ this ν‚€μ›Œλ“œλ‘œ 자기 λŒ€μž… μ²΄ν¬λΌ ν•˜μ§€ μ•Šμ„ κ²½μš°μ—λŠ” 였λ₯Έμͺ½ κ°μ²΄λΌ ν•΄μ œν•œ 뒀에 λ‹€μ‹œ μ™Όμͺ½ν•­μ— λŒ€μž…ν•˜κ²Œ 되λ€λ‘œ λ¬Έμ œκ°€ λ°œμƒν•˜κ²Œ λœλ‹€.
  • *this 의 리턴
    지역 객체에 λŒ€ν•œ 리턴을 ν•΄μ„œλŠ” μ•ˆλœλ‹€. 지역 κ°μ²΄λΌ λ¦¬ν„΄ν•˜λ©΄ 객체의 쑴재 scopeλΌ λ²—μ–΄λ‚˜κΈ° λ•Œλ¬Έμ— μ˜¬λ°”λ₯Έ λ™μž‘μ„ 보μž₯ν•˜μ§€ λͺ»ν•œλ‹€.

1.3.3. 11.3.3 λŒ€μž…μ€ μ΄ˆκΈ°ν™”κ°€ μ•„λ‹ˆλ‹€

C++은 = κ°€ 객체의 μ΄ˆκΈ°ν™”, 볡사 μ‹œμ— λ™μΌν•˜κ²Œ μ‚¬μš©λ˜κΈ° λ•Œλ¬Έμ— 볡사 μƒμ„±μžμ™€, λŒ€μž…μ—°μ‚°μžμ˜ ꡬ뢄이 μ—†λ‹€.
= κ°€ μ΄ˆκΈ°ν™” λ˜μ§€ μ•Šμ€ 객체에 μ‚¬μš©λ˜λ©΄ 볡사 μƒμ„±μžλ‘œ, μ΄ˆκΈ°ν™”λœ 객체에 μ‚¬μš©λ˜λ©΄ λŒ€μž… μ—°μ‚°μžλ‘œ μ‚¬μš©λœλ‹€.
μ΄ˆκΈ°ν™” 상황 * λ³€μˆ˜ μ„ μ–Έμ‹œ
* ν•¨μˆ˜ μ§„μž…μ‹œ, ν•¨μˆ˜ λ§€κ°œλ³€μˆ˜
* ν•¨μˆ˜ 리턴값
* μƒμ„±μž 초기 μ„μ •μž

μƒμ„±μžμ˜ 2가지 μš©λ²•
~cpp 
string url_ch = "~;/?:@=&$-_.+!*'(),";
string spaces(url_ch.size(), ' ');
 

λ¦¬ν„΄κ°’μ—μ„œμ˜ 볡사 μƒμ„±μžμ˜ μ‚¬μš©, λŒ€μž…μ—°μ‚°μžμ˜ μ‚¬μš©
~cpp 
vector<string> split(const string&);
vector<string> v;
v = split(line);	// ν•¨μˆ˜μ˜ μ’…λ£Œμ‹œ μž„μ‹œ κ°μ²΄λΌ λ³΅μ‚¬μƒμ„±μžλ‘œ 생성
			// μƒμ„±λœ μž„μ‹œ κ°μ²΄λΌ λŒ€μž… μ—°μ‚°μžκ°€ v 에 λŒ€μž…
 

1.3.4. 11.3.4 μ†Œλ©Έμž(Destructor)

μ†Œλ©Έμž(destructor)
동적 ν• λ‹ΉμœΌλ‘œ μƒμ„±λœ κ°μ²΄λŠ” delete ν‚€μ›Œλ“œλ‘œ μ œκ±°ν•˜κΈ° μ „μ—λŠ” λ©”λͺ¨λ¦¬ κ³΅κ°„μ—μ„œ μ‚­μ œλ˜μ§€ μ•ŠλŠ”λ°, 객체 λ©€λ²„λ³€μˆ˜λ‘œ 동적 할당이 된 λ³€μˆ˜κ°€ μ‘΄μž¬ν•œλ‹€λ©΄ 객체의 ν•΄μ œμ‹œμ— 이 곡간을 λ©”λͺ¨λ¦¬μ—μ„œ ν•΄μ œν•΄μ£Όμ–΄μ•Ό ν•œλ‹€.
μ†Œλ©Έμžμ˜ ν˜•νƒœλŠ” μƒμ„±μžμ™€ λ§ˆμ°¬κ°€μ§€λ‘œ λ°˜ν™˜ν˜•μ΄ μ—†μœΌλ©° 객체 ν˜•λͺ…κ³Ό λ™μΌν•œ ν•¨μˆ˜λͺ…을 κ°–λŠ” λŒ€μ‹ μ— 첫 κΈ€μžλ‘œ ~λΌ κ°€μ Έμ•Ό ν•œλ‹€.
~cpp 
template <class T> class Vec {
public:
	~Vec() { uncreate; }	// copy constructor
	// 이전과 κ°™μŒ
};
 

1.3.5. 11.3.5 λ””ν΄νŠΈ μ—°μ‚°(Default operation)

μƒμ„±μž, μ†Œλ©Έμž, 볡사 μƒμ„±μž, λŒ€μž…μ—°μ‚°μžλΌ μž¬μ •μ˜ ν•˜μ§€ μ•Šμ„ κ²½μš°μ—λŠ” μ»΄νŒŒμΌλŸ¬κ°€ κΈ° μ •μ˜λœ λ°©μ‹μœΌλ‘œ 이런 μƒμ„±μžμ˜ κΈ°λ³Έν˜•μ„ λ§Œλ“ λ‹€.
이 경우 멀버 객체(has-a)인 κ²½μš°μ—λŠ” μž¬κ·€μ μœΌλ‘œ 이런 λ””ν΄νŠΈ 연산을 μˆ˜ν–‰ν•˜λ©°, κΈ°λ³Έν˜•(primitive type)의 κ²½μš°μ—λŠ” κ°’μ—μ˜ν•œ λ°©μ‹μœΌλ‘œ 이런 연산듀이 행해진닀. κ·ΈλŸ¬λ‚˜ ν¬μΈν„°μ˜ 경우 νŠΉλ³„νžˆ λ‹€λ₯Έ 일이 μžƒμ–΄λ‚˜μ§€ μ•ŠμœΌλ©°, 포인터가 κ°€λ¦¬ν‚€λ˜ 곡간은 ν•΄μ œλ˜μ§€ μ•ŠλŠ”λ‹€.
default constructor λΌ μ‚¬μš©ν•˜κΈ° μœ„ν•΄μ„œλŠ” 객체의 멀버듀이 λ””ν΄νŠΈ μƒμ„±μžλΌ κ°€μ§„ κ²½μš°μ—λ§Œ 정상적인 λ™μž‘μ„ 보μž₯ν•  수 μžˆλ‹€.
μΌλ°˜μ μœΌλ‘œλŠ” λͺ…μ‹œμ μœΌλ‘œ μ •μ˜λœ λ””ν΄νŠΈ μƒμ„±μžλΌ λ§Œλ“œλŠ” 것이 μ’‹λ‹€.

1.3.6. 11.3.6 μ„Έ 법칙(rule of three)

볡사 μƒμ„±μž λΈμ •μ˜ 원본과 λ³΅μ‚¬λ³Έμ˜ 데이터가 μƒν˜Έ 참쑰의 ν˜•μ‹μœΌλ‘œ λ™μž‘ν•œλ‹€.
μ†Œλ©Έμž λΈμ •μ˜ 포인터 객체가 μ‘΄μž¬ν•˜λŠ” 경우 memory leak 이 λ°œμƒ
β€» ν΄λž˜μŠ€μ— μ†Œλ©Έμžκ°€ ν•„μš”ν•˜λ‹€λ©΄ λ°˜λ“œμ‹œ 볡사 μƒμ„±μžμ™€ λŒ€μž… μ—°μ‚°μžλΌ μž¬μ •μ˜ν•΄μ•Ό μ˜¬λ°”λ₯Έ λ™μž‘μ„ 보μž₯ν•œλ‹€.

ν•œ 객체에 λŒ€ν•΄μ„œ λͺ¨λ“  볡사본이 μ œλŒ€λ‘œ λ™μž‘ν•˜λ©΄ μž¬μ •μ˜ ν•΄μ•Όν•  것듀
T::T()
T::~T()
T::T(const T&)
T::operator=(const T&)

Rule of three : 볡사 μƒμ„±μž, μ†Œλ©Έμž, λŒ€μž… μ—°μ‚°μžκ°€ λ°€μ ‘ν•œ κ΄€κ³„λΌ κ°–λŠ” 것을 일컬어 ν‘œν˜„ν•˜λŠ” 말이닀.

1.4. 11.4 Dynamic Vecs

push_back의 κ΅¬ν˜„λ°©μ‹
push_back을 κ΅¬ν˜„ν•¨μ— μžˆμ–΄μ„œ μš”μ†Œ λ°°μ—΄μ˜ ν¬κΈ°λΌ ν‚€μ›Œμ•Όν•˜λŠ”λ° 이 것을 μœ„ν•΄μ„œ μ—¬κΈ°μ„œλŠ” ν•„μš”μ–‘ 보닀 λ§Žμ€ 수의 배열을 ν• λ‹Ήν•˜κ³  ν•˜λ‚˜μ”© λ³€μˆ˜λΌ ν•˜λ‚˜λ” λ§Œλ“€μ–΄μ„œ ν˜„μž¬ μ‚¬μš©κ°€λŠ₯ν•œ 끝을 κ°€λ¦¬ν‚€λŠ”λ° μ΄μš©ν•˜κΈ°λ‘œ ν•œλ‹€.
~cpp 
template<class T> class Vec {
public:
	size_type size() const { return avail - data; }
	iterator end() { return avail; }
	const_iterator end() const { return avail; }
	void push_back(const T& val) {
		if (avail == limit)
			grwo(0;
		unchecked_append(val);
	}
private:
	iterator data;
	iterator avail;
	iterator limit;
}

1.5. 11.5 Flexible memory management

Vecμ—μ„œ new, delete ν‚€μ›Œλ“œλΌ μ‚¬μš©ν•˜μ§€ μ•ŠλŠ”λ‹€. 배열을 new둜 ν• λ‹Ήν•˜κ²Œ 되면 기본적으둜 μƒμ„±λ˜λŠ” 객체의 λ””ν΄νŠΈ μƒμ„±μžλ‘œ μ΄ˆκΈ°ν™” 되기 λ•Œλ¬Έμ΄λ‹€. μ΄λŠ” μ›λž˜ μš°λ¦¬κ°€ μ˜λ„ν•œ κ²ƒκ³ΌλŠ” λ‹€λ₯Έ λ°©μ‹μœΌλ‘œ λ™μž‘ν•œλ‹€.
λ”°λΌμ„œ μš°λ¦¬λŠ” μ€λ” 일반적인 ν˜•νƒœμ˜ ν‘œμ€ μ œκ³΅ λΌμ΄λΈŒλŸ¬λ¦¬μ— μ‘΄μž¬ν•˜λŠ” κ΄€λ¦¬μžλΌ μ‚¬μš©ν•œλ‹€.

<memory> 의 allocate<> STLμ—μ„œ μ•Œμ•„μ•Όν•  μ€‘μš” λ©”μ†Œλ“œ
~cpp 
template<class T> class allocator {
pubilc:
	T* allocate(size_t);
	void deallocate(T*, size_t);
	void construct(T*, T);
	void destroy(T*);
};
allocate, deallocate μ‹€μ œ λ©”λͺ¨λ¦¬μ˜ 곡간을 ν• λ‹Ή, ν•΄μ œν•œλ‹€. κ·ΈλŸ¬λ‚˜ ν• λ‹Ήμ‹œ μ΄ˆκΈ°ν™”λŠ” ν•˜μ§€ μ•ŠλŠ”λ‹€.
construct, destroy ν• λ‹Ήλœ λ©”λͺ¨λ¦¬ 곡간에 μ λ‹Ήν•œ 데이터 νƒ€μž…μ„ μ΄ˆκΈ°ν™” μ‹œν‚¨λ‹€. (곡간은 allocateλΌ ν†΅ν•΄μ„œ μ΄λΈ ν• λ‹Ήλœ 곡간이어야 ν•œλ‹€.)

allocate 클래슀의 비멀버 ν•¨μˆ˜ 일뢀
~cpp 
template<class In, class For> For uninitialized_copy(In, In, For);
tempalte<class for, class T> void uninitialized_fill(For, For, const T&);
uninitialized_copy μ²«λ²ˆμ§Έμ™€ λ‘λ²ˆμ§ΈμΈμžμ˜ μŠ€ν€€μŠ€λ§ŒνΌμ„ 3번째 인자의 곡간에 λ³΅μ‚¬ν•œλ‹€.
uninitialized_fill μ²«λ²ˆμ§Έμ™€ λ‘λ²ˆμ§Έ 인자의 곡간을 T둜 μ±„μš΄λ‹€.

1.5.1. 11.5.1 μ΅œμ’… Vec 클래슀


~cpp 
//vec.h
#ifndef VEC_H
#define VEC_H

#include <algorithm>
#include <cstddef>
#include <memory>

using std::max;

template <class T> class Vec {
public:
	typedef T* iterator;
	typedef const T* const_iterator;
	typedef size_t size_type;
	typedef T value_type;
	typedef T& reference;
	typedef const T& const_reference;

	Vec() { create(); }
	explicit Vec(size_type n, const T& t = T()) { create(n, t); }

	Vec(const Vec& v) { create(v.begin(), v.end()); }
	Vec& operator=(const Vec&);	// as defined in 11.3.2/196
	~Vec() { uncreate(); }

	T& operator[](size_type i) { return data[i]; }
	const T& operator[](size_type i) const { return data[i]; }

	void push_back(const T& t) {
		if (avail == limit)
			grow();
		unchecked_append(t);
	}

	size_type size() const { return avail - data; }  // changed

	iterator begin() { return data; }
	const_iterator begin() const { return data; }

	iterator end() { return avail; }                 // changed
	const_iterator end() const { return avail; }     // changed
	void clear() { uncreate(); }
	bool empty() const { return data == avail; }

private:
	iterator data;	// first element in the `Vec'
	iterator avail;	// (one past) the last element in the `Vec'
	iterator limit;	// (one past) the allocated memory

	// facilities for memory allocation
	std::allocator<T> alloc;	// object to handle memory allocation

	// allocate and initialize the underlying array
	void create();
	void create(size_type, const T&);
	void create(const_iterator, const_iterator);

	// destroy the elements in the array and free the memory
	void uncreate();

	// support functions for `push_back'
	void grow();
	void unchecked_append(const T&);
};

template <class T> void Vec<T>::create()
{
	data = avail = limit = 0;
}

template <class T> void Vec<T>::create(size_type n, const T& val)
{
	data = alloc.allocate(n);
	limit = avail = data + n;
	std::uninitialized_fill(data, limit, val);
}

template <class T>
void Vec<T>::create(const_iterator i, const_iterator j)
{
	data = alloc.allocate(j - i);
	limit = avail = std::uninitialized_copy(i, j, data);
}

template <class T> void Vec<T>::uncreate()
{
	if (data) {
		// destroy (in reverse order) the elements that were constructed
		iterator it = avail;
		while (it != data)
			alloc.destroy(--it);

		// return all the space that was allocated
		alloc.deallocate(data, limit - data);
	}
	// reset pointers to indicate that the `Vec' is empty again
	data = limit = avail = 0;

}

template <class T> void Vec<T>::grow()
{
	// when growing, allocate twice as much space as currently in use
	size_type new_size = max(2 * (limit - data), ptrdiff_t(1));

	// allocate new space and copy existing elements to the new space
	iterator new_data = alloc.allocate(new_size);
	iterator new_avail = std::uninitialized_copy(data, avail, new_data);

	// return the old space
	uncreate();

	// reset pointers to point to the newly allocated space
	data = new_data;
	avail = new_avail;
	limit = data + new_size;
}

// assumes `avail' points at allocated, but uninitialized space
template <class T> void Vec<T>::unchecked_append(const T& val)
{
	alloc.construct(avail++, val);
}

template <class T>
Vec<T>& Vec<T>::operator=(const Vec& rhs)
{
	// check for self-assignment
	if (&rhs != this) {

		// free the array in the left-hand side
		uncreate();

		// copy elements from the right-hand to the left-hand side
		create(rhs.begin(), rhs.end());
	}
	return *this;
}

#endif
 
클래슀 λΆˆλ³€μ‹(class invariant)
  • dataλŠ” 첫번째 μš”μ†Œ, μ—†λ‹€λ©΄ 0을 가진닀.
  • data<=avail<=limit
  • μƒμ„±λœ μš”μ†ŒλŠ” [data, avail)의 λ²”μœ„μ— 쑴재
  • μƒμ„±λ˜μ§€ μ•Šμ€ μš”μ†ŒλŠ” [avail, limit)의 λ²”μœ„μ— 쑴재

    ~cpp 
    template <class T> void Vec<T>::create()
    {
    	data = avail = limit = 0;	// λ””ν΄νŠΈ μƒμ„±μž 이기 λ•Œλ¬Έμ— 포인터에 λ„ν¬μΈν„°λΌ λ„£μ–΄μ„œ 빈 κ°μ²΄μž„μ„ λ‚˜νƒ€λ‚Έλ‹€.
    }
    
    template <class T> void Vec<T>::create(size_type n, const T& val)
    {
    	data = alloc.allocate(n);	// 인자둜 받은 만큼의 곡간을 ν• λ‹Ήν•œλ‹€.
    	limit = avail = data + n;	// 끝을 가리킨닀. ν˜„μž¬λ‘œμ„œλŠ” μ΄ˆκΈ°ν™”μ‹œ n개의 곡간을 ν• λ‹Ήν–ˆκΈ° λ•Œλ¬Έμ— avail = limit 이닀.
    	std::uninitialized_fill(data, limit, val);	// 아직 μ΄ˆκΈ°ν™” λ˜μ§€ μ•Šμ€ 곡간에 μ—¬λŸ¬κ°œμ˜ κ°μ²΄λΌ μ‚½μž…ν•΄μ•Όν•˜κΈ° λ•Œλ¬Έμ— λΉ„λ©€λ²„ν•¨μˆ˜λΌ μ΄μš©ν•΄μ„œ μ΄ˆκΈ°ν™” μ‹œν‚¨λ‹€.
    }
    
    template <class T>
    void Vec<T>::create(const_iterator i, const_iterator j)
    {
    	data = alloc.allocate(j - i);
    	limit = avail = std::uninitialized_copy(i, j, data);
    }
     
    주석을 μ°Έκ³ ν•˜κ³  μ΄ν•΄ν•˜κΈ° λ°”λžŒ.

    ~cpp 
    template <class T> void Vec<T>::uncreate()
    {
    	if (data) {
    		// destroy (in reverse order) the elements that were constructed
    		iterator it = avail;
    		while (it != data)
    			alloc.destroy(--it);
    
    		// return all the space that was allocated
    		alloc.deallocate(data, limit - data);
    	}
    	// reset pointers to indicate that the `Vec' is empty again
    	data = limit = avail = 0;
    
    }
     
    μ΄ˆκΈ°ν™” λ˜μ–΄μžˆλŠ” λ‚΄λΆ€μ˜ μš”μ†Œλ“€μ„ ν•˜λ‚˜μ”© destroyν•¨μˆ˜λΌ μ΄μš©ν•΄μ„œ μ†Œλ©Έμ‹œν‚¨λ‹€.
    κ·Έν›„ ν• λ‹Ήλœ 곡간을 deallocate ν•¨μˆ˜λΌ μ΄μš©ν•΄μ„œ λ©”λͺ¨λ¦¬ κ³΅κ°„μƒμ—μ„œ ν•΄μ œ μ‹œν‚¨λ‹€.
    ν•΄μ œκ°€ λλ‚œ μ΄ν›„μ—λŠ” λ‹€μ‹œ 빈 λ°±ν„°λ‘œ λ‚˜νƒœλ‚΄κΈ°μœ„ν•΄μ„œ data, limit, avail 을 μ΄ˆκΈ°ν™” ν•œλ‹€.

    ~cpp 
    template <class T> void Vec<T>::grow()
    {
    	// when growing, allocate twice as much space as currently in use
    	size_type new_size = max(2 * (limit - data), ptrdiff_t(1));	// λΉ„μ–΄μžˆλŠ” 벑터인 κ²½μš°μ—λŠ” 1개만 ν• λ‹Ήν•œλ‹€. 
    
    	// allocate new space and copy existing elements to the new space
    	iterator new_data = alloc.allocate(new_size);
    	iterator new_avail = std::uninitialized_copy(data, avail, new_data);
    
    	// return the old space
    	uncreate();
    
    	// reset pointers to point to the newly allocated space
    	data = new_data;
    	avail = new_avail;
    	limit = data + new_size;
    }
    
    // assumes `avail' points at allocated, but uninitialized space
    template <class T> void Vec<T>::unchecked_append(const T& val)
    {
    	alloc.construct(avail++, val);
    }
     
    grow ν•¨μˆ˜λŠ” ν•œλ²ˆ ν˜ΈμΆœν• λ•Œ μ΄λΈ μ›Œλž˜ κ³΅κ°„μ˜ 2λ°°λΌ ν• λ‹Ήμ‹œν‚€κΈ° λ•Œλ¬Έμ— κ³„μ†λœ push_back둜 μΈν•œ λ©”λͺ¨λ¦¬ ν• λ‹Ή μ˜€λ²„ν—€λ“œλΌ μ„일 수 μžˆλ‹€.
    unchecked_append()ν•¨μˆ˜λŠ” grow() ν•¨μˆ˜μ˜ λ°”λ‘œ λ’€μ—μ„œλ§Œ λ™μž‘ν•˜λ„λ‘ κ΅¬μ„±ν–ˆκΈ° λ•Œλ¬Έμ— λ™μž‘μ˜ μ•ˆμ •μ„±μ„ 보μž₯ν•  수 μžˆλ‹€. (λ¬Όλ‘  λ¬Έμ„œλ‘œ λ‚¨κ²¨μ„œ 이후 클래슀 ν™•μž₯μ‹œ λ‹€λ₯Έ ν”„λ‘œκ·Έλž˜λ¨Έκ°€ μ•Œ 수 μžˆλ„λ‘ ν•΄μ•Όν•  λ“)



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