U E D R , A S I H C RSS

AcceleratedC++/Chapter12

1. Chapter 12 Making class objects act like values

일반적인 C++의 κΈ°λ³Έν˜• λ°μ΄ν„°μ²˜λŸΌ ν΄λž˜μŠ€λ„ μ—¬λŸ¬κ°€μ§€μ˜ μ—°μ‚°μžλΌ μž¬μ •μ˜ ν•¨μœΌλ‘œμ¨ 마치 κ°’μ²˜λŸΌ λ™μž‘ν•˜λ„λ‘ ν•  수 μžˆλ‹€.
이 μž₯μ—μ„œλŠ” μ—¬λŸ¬κ°€μ§€ μ—°μ‚°μž, ν˜•λ³€ν™˜μ„ 클래슀의 μ œμž‘μžκ°€ μ œμ–΄ν•˜λŠ” 방법에 λŒ€ν•΄μ„œ λ°°μš΄λ‹€.
12μž₯μ—μ„œλŠ” string 클래슀의 클둠 버전인 Str ν΄λž˜μŠ€λΌ μ œμž‘ν•œλ‹€. Str ν΄λž˜μŠ€λŠ” string 클래슀의 ν˜•λ³€ν™˜κ³Ό μ—°μ‚°μžμ˜ κ΅¬ν˜„μ— μ΄ˆμ μ„ λ§žμΆ”μ–΄μ„œ μ œμž‘ν•œλ‹€.

1.1. 12.1 A simple string class

~cpp 
class Str {
public:
	typedef Vec<char>::size_type size_type;
	Str() {}
	Str(size_type n, char c):data(n, c) { }
	Str(const char* cp) {
		std::copy(cp, cp+std::strlen(cp), std::back_inserter(data));
	}
	
	template<class In> Str(In b, In e) {
		std::copy(b, e, std::back_inserter(data));
	}
private:
	Vec<char> data;
}
λ§Œμ•½ μƒμ„±μžκ°€ ν•˜λ‚˜λΌλ„ μ‘΄μž¬ν•˜λ©΄ μ»΄νŒŒμΌλŸ¬λŠ” μ•”μ‹œμ  κΈ°λ³Έ μƒμ„±μžλΌ λ§Œλ“€μ§€ μ•ŠλŠ”λ‹€. λ”°λΌμ„œ μ•„λ¬΄λŸ° μΈμžλΌ λ°›μ§€ μ•ŠλŠ” κΈ°λ³Έ μƒμ„±μžλΌ λ§Œλ“€ ν•„μš”κ°€ μžˆλ‹€.
이 ν΄λž˜μŠ€λŠ” 볡사 μƒμ„±μž, λŒ€μž… μ—°μ‚°μž, μ†Œλ©Έμžκ°€ ν•˜λŠ” λͺ¨λ“ μΌμ„ Vecν΄λž˜μŠ€μ— μΌμž„ν•œλ‹€.

1.2. 12.2 Automatic conversions

~cpp 
Str s("hello");		// sλΌ μƒμ„±ν•œλ‹€. 
Str t = "hello";	// tλΌ μ΄ˆκΈ°ν™” ν•œλ‹€. 
s = "hello";		// μƒˆλ‘œμš΄ 값을 s에 λŒ€μž…ν•œλ‹€. 
ν΄λž˜μŠ€λŠ” 기본적으둜 볡사 μƒμ„±μž, λŒ€μž… μ—°μ‚°μžμ˜ κΈ°λ³Έν˜•μ„ μ œκ³΅ν•œλ‹€. μœ„μ˜ ν΄λž˜μŠ€λŠ” 이런 연산에 λŒ€ν•œ 기본적인 μš”κ±΄μ„ 만μ±ν•˜κΈ° λ•Œλ¬Έμ— const char* κ°€ const Str& 둜 λ³€ν™˜λ˜μ–΄μ„œ μ •μƒμ μœΌλ‘œ λ™μž‘ν•œλ‹€.
μƒκΈ°μ˜ ν΄λž˜μŠ€μ—λŠ” Str(const char*) νƒ€μž…μ˜ μƒμ„±μžκ°€ μ‘΄μž¬ν•˜κΈ° λ•Œλ¬Έμ— 이 μƒμ„±μžκ°€ Str μž„μ‹œ κ°μ²΄λΌ μƒμ„±ν•΄μ„œ 마치 μ‚¬μš©μž μ •μ˜ λ³€ν™˜(user-define conversion)처럼 λ™μž‘ν•œλ‹€.

~cpp 
s="hello" 
s=Str("hello");		// 의 μž„μ‹œκ°μ²΄λΌ λ§Œλ“€μ–΄μ„œ λ§Œλ“€μ–΄μ§„ μž„μ‹œκ°μ²΄κ°€ λ””ν΄νŠΈ 볡사 μƒμ„±μžλΌ ν†΅ν•΄μ„œ ν• λ‹Ήλ˜κ²Œ λœλ‹€. 


1.3. 12.3 Str operations

string μ—μ„œ κ°€λŠ₯ν–ˆλ˜ μ—°μ‚°λ“€
~cpp 
cin>>s;		
cout<<s;	
s[i];		
s1 + s1		

operator[] implementation
~cpp 
class Str{
public:
	// μ΄μ „μ˜ μƒμ„±μžλ“€ 
	char& operator[](size_type i) { return data[i]; }
	const char& operator[](size_type i) const { return data[i]; }
private:
	Vec<int> data;
};
이 κ΅¬ν˜„μ˜ 세뢀적인 μž‘λ™λ°©μ‹μ€ λͺ¨λ‘ Vec 클래슀둜 μœ„μž„ν•˜μ˜€λ‹€. λŒ€μ‹ μ— const ν΄λž˜μŠ€μ™€ const κ°€ μ•„λ‹Œ ν΄λž˜μŠ€μ— λŒ€ν•œ 버전을 μ œκ³΅ν•˜μ˜€κ³ , ν‘œμ€ string ν•¨μˆ˜μ™€μ˜ 일관성 μœ μ§€λΌ μœ„ν•΄μ„œ string λŒ€μ‹ μ— char& ν˜•μ„ λ¦¬ν„΄ν•˜λ„λ‘ ν•˜μ˜€μŒ.

1.3.1. 12.3.1 μž…μΆœλ ₯ μ—°μ‚°μžλ“€

μž…λ ₯ μ—°μ‚°μžλŠ” 일견 객체의 μƒνƒœλΌ λ°”κΎΈκΈ° λ•Œλ¬Έμ— λ©€λ²„ν•¨μˆ˜λ‘œ 선언이 λ˜μ–΄μ•Ό ν•œλ‹€κ³  μƒκ°ν•˜κΈ° 쉽닀. κ·ΈλŸ¬λ‚˜ 이항 μ—°μ‚°μžμ˜ 경우 νŒŒλΌλ©”ν„°μ˜ 맡핑이 μ’Œν•­μ˜ 경우 첫번째 μš°ν•­μ˜ 경우 λ‘λ²ˆμ§ΈμΈμžλ‘œ λ°›λŠ”λ°, μ΄λ ‡κ²Œ 될 경우 λ©€λ²„ν•¨μˆ˜λ‘œ >>μ—°μ‚°μžλΌ μ˜€λ²„λ‘œλ”©ν•˜λ©΄ μš°λ¦¬κ°€ μ›Œν•˜λŠ” κ²°κ³ΌλΌ μ–»μ„ 수 μ—†λ‹€.
~cpp 
cin>>s;
cin.operator>>(s);		// istream 을 μš°λ¦¬κ°€ λ§Œλ“  객체가 μ•„λ‹ˆκΈ° λ•Œλ¬Έμ— μž¬μ •μ˜ν•  수 μ—†λ‹€.
s.operator>>(cin);		// ν‘œμ€ istream 의 ν˜•νƒœκ°€ μ•„λ‹ˆλ‹€.
s>>cin
 
상기와 같은 이유둜 operator>>λŠ” λΉ„λ©€λ²„ν•¨μˆ˜λ‘œμ„œ 선언이 λ˜μ–΄μ•Ό ν•œλ‹€.

~cpp 
std::istream& operator>>(std::istream&, Str&);
std::ostream& operator<<(std::ostream&, const Str&);

ostream& operator<<(ostream& os, const Str& s) {
	for(Str::size_type i=0; i!= s.size(); ++i)
		os<<s[i];
	return os;
}
 
μœ„μ˜ 식 처럼 μ‚¬μš©ν•˜κΈ° μœ„ν•΄μ„œλŠ” Str::size() κ°€ μ •μ˜ λ˜μ–΄μ•Όν•œλ‹€.
~cpp 
class Str{
public:
	size_type size() const { return data.size(); }
	// 이전과 동일
}
 

1.3.2. 12.3.2 ν”„λ Œλ“œ(Friend)


~cpp 
istream& operator>>(istream& is, Str& s) {
	s.data.clear();	// compile error. private λ©€λ²„λ‘œ μ ‘κ·Ό

	char c;
	while(is.get(c) && isspace(c))		// μž…λ ₯이 있고 값이 곡백이라면 λ¬΄μ‹œ
	;

	if(is) {	// EOFλΌ λ§Œλ‚˜λ©΄ μž…λ ₯ μŠ€νŠΈλ¦Όμ„ false 값을 λ¦¬ν„΄ν•œλ‹€.
		do s.data.push_back(c);	// compile error. private λ©€λ²„λ‘œ μ ‘κ·Ό
		while(is.get(c) && !isspace(C));

		if(is)		// μž…λ ₯쀑 곡백 λ¬ΈμžλΌ λ§Œλ‚¬μ„ 경우 λ°©κΈˆμ „μ— μž…λ ₯으둜 λ“€μ–΄μ™”λ˜ ν•œλ¬ΈμžλΌ λ¬΄μ‹œν•œλ‹€.
			is.unget();
	}
	return is;
}
 
μƒκΈ°μ˜ ν•¨μˆ˜λŠ” Str μžλ£Œν˜•μ— μž…λ ₯을 ν•˜κΈ° λ•Œλ¬Έμ— Str ν˜•μ— λŒ€ν•œ μ“°κΈ° κΆŒν•œμ΄ ν•„μš”ν•˜λ‹€. κ·ΈλŸ¬λ‚˜ 9.3.1절처럼 λ‹¨μˆœνžˆ μž…λ ₯ ν•¨μˆ˜λΌ λ§Œλ“€κ²Œ 되면 일반 μ‚¬μš©μžκ°€ 객체의 λ‚΄λΆ€ κ΅¬μ‘°λΌ κ±΄λ“œλ¦΄ 수 μžˆλŠ” μΈν„°νŽ˜μ΄μŠ€λΌ μ œκ³΅ν•˜λŠ” 꼴이 되기 λ•Œλ¬Έμ— μ˜³μ§€ λͺ»ν•˜λ‹€.
λ”°λΌμ„œ μš°λ¦¬λŠ” operator>>λΌ public λ©€λ²„λ‘œ λ§Œλ“€κ³  data에 λŒ€ν•œ μ“°κΈ° κΆŒν•œμ„ κ°€μ§€κ²Œ ν•΄μ„œλŠ” μ•ˆλœλ‹€.
이런 경우의 ν•¨μˆ˜λΌ friend 둜 μ •μ˜ ν•˜μ—¬ ν•΄κ²°ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
ν•¨μˆ˜λΌ friend 둜 μ •μ˜ν•˜λ©΄ 인자둜 받은 ν˜•μ—λŒ€ν•΄μ„œλŠ” ν˜•μ˜ μ ‘κ·Όμžκ°€ λ¬΄μ‹œλœλ‹€.
~cpp 
class Str {
friend std::istream& operator>>(std::istream&, Str&);
};
 
friend ν•¨μˆ˜λŠ” μ ‘κ·Όμ œμ–΄ λ ˆμ΄λΈ”μ— 영ν–₯을 받지 μ•ŠκΈ° λ•Œλ¬Έμ— 어디에 선언을 해도 λ¬΄κ΄€ν•˜λ‚˜, κ°€λŠ₯ν•˜λ©΄ 클래슀 μ„ μ–Έμ˜ 졜초 뢀뢄에 λ†“λŠ” 것이 μ’‹λ‹€.

1.3.3. 12.3.3 λ‹€λ₯Έ 이항 μ—°μ‚°μžλ“€

operator+ κ΅¬μƒν•˜κΈ°
~cpp 
s1 + s2 + s3;
 
  • operator+λŠ” 각 인수둜 λ°›λŠ” 객체의 값을 λ³€ν™”μ‹œν‚€μ§€ γ…€γ…‡γ…γ…ŽλŠ”λ‹€. λ”°λΌμ„œ λΉ„λ©€λ²„ν•¨μˆ˜λ‘œ κ΅¬ν˜„ν•˜λŠ” 것이 μ λ‹Ήν•˜λ‹€.
  • operator+λŠ” μ—°μ‚°μ˜ κ²°κ³ΌλŠ” Str ν˜•μ„ λ¦¬ν„΄ν•΄μ•Όν•œλ‹€.

    ~cpp 
     Str operator+(const Str&, const Str&);
     
    그리고 operator+=() μ—­μ‹œλ„ κ΅¬ν˜„ν•΄μ•Όν•  ν•„μš”κ°€ μžˆλ‹€.
    이런 식을 만μ±ν•˜λŠ” Str선언은 λ‹€μŒκ³Ό κ°™λ‹€.
    ~cpp 
    class Str {
    	// input operator implemented in 12.3.2/216
    	friend std::istream& operator>>(std::istream&, Str&);
    public:
    	Str& operator+=(const Str& s) {
    		std::copy(s.data.begin(), s.data.end(),
    		          std::back_inserter(data));
    		return *this;
    	}
    
    	// as before
    	typedef Vec<char>::size_type size_type;
    
    	Str() { }
    	Str(size_type n, char c): data(n, c) { }
    	Str(const char* cp) {
    		std::copy(cp, cp + std::strlen(cp), std::back_inserter(data));
    	}
    	template <class In> Str(In i, In j) {
    		std::copy(i, j, std::back_inserter(data));
    	}
    
    	char& operator[](size_type i) { return data[i]; }
    	const char& operator[](size_type i) const { return data[i]; }
    	size_type size() const { return data.size(); }
    
    private:
    	Vec<char> data;
    };
    
    // output operator implemented in 12.3.2/216
    std::ostream& operator<<(std::ostream&, const Str&);
    Str operator+(const Str&, const Str&);
     
    μƒκΈ°μ—μ„œ κ΅¬ν˜„λœ operator+= λŠ” VecλΌ copyν•¨μˆ˜λΌ μ΄μš©ν•΄μ„œ κ΅¬ν˜„ν•˜μ˜€λ‹€.
    operator+λŠ” operator+=λΌ μ΄μš©ν•΄μ„œ λ‹€μŒκ³Ό 같이 κ°„λ‹¨ν•˜κ²Œ κ΅¬ν˜„μ΄ κ°€λŠ₯ν•˜λ‹€.

    ~cpp 
    Str operator+(const Str& s, const Str& t) {
    	Str r =s;
    	r += t;
    	return r;
    }
     
    μ§€μ—­λ³€μˆ˜λ‘œ μƒμ„±λœ rλΌ λ³΅μ‚¬μƒμ„±μžλΌ ν†΅ν•΄ μƒμ„±λœ μž„μ‹œ 객체둜 λ¦¬ν„΄μ‹œν‚¨λ‹€.

1.3.4. 12.3.4 ν˜Όν•©-νƒ€μž… ν‘œν˜„μ‹(Mixed-type expression)


~cpp 
Str greeting = "Hello, " + name + "!";
 
μƒκΈ°μ˜ λ¬Έμž₯은 λ‹€μŒκ³Ό λ™μΌν•œ μˆœμ„œλ‘œ λ™μž‘ν•˜κ²Œ λœλ‹€.
~cpp 
Str temp1("Hello, ");
Str temp2 = temp1 + name;
Str temp3("!");
Str greeting = temp2 + temp3;
 
μ΄λŸ°μ‹μœΌλ‘œ λ™μž‘ν•˜κ²Œ ν•˜λ©΄ μž„μ‹œ λ³€μˆ˜μ˜ μƒμ„±μœΌλ‘œ μΈν•œ μ˜€λ²„ν—€λ“œκ°€ μƒλ‹Ήν•¨μœΌλ‘œ μ•Œ 수 μžˆλ‹€. 이런 λ¬Έμ œλΌ ν•΄κ²°ν•˜κΈ° μœ„ν•΄μ„œ string ν΄λž˜μŠ€λŠ” μžλ™λ³€ν™˜μ— μ˜μ‘΄ν•˜μ§€ μ•Šκ³ , ν”Όμ—°μ‚°μžλ“€μ˜ λͺ¨λ“  쑰합에 λŒ€ν•΄ κ²°ν•© μ—°μ‚°μžλΌ μ œκ³΅ν•œλ‹€.

1.3.5. 12.3.5 이항 μ—°μ‚°μž μ„κ³„ν•˜κΈ°

μ΄ν•­μ—°μ‚°μžλΌ μ„계할 κ²½μš°μ—λŠ” λ³€ν™˜(conversion)이 λ§Žμ€ 도움이 λœλ‹€.
μ΄ν•­μ—°μ‚°μžλŠ” λΉ„ λ©€λ²„ν•¨μˆ˜λ‘œ μ„κ³„ν•˜λŠ” 것이 μ’‹λ‹€. μ΄μœ λŠ” λ©€λ²„ν•¨μˆ˜μ˜ 경우 첫번째 μΈμžκ°€ 객체의 νŠΉμ •ν˜•μœΌλ‘œ κ³ μ •λ˜κΈ° λ•Œλ¬Έμ— μžλ™ ν˜•λ³€ν™˜μ„ μ΄μš©ν•  수 μ—†κΈ° λ•Œλ¬Έμ΄λ‹€. 즉 λŒ€μΉ­μ„±(symmetry)λΌ μœ μ§€ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
λ©€λ²„ν•¨μˆ˜λ‘œ μ΄μš©λ˜λŠ” 경우 μš°ν•­ ν”Όμ—°μ‚°μžκ°€ μžλ™ ν˜•λ³€ν™˜λ˜μ–΄ μ’Œν•­κ³Ό μΌμΉ˜ν•˜μ§€ μ•ŠλŠ” 것과 같은 λ¬Έμ œκ°€ λ°œμƒν•  수 μž‡λ‹€.
반면 λŒ€μž…μ—°μ‚°μžλŠ” μ—°μ‚°μ˜ κ²°κ³Όκ°€ νŠΉμ • 객체에 영ν–₯을 μ£Όμ–΄μ•Ό ν•˜κΈ° λ•Œλ¬Έμ— λ°˜λ“œμ‹œ 클래슀의 λ©€λ²„ν•¨μˆ˜λ‘œ μž‘μ„±ν•˜λŠ” 것이 μ˜³λ‹€.

1.4. 12.4 Some conversions are hazardous

11.2.2 μ—μ„œμ˜ explicit ν‚€μ›Œλ“œμ˜ μ‚¬μš©μ€ μžλ™ ν˜•λ³€ν™˜μ— 이용이 λ˜λŠ” 단일 μΈμžλΌ λ°›λŠ” μƒμ„±μžμ˜ ν–‰μœ„λΌ μ œν•œν•¨μœΌλ‘œμ¨ ν”„λ‘œκ·Έλž˜λ¨Έκ°€ μ›μΉ˜ μ•ŠλŠ” λ³€ν™˜μ„ λ§‰λŠ” κΈ°λŠ₯을 ν•œλ‹€.
λ§Œμ•½ explicit 으둜 Vec 클래슀의 Vec<T>::Vec(size_type n) 을 μ •μ˜ ν–ˆλ‹€κ³  κ°€μ •ν•˜κ³  λ‹€μŒμ˜ μ½”λ“œλΌ λ³΄μž
~cpp 
Vec<string> p = frame(42);
μ›λž˜μ˜ μ˜λ„ : 42λΌλŠ” κΈ€μžμ— ν…Œλ‘λ¦¬κ°€ μ²˜μ§„ κ²°κ³Ό
μ‹€ν–‰ : 42개의 빈 행에 ν…Œλ‘λ¦¬κ°€ 그렀진 κ²°κ³Ό

일반적으둜 객체의 κ΅¬μ‘°λΌ κ²°μ •ν•˜λŠ” μƒμ„±μžλŠ” explicit 으둜 λ‚΄μš©μ„ κ΅¬μ„±ν•˜λŠ” κ²½μš°μ—λŠ” 암묡적인 싀행이 κ°€λŠ₯ν•˜λ„λ‘ ν•˜λŠ” 것이 μΌλ°˜μ μ΄λ‹€.
Vec의 경우처럼 size_type 을 인자둜 λ°›λŠ” κ²½μš°μ—λŠ” μš”μ†Œμ˜ κ°œμˆ˜λΌλŠ” κ΅¬μ‘°λΌ κ²°μ •ν•˜κΈ° λ•Œλ¬Έμ— explicit 이 μ λ‹Ήν•˜λ‹€.

1.5. 12.5 Conversion operators

클래슀의 μ œμž‘μžλ“€μ€ λͺ…μ‹œμ μœΌλ‘œ λ³€ν™˜ μ—°μ‚°μž(conversion operator)λΌ μ •μ˜ν•˜μ—¬ κ·Έ 객체의 νƒ€μž…μ΄ λͺ©μ μΈ 객체의 νƒ€μž…μœΌλ‘œ λ³€ν™˜ν•˜λŠ” 것을 μ •ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
λ³€ν™˜ μ—°μ‚°μžμ˜ λͺ¨μ–‘은 operator λͺ©μ μ΄ λ˜λŠ” νƒ€μž…μ˜ μ΄λ¦„μœΌλ‘œ μ •μ˜λœλ‹€.
~cpp 
class Student_info {
public:
	operator double();
	// ...
}

...
vector<Student_info> vs;
...
double d = 0;
d += vs[i];		// 이와 같이 ν˜•λ³€ν™˜μ„ ν•  수 μžˆλ‹€.

이런 μžλ™ ν˜•λ³€ν™˜μ΄ 이용된 ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬λ‘œλŠ” cin λ“€ 수 μžˆλ‹€.
~cpp 
if (cin>>x) { /* ... */ }

cin>>x
if (cin) { /* ... */ }
이경우 istream 은 void *λΌ λ¦¬ν„΄ν•˜κ²Œ λœλ‹€.
그런데 istream ν΄λž˜μŠ€λŠ” istream::operator void*()λΌ μ •μ˜ν•˜μ—¬ λ§Œμ•½ μž…λ ₯에 λ¬Έμ œκ°€ 있으면 void* ν˜•μœΌλ‘œ 0을 그렇지 μ•Šμ€ κ²½μš°μ—λŠ” void* λΌ λ¦¬ν„΄ν•˜κ²Œ ν•¨μœΌλ‘œμ¨ 마치 bool ν˜•μ²˜λŸΌ μ‚¬μš©ν•˜λŠ” 것이 κ°€λŠ₯ν•˜λ‹€.
void*둜 리턴값을 μ •ν•¨μœΌλ‘œμ¨ bool 둜 μ •ν–ˆμ„ λ•Œ λ‚˜νƒ€λ‚˜λŠ” μžλ™ν˜• λ³€ν™˜(μ •μˆ˜ν˜•μœΌλ‘œμ˜) λ¬Έμ œμ μ„ ν•΄κ²°ν•  수 μžˆλ‹€.

void* νƒ€μž…μ˜ ν¬μΈν„°λŠ” μ–΄λ–€ 객체라도 가리킬 수 μžˆλŠ” 포인터 이λ€λ‘œ μœ λ‹ˆλ²„μ…œ 포인터(universal point)라고 λΆ€λ₯Έλ‹€. κ·ΈλŸ¬λ‚˜ κ·ΈλŸ¬λ‚˜ 포인털λ₯΄ μ—­μ°Έμ‘°ν•˜λŠ” 것은 λΆˆκ°€λŠ₯ν•˜λ‹€. κ·ΈλŸ¬λ‚˜ bool νƒ€μž…μœΌλ‘œμ˜ λ³€ν™˜μ€ κ°€λŠ₯ν•˜λ‹€.

1.6. 12.6 Conversions and memory management

char*, const char* ν˜•μœΌλ‘œμ˜ λ³€ν™˜
~cpp 
class Str{
public:
	operator char* ();
	operator const char* () const;
	// 이전과 동일
private:
	Vec<char> data;
};

Str s;
ifstream in(s);
ν•˜λ‹¨μ˜ μ½”λ“œκ°€ μ˜¬λ°”λ₯΄κ²Œ λ™μž‘ν•˜μ§€ λͺ»ν•œλ‹€. λ³€ν™˜λ˜λŠ” ν˜•μ΄ μš”κ΅¬λ˜λŠ” ν˜•κ³Ό μ „ν˜€ λ§žμ§€ μ•ŠκΈ° λ•Œλ¬Έμ΄λ‹€.
κ·Έλ ‡λ‹€κ³ ν•΄μ„œ dataκ°€ κ°€λ¦¬ν‚€λŠ” ν¬μΈν„°λΌ λ°”λ‘œ λ„˜κΈ°λ©΄ ν”„λ‘œκ·Έλž¨μ—μ„œ κ·Έ ν¬μΈν„°λΌ ν†΅ν•΄μ„œ λ°μ΄ν„°μ˜ μˆ˜μ •μ„ ν•  수 μž‡κΈ° λ•Œλ¬Έμ— μΊ‘μŠν™”μ˜ μž₯점이 사라진닀.
이 것을 ν•΄κ²°ν•  방법은 data의 볡사본을 λ§Œλ“€μ–΄μ„œ κ·Έ 것을 λ¦¬ν„΄ν•˜κ³  μ‚¬μš©μ΄ λλ‚œ λ’€μ—λŠ” 볡사본을 μ œκ±°ν•˜λŠ” λ°©μ‹μœΌλ‘œ 해결이 κ°€λŠ₯ν•˜λ‹€.
κ·ΈλŸ¬λ‚˜ μ‚¬μš©μžλŠ” 암묡적 λ³€ν™˜μ‚¬μ΄μ—μ„œ μ†Œλ©Έ μ‹œμΌœμ•Όν•  ν¬μΈν„°λΌ μ°Ύμ„ 수 μ—†λ‹€.

ν‘œμ€ string 의 κ²½μš°μ—λŠ” 3가지 μ’…λ£Œμ˜ char* ν˜•μœΌλ‘œμ˜ λ³€ν™˜μ„ μ œκ³΅ν•˜λŠ”λ°
c_str() string λ‚΄λΆ€μ˜ char*λΌ λ¦¬ν„΄ν•œλ‹€. λ”°λΌμ„œ μ‚¬μš©μžκ°€ deleteλΌ ν•  μˆ˜λŠ” μ—†μ§€λ§Œ ν¬μΈν„°λΌ μ–»μ–΄μ„œ μˆ˜μ •ν•  수 μžˆλ‹€.
data() c_str()κ³Ό λΉ„μŠ·ν•˜μ§€λ§Œ '\0'둜 μ’…λ£Œλ˜λŠ” λ¬Έμžμ—΄μ΄ μ•„λ‹Œ 배열을 λ¦¬ν„΄ν•œλ‹€.
copy(char* ) 인자둜 받은 char*의 곡간에 λ‚΄λΆ€μ˜ λ¬Έμ œλ“€μ„ 볡사해 λ„£λŠ”λ‹€. char*곡간은 ν”„λ‘œκ·Έλž¨κ°€ ν• λ‹Ήν•˜κ³  ν•΄μ œν•˜λŠ” 곡간이닀.

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