Contents
- 1. Shifting from C to C++
- 2. Memory management
- 2.1. Item 5: Use the same form in corresponding uses of new and delete
- 2.2. Item 6: Use delete on pointer members in destructors
- 2.3. Item 7: Be prepared for out-of-memory conditions.
- 2.4. Item 8: Adhere to convention when writing operator new and operator delete
- 2.5. Item 9: Avoid hiding the "normal" form of new
- 2.6. Item 10: Write operator delete if you write operator new
- 3. Constructors, Destructors, and Assignment Operators (ํด๋์ค์ ๊ดํ๊ฒ๋ค.)
- 3.1. Item 11: Declare a copy constructor and an assignment operator for classes with dynamically allocated memory
- 3.2. Item 12: Prefer initialization to assignment in constructors
- 3.3. Item 13: List members in an initialization list in the order in which they are declared
- 3.4. Item 14: Make sure base classes have virtual destructors
- 3.5. Item 15: Have operator= return a reference to *this
- 3.6. Item 16: Assign to all data members in operator=
- 3.7. Item 17: Check for assignment to self in operator=
- 4. Classes and Functions: Design and Declaration
- 4.1. Item 18. ์ต์ํ์ ์์ ํ ํด๋์ค ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ตฌํ๋ค.
- 4.2. Item 19. ๋ฉค๋ฒ ํจ์, ๋น๋ฉค๋ฒ ํจ์ ๋ฐ ํ๋ ๋ ํจ์๋ฅผ ๊ตฌ๋ณํ๋ค.
- 4.3. Item 20. ๋ฐ์ดํฐ ๋ฉค๋ฒ๋ฅผ ๊ณต์ฉ(public) ์ธํฐํ์ด์ค์ ํฌํจ์ํค์ง ์๋๋ค.
- 4.4. Item 21. ๊ฐ๋ฅํ const๋ฅผ ์ด์ฉํ๋ค.
- 4.5. ํญ๋ชฉ 22. ๊ฐ์ ์ํ ํธ์ถ๋ณด๋ค๋ ๋ ํผ๋ฐ์ค์ ์ํ ํธ์ถ์ ์ ํธํ๋ค.
- 4.6. ํญ๋ชฉ 23. ๊ฐ์ฒด ๋ฐํ์ ๋ ํผ๋ฐ์ค๋ฅผ ๋ฐํํ์ง ์๋๋ค.
- 4.7. ํญ๋ชฉ 24. ํจ์ ์ค๋ฒ๋ก๋ฉ๊ณผ ๋ํดํธ ์ธ์๊ฐ ์ค์์ ์ฃผ์๊น๊ฒ ์ ํํ๋ค.
- 4.8. ํญ๋ชฉ 25. ํฌ์ธํฐ๋ ์์นํ ํ์ ์์ ์ค๋ฒ๋ก๋ฉ์ ํผํ๋ค.
- 4.9. ํญ๋ชฉ 26. ์ ์ฌ์ ๋ชจํธ์ฑ์ ๊ฒฝ๊ณํ๋ค.
- 4.10. ํญ๋ชฉ 27. ์๋ํ์ง ์์ ๋ด๋ถ ์์ฑ ๋ฉค๋ฒ ํจ์์ ์ด์ฉ์ ๋ช ์์ ์ผ๋ก ๋ง๋๋ค.
- 4.11. ํญ๋ชฉ 28. ์ ์ญ ๋ค์์คํ์ด์ค๋ฅผ ๋ถํ ํ๋ค.
- 5. ํด๋์ค์ ํจ์ : ๊ตฌํ
- 5.1. ํญ๋ชฉ 29. ๋ด๋ถ ๋ฐ์ดํฐ์ ๋ํ "ํธ๋ค"์ ๋ฆฌํดํ๋ ๊ฒ์ ํผํด๋ผ.
- 5.2. ํญ๋ชฉ 30. ์ ๊ทผํ๊ธฐ ์ด๋ ค์ด ๋ฉค๋ฒ์ ๋ํ ๋น์์ ํฌ์ธํฐ๋ ๋ ํผ๋ฐ์ค๋ฅผ ๋ฆฌํดํ๋ ๋ฉค๋ฒ ํจ์ ์ฌ์ฉ์ ํผํ๋ผ.
- 5.3. ํญ๋ชฉ 31. ์ง์ญ ๊ฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋ ํจ์ ๋ด์์ new๋ฅผ ์ด์ฉํด ์ด๊ธฐํ๋ ํฌ์ธํฐ๋ฅผ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ์ง ๋ง๋ผ.
- 5.4. ํญ๋ชฉ 32. ๋ณ์ ์ ์๋ ๊ฐ๋ฅํ ๋ค๋ก ๋ฆ์ถฐ๋ผ.
- 5.5. ํญ๋ชฉ 33. ์ธ๋ผ์ธ์ ์ ๋ณ์ ์ผ๋ก ์ฌ์ฉํ๋ผ.
- 5.6. ํญ๋ชฉ 34. ํ์ผ๊ฐ์ ์ปดํ์ผ ์์กด์ฑ(dependency)์ ์ต์ํํ๋ผ.
- 6. ์ธ์คํด์ค์ ๊ฐ์ฒด์งํฅ ์ค๊ณ
- 6.1. ํญ๋ชฉ 35. public ๊ณ์น์ด "isa"๋ฅผ ๋ชจ๋ธ๋งํ๋๋ก ํ๋ผ.
- 6.2. ํญ๋ชฉ 36. ์ธํฐํ์ด์ค ๊ณ์น๊ณผ ๊ตฌํ ๊ณ์น์ ์ฐจ์ด์ ์ ์ดํดํ๋ผ.
- 6.3. ํญ๋ชฉ 37. ๊ณ์น๋ ๋น๊ฐ์ ํจ์๋ฅผ ์ฌ์ ์ํ์ง ์๋๋ก ํ๋ค.
- 6.4. ํญ๋ชฉ 38. ๊ณ์น๋ ๋ถ์ฌ ์ธ์๊ฐ์ ์ฌ์ ์ํ์ง ์๋๋ก ํ๋ค.
- 6.5. ํญ๋ชฉ 39. ๊ณ์ธต๋์ ์๋์ชฝ ํด๋์ค๋ฅผ ๋ค์ด์บ์คํธ(downcast)ํ์ง ์๋๋ก ํ๋ค.
- 6.6. ํญ๋ชฉ 40. ๋ ์ด์ด๋ง(layering)์ ํตํด "๊ฐ์ง๊ณ ์๋" ๊ฒ๊ณผ "์ฌ์ฉํ์ฌ ๊ตฌํ๋" ๊ฒ์ ๋ชจ๋ธ๋งํ๋๋ก ํ์.
- 6.7. ํญ๋ชฉ 41. ๊ณ์น๊ณผ ํ ํ๋ฆฟ๊ณผ์ ์ฐจ์ด์ ์ ์ดํดํ๋ค.
- 6.8. ํญ๋ชฉ 42. private ๊ณ์น์ ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ผ.
- 6.9. ํญ๋ชฉ 43. ๋ค์ค ๊ณ์น์ ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋๋ก ํ๋ผ.
- 6.10. ํญ๋ชฉ 44. ์๋ฏธํ๋ ๋ฐ๋ฅผ ํํํ๋๋ก ํ๋ผ. ์์ ์ด ํํํ ๊ฒ์ ์๋ฏธ๋ฅผ ์ดํดํ๋๋ก ํ๋ผ.
- 7. ๋ฏธ๋ฌํ ๋ถ๋ถ
- 7.1. ํญ๋ชฉ 45. C++๊ฐ ์๋ฐํ๊ฒ ์ด๋ค ํจ์๋ฅผ ๋ง๋ค์ด์ฃผ๊ณ ํธ์ถํ๋์ง ์ดํดํ๊ธฐ
- 7.2. ํญ๋ชฉ 46. ์คํ ์๊ฐ ์๋ฌ๋ณด๋ค๋ ์ปดํ์ผ ์๊ฐ๊ณผ ๋งํฌ ์๊ฐ ์๋ฌ๊ฐ ์ข๋ค.
- 7.3. ํญ๋ชฉ 47. ๋น์ง์ญ ์ ์ (Non-local static) ๊ฐ์ฒด๋ ์ฌ์ฉ๋๊ธฐ ์ ์ ์ด๊ธฐํ๋๋๋ก ํด์ผ ํ๋ค.
- 7.4. ํญ๋ชฉ 48. ์ปดํ์ผ๋ฌ์ ๊ฒฝ๊ณ (Warning)์ ์ฃผ์๋ฅผ ๊ธฐ์ธ์ฌ๋ผ.
- 7.5. ํญ๋ชฉ 49. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ ์์๋์.
- 7.6. ํญ๋ชฉ 50. C++์ ๋ํ ์ดํด๋ฅผ ๋ํ๋ผ.
- 8. Thread
1.1. Item1: Prefer const and inline to #define ¶
preprocessor(์ ์ฒ๋ฆฌ๊ธฐ)๋ณด๋ค๋ compiler๋ฅผ ์ ํธํ๋ค๋ ๋ป.
DeleteMe #define(preprocessor)๋ฌธ์ ๋ํด const์ inline์(compile)์ ์ด์ฉ์ ์ถ์ฒํ๋ค. --์๋ฏผ
DeleteMe #define(preprocessor)๋ฌธ์ ๋ํด const์ inline์(compile)์ ์ด์ฉ์ ์ถ์ฒํ๋ค. --์๋ฏผ
-> const
instead of upper..
define ๋ ASPECT_RATIO ๋ ์์๋ 1.653์ผ๋ก ๋ณ๊ฒฝ๋๊ธฐ๋๋ฌธ์ ์ปดํ์ผ๋ฌ๋ ASPECT_RATIO ๋๊ฒ์ด ์๋ค๋ ๊ฒ์ ๋ชจ๋ฅด๊ณ symbol table ์?๋ค์ด๊ฐ์ง ์๋๋ค. ์ด๋ debugging์ ํ ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. -์ธํ
#define -> inline (๋งคํฌ๋ก ์ฌ์ฉ์)

#define ๋ฌธ์ const์ inline์ผ๋ก ๋์ฒดํด์ ์จ๋, #ifdef/#ifndef - #endif ๋ฑ.. ์ด์ ์ ์ฌํ ๊ฒ๋ค์
์์ง๊น์ง ์ ์ฉํ๊ฒ ์ฌ์ฉ๋๋ฏ๋ก, ์์ธํ์๋ ์๊ฒ ์ฃ ?
ํก์ค์์ค.
~cpp #define ASPECT_RATIO 1.653ASPECT_RATIO๋ ์์ค์ฝ๋๊ฐ ์ปดํ์ผ๋ก ๋ค์ด๊ฐ๊ธฐ ์ ์ ์ ์ฒ๋ฆฌ๊ธฐ์ ์ํด ์ ๊ฑฐ๋๋ค.
instead of upper..
define ๋ ASPECT_RATIO ๋ ์์๋ 1.653์ผ๋ก ๋ณ๊ฒฝ๋๊ธฐ๋๋ฌธ์ ์ปดํ์ผ๋ฌ๋ ASPECT_RATIO ๋๊ฒ์ด ์๋ค๋ ๊ฒ์ ๋ชจ๋ฅด๊ณ symbol table ์?๋ค์ด๊ฐ์ง ์๋๋ค. ์ด๋ debugging์ ํ ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. -์ธํ
~cpp const double ASPECT_RATIO = 1.653์ฑ ์์ ์ธ๊ธํ ๋๊ฐ์ง.
~cpp 1. ์์ ํฌ์ธํฐ(constant pointer)๋ฅผ ์ ์ํ๊ธฐ๊ฐ ๋ค์ ๊น๋ค๋ก์ ์ง๋ค๋ ๊ฒ. - ex - const char * const authorName = "Scott Meyers"; 2. ์์์ ์์ญ์ ํด๋์ค๋ก ์ ํํ๊ธฐ ์ํด์ ์์๋ฅผ ๋ฉค๋ฒ๋ก ๋ง๋ค์ด์ผ ํ๋ฉฐ ๊ทธ ์์์ ๋ํ ๋จ ํ๊ฐ์ ๋ณต์ฌ๋ณธ์ด ์๋ค๋ ๊ฒ์ ํ์ ํ๊ธฐ ์ํด์ static์ผ๋ก ๋ฉค๋ฒ ๋ณ์๋ฅผ ๋ง๋ค์ด์ผ ํ๋ค. - ex - // header. class GamePlayer { private: static const int NUM_TURNS = 5; // ์์ ์ ์ธ! (์ ์ธ๋ง ํ๊ฒ์) int scores[NUM_TURNS]; // ์์์ ์ฌ์ฉ. } // source file ... const int GamePlayer::NUM_TURNS; // ์ ์๋ฅผ ๊ผญํด์ฃผ์ด์ผ ํ๋ค. ...
#define -> inline (๋งคํฌ๋ก ์ฌ์ฉ์)
- inline: ํจ์ ํธ์ถ๋ก ์ธํ ์ค๋ฒํค๋๋ฅผ ์ค์ผ์ ์๋.. ๊ฑฐ์๊ธฐ. ๊ถ๊ธํ๋ฉด ์ฑ
์ฐพ์๋ณด์ธ์.
~cpp - ex - #define max(a,b) ((a) > (b) ? (a) : (b)) // ๋งคํฌ๋ก ์์ฑ์์๋ ์ธ์ ๋ ๋งคํฌ๋ก ๋ชธ์ฒด์ ๋ชจ๋ ์ธ์๋ค์ ๊ดํธ๋ก ๋ฌถ์ด ์ฃผ์ด์ผ ํ๋ค. // ์์ธ์ง๋ ๋ค๋ค ์๊ฒ์ด๋ค. // #define ์ inline์ผ๋ก.. inline int max(int a, int b) { return a > b ? a : b; } // intํ์ผ๋ก๋ง ์ ํ ๋์ด์๋ค.. // template์ผ๋ก template class<T> inline const T& max (const T& a, const T& b) { return a > b ? a : b; }const์ inline์ ์ฐ์๋ ์๊ธฐ์์ต๋๋ค. --; ์ ๊ทธ๋ฐ์ง๋ ์์๋ ๋ถ๊ป์ ๊ธ์ข ๋จ๊ธฐ์๊ตฌ์.

#define ๋ฌธ์ const์ inline์ผ๋ก ๋์ฒดํด์ ์จ๋, #ifdef/#ifndef - #endif ๋ฑ.. ์ด์ ์ ์ฌํ ๊ฒ๋ค์
์์ง๊น์ง ์ ์ฉํ๊ฒ ์ฌ์ฉ๋๋ฏ๋ก, ์์ธํ์๋ ์๊ฒ ์ฃ ?
๋งคํฌ๋ก๋ ๋ง ๊ทธ๋๋ก ์นํ์ด๊ธฐ ๋๋ฌธ์ ๋ฒ๊ทธ ๋ฐ์ํ ํ๋ฅ ์ด ๋์. ์์์ ์ธ์ด๋ ํจ์์ ์ธ๊ฐ์ ๊ฒฝ์ฐ๋ ๊ฐ๊ธ์ const ๋ inline์ผ๋ก ๋์ฒดํ๋๊ฒ ์ข๊ฒ ์ง. (์ผ.. ๊ทธ๋๋ ์ค์ ๋ก ์งค๋๋ ์์ ์ ์ธํ ๋๋ #define ๋จ์ฉ ๊ฒฝํฅ์ด..
๊ทธ๋ผ.. ํญ๋ชฉ1 end.ํก์ค์์ค.
1.3. Item 3: Prefer new and delete to malloc and free ¶
* malloc & free
- ์์ฑ์(constructor)์ ์๋ฉธ์(destructor)์ ์กด์ฌ๋ฅผ ๋ชจ๋ฅธ๋ค.
- ์์ฑ์ ๋ฐ ์๋ฉธ์์ ์ ์ ํ ์ํธ๋์ํ๊ธฐ ๋๋ฌธ์. they are clearly the superior choice.
1.4. Item 4: Prefer C++-style comments ¶
/* */: C style์ ์ฃผ์
// : C++ style์ ์ฃผ์
์๊ธฐ๋ง์ ์ฃผ์์ ์ฐ๋ฉด ๋๋๊ฑฐ ์๋์ผ? ๋. ์ฃผ์๋ค๋๊ฒ ์ ์ผ ์ซ์๋ฐ. ^^;
๋ช๋ฌ ์ง๋ ํ๋ก๊ทธ๋จ์ ์๊ธฐ๊ฐ ๋ง๋ ๊ฒ ์๋๊ฑฐ์ผ!? , ์์ ์ ์๋ฏผ์ด ํ์ด ์๊ธฐํด์ค.. --;; ใ ใ ใ ๋๊ฐ..
// : C++ style์ ์ฃผ์
์๊ธฐ๋ง์ ์ฃผ์์ ์ฐ๋ฉด ๋๋๊ฑฐ ์๋์ผ? ๋. ์ฃผ์๋ค๋๊ฒ ์ ์ผ ์ซ์๋ฐ. ^^;
๋ช๋ฌ ์ง๋ ํ๋ก๊ทธ๋จ์ ์๊ธฐ๊ฐ ๋ง๋ ๊ฒ ์๋๊ฑฐ์ผ!? , ์์ ์ ์๋ฏผ์ด ํ์ด ์๊ธฐํด์ค.. --;; ใ ใ ใ ๋๊ฐ..
2. Memory management ¶
๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ๋ฐ๋ก ์ป๋ ๊ฒ๊ณผ ๊ทธ๊ฒ์ ํจ์จ์ ์ผ๋ก ์ํํ๊ฒ ๋ง๋๋๊ฒ(?)์ ๊ดํ ์๊ธฐ๋ค.
2.1. Item 5: Use the same form in corresponding uses of new and delete ¶
~cpp string *stringArray = new string[100]; ... delete stringArray; // delete๋ฅผ ์๋ชป ์จ์ฃผ์์ต๋๋ค. // stringArray์ ์ํด ๊ฐ๋ฅด์ผ์ง 100๊ฐ์ string object๋ค์ค์ 99๊ฐ๋ ์ ๋๋ก ์ ๊ฑฐ๊ฐ ์๋จ.
- new๋ฅผ ํธ์ถํ ๋ []๋ฅผ ์ด์ฉํ๋ค๋ฉด delete์ ํธ์ถ์์๋ []๋ฅผ์ด ์ฉํ๋ค. ๊ฐ๋จ๊ฐ๋จ!
~cpp typedef string AddressLines[4]; // ๊ฐ์ธ ์ฃผ์๋ 4๊ฐ์ ์ค์ ์ฐจ์งํ๊ณ // ๊ฐ๊ฐ์ด ์คํธ๋ง์ด๋ค. ... string *pal = new AddressLines; // "new AddressLines" returns a string *, just "new string[4]".. ... delete pal; // ์ด๋ป๊ฒ ๋ ์ง ๋ชฐ๋ผ~ delete [] pal; // fine.์ด๋ฐ ํผ๋(?)์ ํผํ๊ธฐ ์ํด์ ๋ฐฐ์ด ํ์ ๋ค์ ๋ํ typedef๋ฅผ ํผํ๋ฉด ๋์ง๋ญ.

2.2. Item 6: Use delete on pointer members in destructors ¶
๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ํํ๋ ํด๋์ค๋ค์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ธฐ ์ํด์ ์์ฑ์์ new๋ฅผ ์ด๋ค. (CString class๊ฐ์๊ฒ๋ค?)
๋์ค์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํ๊ธฐ ์ํด์ ์๋ฉธ์์์ delete๋ฅผ ์ฌ์ฉํ๋ค.
๊ทธ๋ฌ๋, ๋์ค์ ์ด๋ ๊ฒ ๋ง๋ ํด๋์ค๋ฅผ ๋๊ตฐ๊ฐ๊ฐ ๊ฐ์ ๋ ๊ฒฝ์ฐ ๊ทธ๋ฆฌ๊ณ , ๊ฐ์ ๋ ํด๋์ค์์ ํฌ์ธํฐ ๋ฉค๋ฒ๋ฅผ ์ถ๊ฐํ๊ฒ
๋๋ค๋ฉด ๋ฐ์ ์ธ๊ฐ์ง๋ฅผ ์์งํ๊ธธ ๋ฐ๋๋ค.
์ธ๋ฒ์งธ ์๋ฉธ์์์ ํฌ์ธํฐ ์ญ์ ์ ๊ดํ ๊ฒ์ ์ ๋๋ก ์ํด์ฃผ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ ์ถ(memory leak)์ผ๋ก ๊ทธ๋ฅ ์ฒ๋ฆฌ๋๊ธฐ ๋๋ฌธ์ ํด๋์ค์ ํฌ์ธํฐ ๋ฉค๋ฒ๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ๋ฐ๋์ ๋ช ์ฌํด์ผ ํ๋ค.
๋์ค์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํ๊ธฐ ์ํด์ ์๋ฉธ์์์ delete๋ฅผ ์ฌ์ฉํ๋ค.
๊ทธ๋ฌ๋, ๋์ค์ ์ด๋ ๊ฒ ๋ง๋ ํด๋์ค๋ฅผ ๋๊ตฐ๊ฐ๊ฐ ๊ฐ์ ๋ ๊ฒฝ์ฐ ๊ทธ๋ฆฌ๊ณ , ๊ฐ์ ๋ ํด๋์ค์์ ํฌ์ธํฐ ๋ฉค๋ฒ๋ฅผ ์ถ๊ฐํ๊ฒ
๋๋ค๋ฉด ๋ฐ์ ์ธ๊ฐ์ง๋ฅผ ์์งํ๊ธธ ๋ฐ๋๋ค.
- Initialization of the pointer in each of the constructors. If no memory is to be allocated to the pointer in a particular constructor, the pointer should be initialized to 0 (i.e., the null pointer). - ์์ฑ์ ๊ฐ๊ฐ์์ ํฌ์ธํฐ ์ด๊ธฐํ
- Deletion of the existing memory and assignment of new memory in the assignment operator. - ํฌ์ธํฐ ๋ฉค๋ฒ์ ๋ค์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ ๊ฒฝ์ฐ ๊ธฐ์กด์ ๋ฉ๋ชจ๋ฆฌ ํด์ ์ ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น
- Deletion of the pointer in the destructor. - ์๋ฉธ์์์ ํฌ์ธํฐ ์ญ์
์ธ๋ฒ์งธ ์๋ฉธ์์์ ํฌ์ธํฐ ์ญ์ ์ ๊ดํ ๊ฒ์ ์ ๋๋ก ์ํด์ฃผ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ ์ถ(memory leak)์ผ๋ก ๊ทธ๋ฅ ์ฒ๋ฆฌ๋๊ธฐ ๋๋ฌธ์ ํด๋์ค์ ํฌ์ธํฐ ๋ฉค๋ฒ๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ๋ฐ๋์ ๋ช ์ฌํด์ผ ํ๋ค.
2.3. Item 7: Be prepared for out-of-memory conditions. ¶
๋ฉ๋ชจ๋ฆฌ๊ฐ ๋ถ์กฑํ ๊ฒฝ์ฐ ์ ์ ํ ์ฒ๋ฆฌ๋ฅผ ํด์ค๋ค๋ ์๊ธฐ์ธ๊ฒ ๊ฐ์๋ฐ...
์๋ชจ๋ฅด๊ฒ ์. ์์๋ ๋ถ์ ์ค๋ช ์ด ๋งค์ฐ ํ์ํจ
Comment ๋ถํํด์
๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ์์ ๋ํ ์์ธ์ฒ๋ฆฌ๋ฅผ ๋๋นํด๋์ด๋ผ ์ ๋๋ฉด ์ ๋นํ ๊ฒ ๊ฐ์๋ฐ.
์๋ชจ๋ฅด๊ฒ ์. ์์๋ ๋ถ์ ์ค๋ช ์ด ๋งค์ฐ ํ์ํจ
Comment ๋ถํํด์
๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ์์ ๋ํ ์์ธ์ฒ๋ฆฌ๋ฅผ ๋๋นํด๋์ด๋ผ ์ ๋๋ฉด ์ ๋นํ ๊ฒ ๊ฐ์๋ฐ.
set_new_handler๋ฅผ ์ด์ฉํ memory ํ ๋น ์คํจ์ฒ๋ฆฌ.
๊ทธ๋ฆฌ๊ณ , class๋ด ์์ operator new์ set_new_handler๋ฅผ ์ ํด ์ค์ผ๋ก์จ ํด๋น class๋ง์ ๋ ํน(?)ํ
๋์์ ๊ตฌํํ ์ ์๋ค.
~cpp typedef void (* new_handler) {}; // ํจ์ pointer new_handler set_new_handler (new_handler p) throw (); ... // ์ฐ์ฐ์ new๊ฐ ์ถฉ๋ถํ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ์ง ๋ชปํ ๊ฒฝ์ฐ ํธ์ถ๋ ํจ์ void noMoreMemory () { cerr << "Unable to satisfy request for memory\n"; abort (); } ... void main () { set_new_handler (noMoreMemory); int *pVigdataArray = new int [100000000]; // 100000000๊ฐ์ ์ ์๊ณต๊ฐ์ ํ ๋นํ ์ ์๋ค๋ฉด noMoreMemory๊ฐ ํธ์ถ. ... }
๊ทธ๋ฆฌ๊ณ , class๋ด ์์ operator new์ set_new_handler๋ฅผ ์ ํด ์ค์ผ๋ก์จ ํด๋น class๋ง์ ๋ ํน(?)ํ
๋์์ ๊ตฌํํ ์ ์๋ค.
~cpp class X { public: static new_handler set_new_handler(new_handler p); static void * operator new(size_t size); private: static new_handler currentHandler; }; ... // source file (??.cpp) new_handler X::currentHandler; // sets currentHandler // to 0 (i.e., null) by // default new_handler X::set_new_handler(new_handler p) { new_handler oldHandler = currentHandler; currentHandler = p; return oldHandler; } void * X::operator new(size_t size) { new_handler globalHandler = // install X's std::set_new_handler(currentHandler); // handler void *memory; try { // attempt memory = ::operator new(size); // allocation } catch (std::bad_alloc&) { // restore std::set_new_handler(globalHandler); // handler; throw; // propagate } // exception std::set_new_handler(globalHandler); // restore // handler return memory; } ... void noMoreMemory(); // decl. of function to // call if memory allocation // for X objects fails ... X::set_new_handler(noMoreMemory); // set noMoreMemory as X's // new-handling function X *px1 = new X; // if memory allocation // fails, call noMoreMemory string *ps = new string; // if memory allocation // fails, call the global // new-handling function // (if there is one) X::set_new_handler(0); // set the X-specific // new-handling function // to nothing (i.e., null) X *px2 = new X; // if memory allocation // fails, throw an exception // immediately. (There is // no new-handling function // for class X.)๋ด ์๊ฐ์๋ ์ด๋ฐ๊ฒ ์๋ค๋ผ๊ณ ๋ง ์์๋๋ฉด ์ข์๊ฒ ๊ฐ๋ค. --;
2.4. Item 8: Adhere to convention when writing operator new and operator delete ¶
operator new ์ operator delete ์ ์์ฑ์ ๋ฐ๋ผ์ผ ํ ๊ฒ๋ค.
''- ํ ๋น ๋ฃจํด๋ค์ด new ํธ๋ค๋ฌ ํจ์(memory ํ ๋น์ ์์ธ ์ฒ๋ฆฌ๊ฐ์ ๊ฑฐ๋ค) ๋ฅผ ์ง์ํ๊ณ
ํฌ๊ธฐ๊ฐ 0์ธ ์๊ตฌ๋ค์ ์ฌ๋ฐ๋ก ์ฒ๋ฆฌํ ์ ์๋ค.
- ํ ๋นํด์ ๋ฃจํด๋ค์ด ๋ ํฌ์ธํฐ์ ๋์ฒํ ์ ์๋ค.
''
''- ํ ๋น ๋ฃจํด๋ค์ด new ํธ๋ค๋ฌ ํจ์(memory ํ ๋น์ ์์ธ ์ฒ๋ฆฌ๊ฐ์ ๊ฑฐ๋ค) ๋ฅผ ์ง์ํ๊ณ
ํฌ๊ธฐ๊ฐ 0์ธ ์๊ตฌ๋ค์ ์ฌ๋ฐ๋ก ์ฒ๋ฆฌํ ์ ์๋ค.
- ํ ๋นํด์ ๋ฃจํด๋ค์ด ๋ ํฌ์ธํฐ์ ๋์ฒํ ์ ์๋ค.
''
๋ฉค๋ฒ๊ฐ ์๋ operator new
์์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋ถ๋ถ์ ๋ณด๋ฉด size bytes๋งํผ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น ํ๊ฒ ๋๋ค.
๊ทธ๋ฐ๋ฐ, ์ด ํด๋์ค๋ฅผ ์ํด ๋ง๋ค์ด์ง operator new ์ฐ์ฐ์๊ฐ ์์๋ ๊ฒฝ์ฐ.
์์๋ฐ์ ํด๋์ค๋ด์ operator new์ฐ์ฐ์๋ฅผ ๋ค์ ์ฌ์ ์ ํด์ค์ผ ํ๋ค.
๊ทธ๋ผ ๋ฐ์ source๋ฅผ...
์ด๊ฒ ์ญ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํ ๊ฒ์ size๋ฅผ ๋ฃ์ด์ ํด์ ํ๊ธฐ ๋๋ฌธ์.
operator new์ฐ์ฐ์์ฒ๋ผ ์(?) ์ฒ๋ฆฌ ํด์ฃผ์ด์ผ ํ๋ค.
~cpp // operator new void * operator new (size_t size) { if (size == 0) { // handle 0-byte requests size = 1; // by treating them as } // 1-byte requests while (1) { // size bytes๋ฅผ ํ ๋น.. if (the allocation was successful) return (a pointer to the memory); new_handler globalHandler = set_new_handler(0); set_new_handler(globalHandler); if (globalHandler) (*globalHandler)(); else throw std::bad_alloc(); } }operator new ๊ฐ ํ๋ถ ํด๋์ค๋ก ์์๋๋ค๋ฉด ์ด๋ป๊ฒ ๋ ๊น?
์์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋ถ๋ถ์ ๋ณด๋ฉด size bytes๋งํผ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น ํ๊ฒ ๋๋ค.
๊ทธ๋ฐ๋ฐ, ์ด ํด๋์ค๋ฅผ ์ํด ๋ง๋ค์ด์ง operator new ์ฐ์ฐ์๊ฐ ์์๋ ๊ฒฝ์ฐ.
์์๋ฐ์ ํด๋์ค๋ด์ operator new์ฐ์ฐ์๋ฅผ ๋ค์ ์ฌ์ ์ ํด์ค์ผ ํ๋ค.
๊ทธ๋ผ ๋ฐ์ source๋ฅผ...
~cpp // in class class Base { public: static void * operator new(size_t size); ... }; class Derived: public Base // Derived doesn't declare { ... }; // operator new ... Derived *p = new Derived; // calls Base::operator new! // ๋ง์ผ Base์ operator new๊ฐ ์ด์ ๋์ฒํ๊ธฐ ์ํด ์ค๊ณ๋์ง ์์๋ค๋ฉด ๊ทธ๋ฅผ // ์ํ ์ต์ ์ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ด "์๋ชป๋" ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฒญํ๊ณ ์๋ // ํธ์ถ๋ค์ ํ์ค operator new๋ก ์ ๋ฌํ๋ ๊ฒ์ด๋ค void *Base::operator new (size_t size) { if (size != sizeof (Base)) // size๊ฐ ์๋ชป ๋์์ผ๋ฉด return ::operator new (size); // ์๊ตฌ๋ฅผ ์ฒ๋ฆฌํ๋ค ... // ๊ทธ๋ ์ง ์์ผ๋ฉด ์ฌ๊ธฐ์ ์๊ตฌ๋ฅผ ์ฒ๋ฆฌํจ }๋ฉค๋ฒ๊ฐ ์๋ operator delete
~cpp // operator delete void operator delete(void *rawMemory) { if (rawMemory == 0) return; // do nothing if the null // pointer is being deleted // deallocate the memory pointed to by rawMemory; return; }์ด ์ฐ์ฐ์๋ ์ญ์ ์์๋ ๊ฒฝ์ฐ ์ฝ๊ฐ ๊ณจ์น์ํ๊ฐ?
์ด๊ฒ ์ญ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํ ๊ฒ์ size๋ฅผ ๋ฃ์ด์ ํด์ ํ๊ธฐ ๋๋ฌธ์.
operator new์ฐ์ฐ์์ฒ๋ผ ์(?) ์ฒ๋ฆฌ ํด์ฃผ์ด์ผ ํ๋ค.
~cpp // in class class Base { // same as before, but now public: // op. delete is declared static void * operator new(size_t size); static void operator delete(void *rawMemory, size_t size); ... }; void Base::operator delete(void *rawMemory, size_t size) { if (rawMemory == 0) return; // check for null pointer if (size != sizeof(Base)) { // if size is "wrong," ::operator delete(rawMemory); // have standard operator return; // delete handle the request } // deallocate the memory pointed to by rawMemory; return; }
2.5. Item 9: Avoid hiding the "normal" form of new ¶
๊ฐ๋จ. class ๋ด์ operator new๋ฅผ ๋ง๋ค์ด ์ค๋.
~cpp class X { public: void f(); // new ํธ๋ค๋ง ํจ์์ ์ฌ์์ ๋ง์กฑํ๋ ์ฐ์ฐ์ new static void * operator new(size_t size, new_handler p); }; void specialErrorHandler(); // definition is elsewhere X *px1 = new (specialErrorHandler) X; // calls X::operator new X *px2 = new X; // error!, "์ ์ form์ ๋ํด ํธํ์ด ์ด๋ฃจ์ด ์ง์ง์๋ ๋ฌธ์ ์ ."์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด.
~cpp class X { public: void f(); static void * operator new(size_t size, new_handler p); static void * operator new(size_t size) // normal formํ์์ ์ฐ์ฐ์๋ ๋ง๋ค์ด์ค๋ค. { return ::operator new(size); } }; X *px1 = new (specialErrorHandler) X; // calls X::operator // new(size_t, new_handler) X* px2 = new X; // calls X::operator // new(size_t)or
~cpp class X { public: void f(); static void * operator new(size_t size, new_handler p = 0); // default ๊ฐ์ ์ฃผ์ด์ ์ฒ๋ฆฌํด์ค๋ค }; X *px1 = new (specialErrorHandler) X; // ok X* px2 = new X; // ok์ด๋ค ๋ฐฉ๋ฒ์ด๋ ์๊ด ์์ง๋ง, code๋ฅผ ์ฝ๊ฐ์ด๋ผ๋ ๋์น๋ defaut ์ธ์๋ฅผ ์ฃผ๋๊ฒ์ด.. ใ กใ ก;; ํํ
2.6. Item 10: Write operator delete if you write operator new ¶
operator new ์ operator delete๋ ์ ์ธ๊น?
ํจ์จ์ฑ ๋๋ฌธ์ด๋๋๋ค. ์๋ก ์์ฑํด์ฃผ๋๊ฒ ์ผ๋ง๋ ํฐ ํจ์จ์ ๋ณด์ด๊ธฐ์ default๋ก ์ ๊ณตํด์ฃผ๋ ๊ฒ์
์ฐ์ง ์๋ ๊ฒ์ผ๊น? --a ์ฌ์ค ๋ชฐ๋๋๋ฐ, ์ผ๋ฐ ์ ์ new (default new์ฐ์ฐ์)๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด ํ ๋น๋ ๋ธ๋ก์
ํฌ๊ธฐ๋ฅผ ๋ํ๋ด ์ฃผ๋ ์ถ๊ฐ์ ์ธ ์ ๋ณด๋ฅผ ๊ฐ์ด ๋ถ์ฌ memory๋ฅผ ํ ๋นํด ์ค๋ค๊ณ ํฉ๋๋ค. ๊ทธ๋ฐ๋ฐ, operator new์ฐ์ฐ์๋ฅผ
์ง์ ๋ง๋ค์ด ์ฃผ๊ฒ๋๋ฉด ์ด๋ฐ ์ถ๊ฐ ์ ๋ณด๋ฅผ ์๋ถ์ฌ์ค๋ ๋๋ค๋ ๊ตฐ์. ๊ทธ๋ฌ๋๊น ์ถ๊ฐ ์ ๋ณด ํฌ๊ธฐ๋งํผ์ ์์ค์ ์ค์ผ ์
์๋ค๋ ๋ง์ด์ง์~ ํ๋ค๋ง๋๋ก ํจ์จ์ฑ์ด ์ข์์ก๋ค.(๋ฐ๋ฉด ::operator new๋ ์ ์ฐ์ฑ์ด ์ข๋ค)
...
ํจ์จ์ฑ ๋๋ฌธ์ด๋๋๋ค. ์๋ก ์์ฑํด์ฃผ๋๊ฒ ์ผ๋ง๋ ํฐ ํจ์จ์ ๋ณด์ด๊ธฐ์ default๋ก ์ ๊ณตํด์ฃผ๋ ๊ฒ์
์ฐ์ง ์๋ ๊ฒ์ผ๊น? --a ์ฌ์ค ๋ชฐ๋๋๋ฐ, ์ผ๋ฐ ์ ์ new (default new์ฐ์ฐ์)๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด ํ ๋น๋ ๋ธ๋ก์
ํฌ๊ธฐ๋ฅผ ๋ํ๋ด ์ฃผ๋ ์ถ๊ฐ์ ์ธ ์ ๋ณด๋ฅผ ๊ฐ์ด ๋ถ์ฌ memory๋ฅผ ํ ๋นํด ์ค๋ค๊ณ ํฉ๋๋ค. ๊ทธ๋ฐ๋ฐ, operator new์ฐ์ฐ์๋ฅผ
์ง์ ๋ง๋ค์ด ์ฃผ๊ฒ๋๋ฉด ์ด๋ฐ ์ถ๊ฐ ์ ๋ณด๋ฅผ ์๋ถ์ฌ์ค๋ ๋๋ค๋ ๊ตฐ์. ๊ทธ๋ฌ๋๊น ์ถ๊ฐ ์ ๋ณด ํฌ๊ธฐ๋งํผ์ ์์ค์ ์ค์ผ ์
์๋ค๋ ๋ง์ด์ง์~ ํ๋ค๋ง๋๋ก ํจ์จ์ฑ์ด ์ข์์ก๋ค.(๋ฐ๋ฉด ::operator new๋ ์ ์ฐ์ฑ์ด ์ข๋ค)
...
DeleteMe ๊ทธ๋ฐ ์๋ฏธ๋ณด๋ค String ์ด๋, linked list ํน์ ๊ธฐํ ์ฌ๋ฌ ๊ธฐํ ๋ฐ์ดํฐ ํ์ผ๋ก ๋ง์ ์์ ํ ๋น์ ํตํด์ ์ธ์ ์๋ ์ธ์์ ๊ฒฝ์ฐ์๋ ์ฌ์ฉ์ ์ ์ new๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๋ฅํ๋ฉด ๊ณต์ฉ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์์ ํ๋์์ผ์, ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์ฝ๋๋ฅผ ์ค์ด๊ณ (๋ฉ๋ชจ๋ฆฌ ํ ๋น์ new์ alloc๋ ์ฑ๋ฅ์ ๋ง์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.) ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ค์ด๊ณ ํจ์จ์ ๊ด๋ฆฌ๋ฅผ ํ ์ ์๋ค๋ ์๋ฏธ ๊ฐ์ต๋๋ค. ๊ทธ๋ฐ ๋ฐ์ดํฐ ํ์ผ๋ก ์ฐ์ด๋ ์ธ์๊ฐ ์๋ ํ app์์์ ๋จ ํ๋ฒ๋ง ์ฌ์ฉ๋๋ ํด๋์ค๋ผ๋ฉด ๊ตฌ์ง new๋ฅผ ์ฑ์ํด์ memory leak์ ์ํ์ฑ์ ์ฆ๊ฐ ์ํค๋ ๊ฒ๋ณด๋ค, ์ผ๋ฐ์ ์ธ new์ ์์ฑ์ ํ๊ดด์์ ๊ท์น์ ์ฐ๋๊ฒ์ด ์ข์๊ฒ๋๋ค. --์๋ฏผ
3. Constructors, Destructors, and Assignment Operators (ํด๋์ค์ ๊ดํ๊ฒ๋ค.) ¶
๊ฐ๊ณผ ํ๊ธฐ ์ฌ์ด ์์ฑ์, ์๋ฉธ์, ์นํ ์ฐ์ฐ์์ ๋ํ ์๊ธฐ๋ค.
3.1. Item 11: Declare a copy constructor and an assignment operator for classes with dynamically allocated memory ¶
~cpp // ์๋ฒฝํ์ง ์์ String class class String { public: String(const char *value); ~String(); private: char *data; }; String::String(const char *value) { if (value) { data = new char[strlen(value) + 1]; strcpy(data, value); } else { data = new char[1]; *data = '\0'; } } inline String::~String() { delete [] data; }
์ด class์๋ ์นํ ์ฐ์ฐ์๋ ๋ณต์ฌ ์์ฑ์๊ฐ ์๋ค. ์ด๋ฐ ํด๋์ค๋ ์ข์ง ๋ชปํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ์์ํจ๋ค.
๊ฐ์ฒด a์ ํฌ์ธํฐ๋ ๋ฌธ์์ด "Hello"๋ฅผ, ๊ฐ์ฒด b๋ด์ ํฌ์ธํฐ๋ "World"๋ฌธ์์ด์ ๋ด๊ณ ์๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํจ๋ค.
๋ค์๊ณผ ๊ฐ์ ์นํ์ฐ์ฐ์ ํ๋ฉด..
default ์นํ ์ฐ์ฐ์๋ ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์๋ค์ ํ๋์ฉ ์นํํ๋ ์์ ์ ํ๊ธฐ ๋๋ฌธ์ a์ b์ ๋ฉค๋ฒ ๋ณ์ data๋ฅผ
์ง์ ๋ณต์ฌ ํ๋ค.
์ด ์ํ๋ ์ ์ด๋ ๋๊ฐ์ง์ ๋ฌธ์ ์ ์ ๊ฐ์ง๊ณ ์๋ค.
...
์ดํ ๋ณต์ฌ ์์ฑ์์ ๊ดํ๊ฒ.
๊ฐ์ฒด a์ ํฌ์ธํฐ๋ ๋ฌธ์์ด "Hello"๋ฅผ, ๊ฐ์ฒด b๋ด์ ํฌ์ธํฐ๋ "World"๋ฌธ์์ด์ ๋ด๊ณ ์๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํจ๋ค.
๋ค์๊ณผ ๊ฐ์ ์นํ์ฐ์ฐ์ ํ๋ฉด..
~cpp b = a;ํด๋์ค ๋ด์ operator=๊ฐ ์ ์ ๋์ด ์์ง ์๊ธฐ ๋๋ฌธ์, C++์์ default ์นํ ์ฐ์ฐ์๋ฅผ ํธ์ถํ๋ค.
default ์นํ ์ฐ์ฐ์๋ ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์๋ค์ ํ๋์ฉ ์นํํ๋ ์์ ์ ํ๊ธฐ ๋๋ฌธ์ a์ b์ ๋ฉค๋ฒ ๋ณ์ data๋ฅผ
์ง์ ๋ณต์ฌ ํ๋ค.
์ด ์ํ๋ ์ ์ด๋ ๋๊ฐ์ง์ ๋ฌธ์ ์ ์ ๊ฐ์ง๊ณ ์๋ค.
- b์์ ๊ฐ๋ฆฌํค๊ณ ์๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ญ์ ๋์ง ์์์ง ๋๋ฌธ์, ์์ํ ์ผ์ด๋ฒ๋ฆฌ๊ฒ ๋๋ ๋ฌธ์ ์ ์ธ memory leak.
- a์ b๋ชจ๋ ๊ฐ์ ๋ฌธ์์ด์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ๊ฐ๊ฒ ๋์์ผ๋ฏ๋ก ๋์คํ๋๊ฐ ์ง์์ง๊ฒ ๋๋ฉด ๋๋จธ์ง ํ๋์ญ์ ๋ฐ์ดํฐ๋ฅผ ์์ด ๋ฒ๋ฆฌ๊ฒ ๋๋ค.
~cpp String a("Hello"); // a๋ฅผ ์์ฑ ... { // ์๋ก์ด ์์ญ String b("World"); // b๋ฅผ ์์ฑ ... b = a; // default ์นํ ์ฐ์ฐ์ ์ํ // b์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๊ฒ ๋๋ค. } // ์์ญ์ด ๋ซํํ, // b์ ์๋ฉธ์๊ฐ ํธ์ถ๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก, a๊ฐ ๊ฐ๋ฆฌํค๋ data๋ ์๋ฉธ๋๊ฒ ๋๋ค. String c = a; // c์ data๋ ์ ์ ๋์ง ์๋๋ค. // ๋ณต์ฌ ์์ฑ์๊ฐ ์ ์ ๋์ง ์์๊ธฐ ๋๋ฌธ์ C++์์ ์ ๊ณตํ๋ default ์นํ ์ฐ์ฐ์ ํธ์ถ. // a์ data๋ ์ด๋ฏธ ์ง์ ์ก๊ธฐ ๋๋ฌธ์ memory leak์ ๋ฌธ์ ๋ ์๋ค. // ๊ทธ๋ฌ๋, c์ a๋ ๊ฐ์ ๊ณณ์ ๊ฐ๋ฆฌํจ๋ค. ๊ทธ๋ฆฌ๊ณ , c์ ์๋ฉธ์๊ฐ ํธ์ถ ๋๋ฉด ์์์ ์ญ์ ๋ ๊ณณ์ ๋ค์ํ๋ฒ // ์ญ์ ํ๊ฒ ๋๋ค. ๊ฒฐ๊ณผ ์ ์ผ๋ก a์ c๊ฐ ๊ฐ๋ฆฌํค๋ ๊ณณ์ด ๋๋ฒ ์ญ์ ๋๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์๋๋ค. (a๊ฐ ์๋ฉธํ ๋, c๊ฐ ์๋ฉธํ ๋)์ด์ ์นํ ์ฐ์ฐ์์ ๊ดํ๊ฒ.
...
์ดํ ๋ณต์ฌ ์์ฑ์์ ๊ดํ๊ฒ.
~cpp void doNothing(String localString) {} ... String s = "The Truth Is Out There"; doNothing(s); // deault ๋ณต์ฌ ์์ฑ์ ํธ์ถ. call-by-value๋ก ์ธํด // localString์ s์์ ์๋ ํฌ์ธํฐ์ ๋ํ ๋ณต์ฌ๋ณธ์ ๊ฐ์ง๊ฒ ๋๋ค. // ๊ทธ๋์, doNothing์ด ์ํ์ ๋ง์น๋ฉด, localString์ ์ฌ์ญ์ ๋ฒ์ด๋๊ณ , ์๋ฉธ์๊ฐ ํธ์ถ๋๋ค. // ๊ทธ ๊ฒฐ๊ณผ s๋ localString์ด ์ญ์ ํ ๋ฉ๋ชจ๋ฆฌ์ ๋ํ ํฌ์ธํฐ๋ฅผ ๊ฐ์ง๊ฒ ๋๋ค. (data ์์ค)* ํด๋์ค ์์ ํฌ์ธํฐ๋ฅผ ์กฐ๋ฌผ๋ฑ ๊ฑฐ๋ฆฌ๋ ๋ฉค๋ฒ ๋ณ์๊ฐ ์์ ๊ฒฝ์ฐ์๋ ๊ทธ ํด๋์ค์ ๋ณต์ฌ ์์ฑ์์, ์นํ ์ฐ์ฐ์๋ฅผ ๊ผญ ์ ์ํด ์ฃผ์ด์ผ ํ๋ค...
3.2. Item 12: Prefer initialization to assignment in constructors ¶
~cpp template<class T> class NamedPtr { public: NamedPtr(const string& initName, T *initPtr); ... private: string name; T *ptr; };
๋ฉค๋ฒ ๋ณ์๋ฅผ ์ด๊ธฐํ ํ๋ ๋ฐฉ๋ฒ.
1. ์ด๊ธฐํ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ๋ค.
์ฒซ์งธ๋ ์ด๊ธฐํ๋ง ๊ฐ๋ฅํ const๋ฉค๋ฒ ๋ณ์๋ฅผ ์ด๊ธฐํ ํ ์ ์๋ค๋ ์๋ฏธ์์์ด๊ณ ,
๋๋ฒ์งธ๋ ์ค์ฉ์ฃผ์(ํจ์จ์ฑ) ์ฐจ์์์ ์ด๊ธฐํ ๋ฆฌ์คํธ๋ฅผ ์ ํธ ํ๋ค๋ ๊ฒ์ด๋ค.
(์.. ํจ์จ์ฑ์ด ์ข์์ง๋์ง๋ ๊ฐ์ ์๊ฐ~ ์ฑ ์๋ ๋์์๊ณ .. ์๊ฐ๋ง ํด๋ณด๋ฉด ์์ ์๋ ๋ฌธ์ ~)
''
1. ์ด๊ธฐํ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ๋ค.
~cpp template<class T> NamedPtr<T>::NamedPtr(const string& initName, T *initPtr ) : name(initName), ptr(initPtr) {}2. ์์ฑ์์ ์ฝ๋ ๋ถ๋ถ์์ ์นํ์ ํ๋ค.
~cpp template<class T> NamedPtr<T>::NamedPtr(const string& initName, T *initPtr) { name = initName; ptr = initPtr; }2๊ฐ์ง ๋ฐฉ๋ฒ ์ ๋๋ก ๋ฉค๋ฒ ๋ณ์๋ฅผ ์ด๊ธฐํ ํ ์ ์๋๋ฐ. ์ฑ ์์๋ ์ด๊ธฐํ ๋ฆฌ์คํธ๋ฅผ ์ ํธํ๋ค.
์ฒซ์งธ๋ ์ด๊ธฐํ๋ง ๊ฐ๋ฅํ const๋ฉค๋ฒ ๋ณ์๋ฅผ ์ด๊ธฐํ ํ ์ ์๋ค๋ ์๋ฏธ์์์ด๊ณ ,
๋๋ฒ์งธ๋ ์ค์ฉ์ฃผ์(ํจ์จ์ฑ) ์ฐจ์์์ ์ด๊ธฐํ ๋ฆฌ์คํธ๋ฅผ ์ ํธ ํ๋ค๋ ๊ฒ์ด๋ค.
(์.. ํจ์จ์ฑ์ด ์ข์์ง๋์ง๋ ๊ฐ์ ์๊ฐ~ ์ฑ ์๋ ๋์์๊ณ .. ์๊ฐ๋ง ํด๋ณด๋ฉด ์์ ์๋ ๋ฌธ์ ~)
''
- ๊ฐ๋ฅํ ๊ฒฝ์ฐ ํญ์ ๋ฉค๋ฒ ์ด๊ธฐํ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ๋ ์ต๊ด์ ๋ค์ด๋ฉด, const์ ๋ ํผ๋ฐ์ค ๋ณ์๋ค์ ๋ํ
์๊ตฌ ์กฐ๊ฑด์ ์ฑ์ธ ์ ์์ ๋ฟ๋ง ์๋๋ผ, ๋ฉค๋ฒ ๋ณ์๋ค์ ๋ํ ๋นํจ์จ์ ์ธ ์ด๊ธฐํ๋ ์ค์ผ์ ์๋ค.''
3.3. Item 13: List members in an initialization list in the order in which they are declared ¶
ํด๋์ค ๋ฉค๋ฒ๋ค์ ํด๋์ค์ ์ ์ธ๋ ์์์ ๋ฐ๋ผ ์ด๊ธฐํ๋๋ค.
๋ฉค๋ฒ ์ด๊ธฐํ ๋ฆฌ์คํธ์ ๋์ด๋ ์์๋ ์๋ฌด๋ฐ ์ํฅ๋ ๋ฏธ์น์ง ๋ชปํ๋ค.
๋ง์ฝ, ์ด๊ธฐํ ๋ฆฌ์คํธ์ ๋์ด๋ ์์๋๋ก ๋ฉค๋ฒ ๋ณ์๊ฐ ์ด๊ธฐํ ๋๋ค๊ณ ๊ฐ์ ํ๊ณ ์ด ์๋ฅผ ๋ณด์.
๊ฐ์ฒด๋ค(string ๊ฐ์ฒด)์ด ์์ฑ๋ ์์๋ฅผ ๊ธฐ์ตํ๋ค์ ์๋ฉธ์๋ฅผ ์ฐจ๋ก๋๋ก ํธ์ถํด์ผ ํ ๊ฒ์ด๋ค. ์ด๋ฐ overhead๋ฅผ ์์ ๊ธฐ ์ํด,
๋ชจ๋ ๊ฐ์ฒด์ ๋ํด์ ์์ฑ์์ ์๋ฉธ์์ ํธ์ถ ์์๋ ๋์ผํ๊ฒ ๋์ด ์๊ณ , ์ด๊ธฐํ ๋ฆฌ์คํธ์ ๋์ด๋ ์์๋ ๋ฌด์๋๋ค.
๋จ, ์ด๋ฐ ๊ท์น์ ๋น์ ์ ๋ฐ์ดํฐ ๋ฉค๋ฒ๋ค๋ง ๋ฐ๋ฅธ๋ค.
์ ์ ๋ฐ์ดํฐ ๋ค์ด์ผ ๋จ์ง ํ๋ฒ๋ง ์ด๊ธฐํ ๋๊ธฐ ๋๋ฌธ์ ์ด๋ฐ๊ฒ์ ๋ฐ๋ฅผ ํ์๋ ์๋ค.
๋ฉค๋ฒ ์ด๊ธฐํ ๋ฆฌ์คํธ์ ๋์ด๋ ์์๋ ์๋ฌด๋ฐ ์ํฅ๋ ๋ฏธ์น์ง ๋ชปํ๋ค.
๋ง์ฝ, ์ด๊ธฐํ ๋ฆฌ์คํธ์ ๋์ด๋ ์์๋๋ก ๋ฉค๋ฒ ๋ณ์๊ฐ ์ด๊ธฐํ ๋๋ค๊ณ ๊ฐ์ ํ๊ณ ์ด ์๋ฅผ ๋ณด์.
~cpp class Wacko { public: Wacko(const char *s): s1(s), s2(0) {} Wacko(const Wacko& rhs): s2(rhs.s1), s1(0) {} private: string s1, s2; }; Wacko w1 = "Hello world!"; Wacko w2 = w1;w1๊ณผ w2์ ๋ฉค๋ฒ๋ค์ ๋ค๋ฅธ ์์์ ๋ฐ๋ผ ์์ฑ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ , ๋ค์ ๊ทธ ๊ฐ์ฒด๋ค(string ๊ฐ์ฒด)์ ์๋ฉธํ๊ธฐ ์ํด์
๊ฐ์ฒด๋ค(string ๊ฐ์ฒด)์ด ์์ฑ๋ ์์๋ฅผ ๊ธฐ์ตํ๋ค์ ์๋ฉธ์๋ฅผ ์ฐจ๋ก๋๋ก ํธ์ถํด์ผ ํ ๊ฒ์ด๋ค. ์ด๋ฐ overhead๋ฅผ ์์ ๊ธฐ ์ํด,
๋ชจ๋ ๊ฐ์ฒด์ ๋ํด์ ์์ฑ์์ ์๋ฉธ์์ ํธ์ถ ์์๋ ๋์ผํ๊ฒ ๋์ด ์๊ณ , ์ด๊ธฐํ ๋ฆฌ์คํธ์ ๋์ด๋ ์์๋ ๋ฌด์๋๋ค.
๋จ, ์ด๋ฐ ๊ท์น์ ๋น์ ์ ๋ฐ์ดํฐ ๋ฉค๋ฒ๋ค๋ง ๋ฐ๋ฅธ๋ค.
์ ์ ๋ฐ์ดํฐ ๋ค์ด์ผ ๋จ์ง ํ๋ฒ๋ง ์ด๊ธฐํ ๋๊ธฐ ๋๋ฌธ์ ์ด๋ฐ๊ฒ์ ๋ฐ๋ฅผ ํ์๋ ์๋ค.
3.4. Item 14: Make sure base classes have virtual destructors ¶
๋ฒ ์ด์ค ํด๋์ค์ ์๋ฉธ์๋ฅผ ๊ฐ์ํจ์๋ก ๋๋ค๋ ์๊ธฐ๋ ๋ฒ ์ด์ค ํด๋์ค๊ฐ ๊ณ์น ๋ ๊ฒฝ์ฐ ๊ณ์น๋ ํด๋์ค์๋ด์์ ์๋ฉธ์์
์์ฉ์ ์ฌ๋ฐ๋ก ํ๊ธฐ ์ํจ์ด๋ค. ์ ๋นํ ์๋ฅผ ๋ณด๋๋ก ํ์.
๊ฐ์ฒด์ ์นด์ดํธ๋ฅผ ์ํด ์ ์ ๋ฉค๋ฒ ๋ณ์ numTanks๋ฅผ ๋์๋ค.
๊ทธ๋ฆฌ๊ณค, ๋ค์๊ณผ ๊ฐ์ code๋ฅผ ์ ์ฉ์์ผ๋ณด์.
์ญ์ ํ๋ ค๊ณ ํ๋ฉฐ, ๋ฒ ์ด์ค ํด๋์ค๋ ๊ฐ์ ์๋ฉธ์๋ฅผ ๊ฐ์ง๊ณ ์์ง ์์ ๊ฒฝ์ฐ. ๊ทธ ๊ฒฐ๊ณผ๋ ์ ์๋์ด ์์ง ์๋ค. ์ด๊ฒ์ ์ปดํ์ผ๋ฌ๋ก
ํ์ฌ๊ธ, ์ํ๋ ๋๋ก ์ฝ๋๋ฅผ ์์ํ๊ณ ์คํํ๋๋ก ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ํ๋ค. (์คํ ์๊ฐ์ ์์ฃผ ๋ฐ์ํ๋ ๊ฒ์ ๊ณ์น๋ ํด๋์ค์ ์๋ฉธ์๊ฐ
ํธ์ถ๋์ง ์๋๋ค๋ ๊ฒ์ด๋ค. ์์ ์์์, targetPtr์ด ์ญ์ ๋ ๋ EnemyTank์ ์๊ฐ ์ ๋๋ก ์กฐ์ ๋์ง ์๋๋ค๋ ๊ฒ์ ์๋ฏธ ํ๋ค.)
๊ทธ๋์ ์ด๋ฌธ์ ๋ฅผ ํผํ๊ธฐ ์ํด์, EnemyTarget์ ์๋ฉธ์๋ฅผ virtual๋ก ์ ์ธํด์ผ ํ๋ค. ์๋ฉธ์๋ฅผ ๊ฐ์ํจ์๋ก ์ ์ธํ๋ฉด, ์ฌ๋ฌ๋ถ์ด ์ํ๋
๋ฐฉ์์ผ๋ก ์๋ฉธ์๊ฐ ๋ถ๋ฆฌ๋๋ก ํ ์ ์๋ค.
์์ฉ์ ์ฌ๋ฐ๋ก ํ๊ธฐ ์ํจ์ด๋ค. ์ ๋นํ ์๋ฅผ ๋ณด๋๋ก ํ์.
~cpp // base class class EnemyTarget { public: EnemyTarget() { ++numTargets; } EnemyTarget(const EnemyTarget&) { ++numTargets; } ~EnemyTarget() { --numTargets; } static unsigned int numberOfTargets() { return numTargets; } virtual bool destroy(); // EnemyTarget ๊ฐ์ฒด ํ๊ดด์ // ์ฑ๊ณตํ๋ฉด ์ฐธ์ ๋๋ ค ์ค๋ค private: static unsigned int numTargets; // ๊ฐ์ฒด ์นด์ดํฐ }; // class๋ด์ ์ ์ ๋ณ์๋ ํด๋์ค์ ๋ฐ๊นฅ์ชฝ์ ์ ์๋์ด์ผ ํ๋ค. // ๊ธฐ๋ณธ์ ์ผ๋ก 0์ผ๋ก ์ด๊ธฐํ๋๋ค. unsigned int EnemyTarget::numTargets; ... .. // base class๋ฅผ ์์ํ ํด๋์ค class EnemyTank: public EnemyTarget { public: EnemyTank() { ++numTanks; } EnemyTank(const EnemyTank& rhs) : EnemyTarget(rhs) { ++numTanks; } ~EnemyTank() { --numTanks; } static unsined int numberOfTanks() { return numTanks; } virtual bool destroy(); private: static unsigned int numTanks; // object counter for tanks }; unsigned int EnenyTank::numTanks;EnemyTarget์ ๊ฐ์ฒด๋ฅผ ์นด์ดํธ ํ๊ธฐ ์ํด ์ ์ ๋ฉค๋ฒ ๋ณ์ numTargets๋ฅผ ๋์์ผ๋ฉฐ EnemyTarget์ ์์ํ EnemyTank์์๋
๊ฐ์ฒด์ ์นด์ดํธ๋ฅผ ์ํด ์ ์ ๋ฉค๋ฒ ๋ณ์ numTanks๋ฅผ ๋์๋ค.
๊ทธ๋ฆฌ๊ณค, ๋ค์๊ณผ ๊ฐ์ code๋ฅผ ์ ์ฉ์์ผ๋ณด์.
~cpp EnemyTarget *targetPtr = new EnemyTank; ... delete targetPtr; // ์๋ฌด ๋ฌธ์ ๊ฐ ์์ด ๋ณด์ธ๋ค.The C++ language standard is unusually clear on this topic. ๋ฒ ์ด์ค ํด๋์ค์ ๋ํ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํด์ ๊ณ์น๋ ํด๋์ค๋ฅผ
์ญ์ ํ๋ ค๊ณ ํ๋ฉฐ, ๋ฒ ์ด์ค ํด๋์ค๋ ๊ฐ์ ์๋ฉธ์๋ฅผ ๊ฐ์ง๊ณ ์์ง ์์ ๊ฒฝ์ฐ. ๊ทธ ๊ฒฐ๊ณผ๋ ์ ์๋์ด ์์ง ์๋ค. ์ด๊ฒ์ ์ปดํ์ผ๋ฌ๋ก
ํ์ฌ๊ธ, ์ํ๋ ๋๋ก ์ฝ๋๋ฅผ ์์ํ๊ณ ์คํํ๋๋ก ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ํ๋ค. (์คํ ์๊ฐ์ ์์ฃผ ๋ฐ์ํ๋ ๊ฒ์ ๊ณ์น๋ ํด๋์ค์ ์๋ฉธ์๊ฐ
ํธ์ถ๋์ง ์๋๋ค๋ ๊ฒ์ด๋ค. ์์ ์์์, targetPtr์ด ์ญ์ ๋ ๋ EnemyTank์ ์๊ฐ ์ ๋๋ก ์กฐ์ ๋์ง ์๋๋ค๋ ๊ฒ์ ์๋ฏธ ํ๋ค.)
๊ทธ๋์ ์ด๋ฌธ์ ๋ฅผ ํผํ๊ธฐ ์ํด์, EnemyTarget์ ์๋ฉธ์๋ฅผ virtual๋ก ์ ์ธํด์ผ ํ๋ค. ์๋ฉธ์๋ฅผ ๊ฐ์ํจ์๋ก ์ ์ธํ๋ฉด, ์ฌ๋ฌ๋ถ์ด ์ํ๋
๋ฐฉ์์ผ๋ก ์๋ฉธ์๊ฐ ๋ถ๋ฆฌ๋๋ก ํ ์ ์๋ค.
3.5. Item 15: Have operator= return a reference to *this ¶
์ฐ๋ฆฌ๋ ์ฐ์ operator=๋ฅผ ์ ์ ํด์ค๋
๊ทธ๋ฆฌ๊ณ , operator=์ฐ์ฐ์์ ๋ฆฌํดํ์ const๋ก ์ ์ ํด ์ฃผ์์๋. ๋ฐ์ ์์ ์ ๊ฐ์ ๋ฉ์ฒญํ(?) ์ฐ์ฐ์ ํด์ฃผ์์๋ ์ ์ฉ ๋์ง ์๋๋ค. ๋ฐ์ ์ฐ์ฐ์ ๋ฉ์ฒญํ(?) ์ฐ์ฐ์ด์ง๋ง C++์ ๊ธฐ๋ณธ ํ์ ์ ๋ํด ์ ๋ฐ ์ฐ์ฐ์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์ ๋ฐ ์ฐ์ฐ๋ ์ง์ํ๊ฒ ๋ ๋ง๋ค์ด์ผ ํ๋ค.
...
๊ธฐ๋ณธ ํ์์ ๊ฐ๋ ์นํ ์ฐ์ฐ์์์, ๋ฆฌํด๊ฐ์ผ๋ก ์ฌ์ฉํ ์ ์๋ ๋ ๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์๋ค. ์นํ์ ์ผ์ชฝ ๋ถ๋ถ (this)๊ณผ ์นํ์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ(์ธ์ ๋ฆฌ์คํธ์ ์๋๊ฒ)์ด๋ค. ์ด๋ค๊ฒ์ ๋ฆฌํดํด ์ค๊ฒ์ธ๊ฐ? operator=๊ณผ ๊ด๋ จ๋ ๋ฐ์ ๋๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๋ณด์.
์ฒซ์งธ, rhs๋ฅผ ๋ฆฌํดํ๋ ๊ฒฝ์ฐ๋ compile ๋์ง ์์ ๊ฒ์ด๋ค. ์๋ํ๋ฉด, rhs๋ const String์ ๋ํ ๋ ํผ๋ฐ์ค ์ด๊ณ , operator=๋ String์ ๋ํ ๋ ํผ๋ฐ์ค๋ฅผ ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ด๋ค. ๋ญ ์ด๋ฐ ๋ฌธ์ ์ผ ๋ฐ์์ ์ฒ๋ผ ๊ณ ์น๋ฉด ๋ฌธ์ ๋์ง ์๋๋ค.
..
๊ฒฐ๋ก ์ ์๊ธฐ ํ์๋ฉด, ์นํ์ ์ผ์ชฝ ๋ถ๋ถ์ ๋ํ ๋ ํผ๋ฐ์ค *this๋ฅผ ๋๋๋ ค ์ฃผ๋๋ก ์นํ ์ฐ์ฐ์๋ฅผ ์ ์ธํด์ผ ํ๋ค. ๋ง์ผ ์ด์ธ์ ์ผ์ ํ๋ฉด, ์ฐ์์ ์ธ ์นํ์ ํ ์ ์๊ฒ ๋๊ณ , ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ์ฝ๋์์์ ๋ฌต์์ ์ธ ํ์ ๋ณํ๋ ํ ์ ์๊ฒ ๋๋ค.
~cpp w = x= y = z = "Hello";์ด ๋ฐ์์ ์ฐ์์ ์ธ ์นํ ์ฐ์ฐ์ ํ ์ ์์ด์ผ ํ๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ operator=์ฐ์ฐ์์ ๋ฆฌํดํ์ void๋ก ์ ์ ํ๋ฉด ์๋๋ค.
๊ทธ๋ฆฌ๊ณ , operator=์ฐ์ฐ์์ ๋ฆฌํดํ์ const๋ก ์ ์ ํด ์ฃผ์์๋. ๋ฐ์ ์์ ์ ๊ฐ์ ๋ฉ์ฒญํ(?) ์ฐ์ฐ์ ํด์ฃผ์์๋ ์ ์ฉ ๋์ง ์๋๋ค. ๋ฐ์ ์ฐ์ฐ์ ๋ฉ์ฒญํ(?) ์ฐ์ฐ์ด์ง๋ง C++์ ๊ธฐ๋ณธ ํ์ ์ ๋ํด ์ ๋ฐ ์ฐ์ฐ์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์ ๋ฐ ์ฐ์ฐ๋ ์ง์ํ๊ฒ ๋ ๋ง๋ค์ด์ผ ํ๋ค.
~cpp class Widget { public: ... // note const Widget& operator=(const Widget& rhs); // const ... // return }; // type ... Widget w1, w2, w3; ... (w1 = w2) = w3; // assign w2 to w1, then w3 to // the result! (Giving Widget's // operator= a const return value // prevents this from compiling.)๊ทธ๋์, operator=์ ๋ฆฌํดํ์ const๋ก ์์ฑํ๋ฉด ์๋๋ค. (....--;...)
...
๊ธฐ๋ณธ ํ์์ ๊ฐ๋ ์นํ ์ฐ์ฐ์์์, ๋ฆฌํด๊ฐ์ผ๋ก ์ฌ์ฉํ ์ ์๋ ๋ ๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์๋ค. ์นํ์ ์ผ์ชฝ ๋ถ๋ถ (this)๊ณผ ์นํ์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ(์ธ์ ๋ฆฌ์คํธ์ ์๋๊ฒ)์ด๋ค. ์ด๋ค๊ฒ์ ๋ฆฌํดํด ์ค๊ฒ์ธ๊ฐ? operator=๊ณผ ๊ด๋ จ๋ ๋ฐ์ ๋๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๋ณด์.
~cpp String& String::operator=(const String& rhs) { ... return *this; // return reference // to left-hand object } String& String::operator=(const String& rhs) { ... return rhs; // return reference to // right-hand object }์์ ๋๊ฐ์ง ๊ฒฝ์ฐ๋ ๋ณ๋ค๋ฅธ ์ฐจ์ด๊ฐ ์์ด๋ณด์ธ๋ค. ๊ทธ๋ฌ๋, ์ค์ํ ์ฐจ์ด์ ์ด ์์ผ๋ ๋ง์ ๊บผ๋ด๋ ๊ฒ์ด ๊ฒ ์ง? --;
์ฒซ์งธ, rhs๋ฅผ ๋ฆฌํดํ๋ ๊ฒฝ์ฐ๋ compile ๋์ง ์์ ๊ฒ์ด๋ค. ์๋ํ๋ฉด, rhs๋ const String์ ๋ํ ๋ ํผ๋ฐ์ค ์ด๊ณ , operator=๋ String์ ๋ํ ๋ ํผ๋ฐ์ค๋ฅผ ๋ฆฌํดํ๊ธฐ ๋๋ฌธ์ด๋ค. ๋ญ ์ด๋ฐ ๋ฌธ์ ์ผ ๋ฐ์์ ์ฒ๋ผ ๊ณ ์น๋ฉด ๋ฌธ์ ๋์ง ์๋๋ค.
~cpp String& String::operator=(String& rhs) { ... }ํ์ง๋ง, ์ด๋ฒ์๋ ํด๋์ค์ operator=๋ฅผ ์ฌ์ฉํ๋ ์ฝ๋์์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
~cpp x = "Hello";์นํ์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ์ด Stringํ์ด ์๋๋ผ char *ํ์ด๊ธฐ ๋๋ฌธ์ ์ปดํ์ผ๋ฌ๋ String์ ์์ฑ์๋ฅผ ํตํด ์์ String๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด์ ํธ์ถ์ ํ๋ค. ์ฆ, ์๋์ ๊ฐ์ code๋ฅผ ์์ฑํ๋ค.
~cpp const String temp("Hello"); // ์์ ๊ฐ์ฒด๋ฅผ ๋ง๋ ๋ค. ... x = temp; // ์์ ๊ฐ์ฒด๋ฅผ operator=์ ์ ๋ฌํ๋ค.์ปดํ์ผ๋ฌ๋ ์์ ๊ฐ์ ์์ ๊ฐ์ฒด๋ฅผ ๋ง๋ค๋ ค๊ณ ํ์ง๋ง, ์์ ๊ฐ์ฒด๊ฐ const๋ผ๋ ๊ฒ์ ์ฃผ์. ๊ทธ๋ฆฌ๊ณ , operator=์ ๋ฆฌํดํ์ ๋ณด๋ฉด String์ ๋ํ ๋ ํผ๋ฐ์ค๋ฅผ ๋๋ ค์ฃผ๊ธฐ ๋๋ฌธ์ ๋ฆฌํดํ์ด ์ผ์นํ์ง ์๊ฒ ๋๋ค. ๊ทธ๋์, error๋ฅผ ๋ฐ์์ํจ๋ค. ๋ง์ฝ error๋ฅผ ๋ฐ์ ์ํค์ง ์๋๋ค๋ฉด, operator=์ด ํธ์ถ๋๋ ์ธก์์ ์ ๊ณต๋ ์ธ์๊ฐ ์๋๋ผ ์ปดํ์ผ๋ฌ๊ฐ ๋ฐ์์ํจ ์์ ๋ณ์๋ง ์์ ๋๋ค๋ ๊ฒ์ ๋๋๊ฒ์ด๋ค. --;
..
๊ฒฐ๋ก ์ ์๊ธฐ ํ์๋ฉด, ์นํ์ ์ผ์ชฝ ๋ถ๋ถ์ ๋ํ ๋ ํผ๋ฐ์ค *this๋ฅผ ๋๋๋ ค ์ฃผ๋๋ก ์นํ ์ฐ์ฐ์๋ฅผ ์ ์ธํด์ผ ํ๋ค. ๋ง์ผ ์ด์ธ์ ์ผ์ ํ๋ฉด, ์ฐ์์ ์ธ ์นํ์ ํ ์ ์๊ฒ ๋๊ณ , ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ์ฝ๋์์์ ๋ฌต์์ ์ธ ํ์ ๋ณํ๋ ํ ์ ์๊ฒ ๋๋ค.
3.6. Item 16: Assign to all data members in operator= ¶
operator= ์ฐ์ฐ์๋ฅผ ์ํํ ๋ ๊ฐ์ฒด ๋ด ๊ฐ๊ฐ์ ๋ชจ๋ ๋ฐ์ดํฐ ๋ฉค๋ฒ๋ฅผ ์นํํ ํ์๊ฐ ์๋ค๋ ์๊ธฐ.
์์์ ๊ฒฝ์ฐ ํนํ๋ ์กฐ์ฌํด์ operator= ์ฐ์ฐ์๋ฅผ ๋ง๋ค์ด ์ค์ผ ํ๋ค.
์์๊ณผ ๊ด๋ จํ์ฌ ์ ์ฌํ ๋ฌธ์ ๊ฐ ๋ณต์ฌ ์์ฑ์์์๋ ์๊ธธ ์ ์๋ค. ๋ฐ์ ์ฝ๋๋ฅผ ๋ณด์.
์์์ ๊ฒฝ์ฐ ํนํ๋ ์กฐ์ฌํด์ operator= ์ฐ์ฐ์๋ฅผ ๋ง๋ค์ด ์ค์ผ ํ๋ค.
~cpp class Base { public: Base(int initialValue = 0): x(initialValue) {} private: int x; }; class Derived: public Base { public: Derived(int initialValue) : Base(initialValue), y(initialValue) {} Derived& operator=(const Derived& rhs); private: int y; }; // The logical way to write Derived's assignment operator is like this // erroneous assignment operator Derived& Derived::operator=(const Derived& rhs) { if (this == &rhs) return *this; y = rhs.y; // assign to Derived's // lone data member return *this; // see Item 15 } // Unfortunately, this is incorrect, because the data member x in // the Base part of a Derived object is unaffected by this assignment operator. // For example, consider this code fragment void assignmentTester() { Derived d1(0); // d1.x = 0, d1.y = 0 Derived d2(1); // d2.x = 1, d2.y = 1 d1 = d2; // d1.x = 0, d1.y = 1! }๋ณด๊ธฐ์ ๊ฐ์ด ์ ๋๋ก ์๋ํ์ง ์๋ operator= ์ฐ์ฐ์์ด๋ค. ๊ทธ๋ผ, ์ด๊ฒ์ ์ด๋ป๊ฒ ๊ณ ์น๋ฉด ์ข์๊น? ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์๋, ๋ค์๊ณผ ๊ฐ์ด Baseํด๋์ค์ operator=์ฐ์ฐ์๋ฅผ ํธ์ถํด ์ฃผ๋ฉด ๋๋ค. ( Derived ํด๋์ค์ operator= ์ฐ์ฐ์์์ x๋ฅผ ์นํํด ์ค๋ค๋ ๊ฒ์ ํ์ฉ๋์ง ์๊ธฐ ๋๋ฌธ์.)
~cpp // correct assignment operator Derived& Derived::operator=(const Derived& rhs) { if (this == &rhs) return *this; Base::operator=(rhs); // call this->Base::operator= y = rhs.y; return *this; }
์์๊ณผ ๊ด๋ จํ์ฌ ์ ์ฌํ ๋ฌธ์ ๊ฐ ๋ณต์ฌ ์์ฑ์์์๋ ์๊ธธ ์ ์๋ค. ๋ฐ์ ์ฝ๋๋ฅผ ๋ณด์.
~cpp class Base { public: Base(int initialValue = 0): x(initialValue) {} Base(const Base& rhs): x(rhs.x) {} private: int x; }; class Derived: public Base { public: Derived(int initialValue) : Base(initialValue), y(initialValue) {} Derived(const Derived& rhs) // erroneous copy : y(rhs.y) {} // constructor private: int y; };Derived ํด๋์ค์ ๋ณต์ฌ ์์ฑ์๋ฅผ ๋ณด๋ฉด Baseํด๋์ค์ ๋ฉค๋ฒ ๋ณ์๋ ์ด๊ธฐํ ์ํค์ง ์์์ ์์ ์๋ค. ์ด๋ฐ ๋ฌธ์ ๋ฅผ ํผํ๊ธฐ ์ํด์๋ ๋ฐ์ ์ฝ๋์ ๊ฐ์ด Baseํด๋์ค์ ๋ณต์ฌ ์์ฑ์๋ฅผ ํธ์ถํด ์ฃผ๋ฉด ๋๋ค.
~cpp class Derived: public Base { public: Derived(const Derived& rhs): Base(rhs), y(rhs.y) {} ... };์ด์ Derivedํด๋์ค์ ๋ณต์ฌ์์ฑ์๋ฅผ ํธ์ถํด๋ Baseํด๋์ค์ ๋ฉค๋ฒ ๋ณ์์ญ์ ์ ๋ณต์ฌ ๋๋ค.
3.7. Item 17: Check for assignment to self in operator= ¶
assignment to self in operator= (์ฌ๊ท์นํ) ๋ ๋ค์๊ณผ ๊ฐ์๋ ๋ฐ์ํ๋ค.
String ๊ฐ์ฒด๋ค์ ์นํ์ ์๊ฐํด ๋ณด์. ์ฌ๊ธฐ์์ ์ฌ๊ท์นํ์ ๊ฒ์ฌํ์ง ์๊ณ ์๋ค.
์นํ ์ฐ์ฐ์๊ฐ ์ํํ๋ ์ฒซ ๋ฒ์งธ ์์ ์ด data๋ฅผ ์ญ์ ํ๋ ๊ฒ์ด๋ฉฐ, ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ๋ค.
์ด์ ์นํ์ฐ์ฐ์์์ strcpy๋ฅผ ์ํํ ๋ ๋ฐ์ํ๋ ์ผ์ ์์ธกํ ์ ์๊ฒ ๋์๋ค. ์ด๊ฒ์ data๊ฐ ์ญ์ ๋๋ฉด์ rhs.data๊ฐ ์ญ์ ๋์๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๊ฒ์ data, this->data ๊ทธ๋ฆฌ๊ณ , rhs.data๊ฐ ๋ชจ๋ ๊ฐ์ ํฌ์ธํฐ๊ธฐ ๋๋ฌธ์ ๊ทธ๋ ๊ฒ ๋๊ฒ์ด๋ค. ์ต์ ์ ์ํฉ์ด๋ค..
์ด์ ์? ์ฌ๊ท์นํ์ ๊ฒ์ฌํด์ผ ํ๋์ง ์์์ ๊ฒ์ด๋ค.
๊ทธ๋ผ, ์ด๋ค์์ผ๋ก ์ฌ๊ท์นํ์ธ์ง ์๋์ง๋ฅผ ๊ฒ์ฌํ ๊น? ์ข ๋ฅ๋ ๋ค์ํ๋ค.
~cpp class X { ... }; X a; a = a; // a is assigned to itself'์ ์ด๋ฐ ๋์ ์ ํ๋๊ฑฐ์ง. ํ๋ก๊ทธ๋จ ์ง๋ ๋์ด ๋ฐ๋ณด ์ธ๊ฐ?' ๋ผ๋ ์๊ฐ์ ํ ์ ๋์์ง๋ง, ๋ฐ์ ์ฝ๋๊ฐ ์๋ค๊ณ ํ์.
~cpp a = b๊ทธ๋ฐ๋ฐ b๊ฐ a๋ก ์ด๊ธฐํ๋ ๋ ํผ๋ฐ์ค๋ผ๋ฉด ๋ณด๊ธฐ์๋ ์ฌ๊ท์นํ์ ํด๋นํ๋ค. ์ด๋ฐ ๊ฐ๋ฅํ ์ํฉ์ ๋์ฒํ๊ธฐ ์ํด ํน๋ณํ ์ฃผ์๋ฅผ ๊ฐ์ง๋ ๊ฒ์ ๋ ๋๊ฐ์ง ์ข์ ์ ์ด ์๋ค. ์ฒซ์งธ๋ ํจ์จ์ฑ์ด๋ค. ์นํ ์ฐ์ฐ์์ ์์ ๋ถ๋ถ์์ ์ฌ๊ท์นํ์ ๊ฒ์ฌํ ์ ์๋ค๋ฉด, ๋ฐ๋ก ๋ฆฌํดํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋๋ฒ์งธ๋, ์ ํํจ์ ํ์ธํ๋ ๊ฒ์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก ์นํ ์ฐ์ฐ์๋ ๊ฐ์ฒด์ ์๋ก์ด ๊ฐ์ ํด๋นํ๋ ์๋ก์ด ๋ฆฌ์์ค๋ค์ ํ ๋นํ๊ธฐ ์ ์ ๊ฐ์ฒด์ ํ ๋น๋ ๋ฆฌ์์ค๋ค์ ํด์ ํด์ผ๋ง ํ๋ค. ์ด์ ๊ฐ๋ค์ ์ ๊ฑฐํด์ผ ํ๋ค๋ ๋ง์ด๋ค. ์ฌ๊ท์นํ์ผ ๊ฒฝ์ฐ ์ด๋ฐ์์ผ๋ก ์ด์ ๊ฐ๋ค์ ์ ๊ฑฐํ ๊ฒฝ์ฐ ํฐ hazard๋ฅผ ๊ฐ์ ธ ์จ๋ค. ์๋ํ๋ฉด, ๊ธฐ์กด ๋ฆฌ์์ค๋ค์ด ์๋ก์ด ๋ฆฌ์๋ค์ ์นํํ๋ ๊ณผ์ ์์ ํ์ํ๊ฒ ๋ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
String ๊ฐ์ฒด๋ค์ ์นํ์ ์๊ฐํด ๋ณด์. ์ฌ๊ธฐ์์ ์ฌ๊ท์นํ์ ๊ฒ์ฌํ์ง ์๊ณ ์๋ค.
~cpp class String { public: String(const char *value); // see Item 11 for // function definition ~String(); // see Item 11 for // function definition ... String& operator=(const String& rhs); private: char *data; }; // an assignment operator that omits a check // for assignment to self String& String::operator=(const String& rhs) { delete [] data; // delete old memory // allocate new memory and copy rhs's value into it data = new char[strlen(rhs.data) + 1]; strcpy(data, rhs.data); return *this; // see Item 15 }๊ทธ๋ฆฌ๊ณ , ์ด์ ๊ฐ์ ๊ฒฝ์ฐ๋ฅผ ๋ณด์.
~cpp String a = "Hello"; a = a; // same as a.operator=(a)String๊ฐ์ฒด์ operator= ์ฐ์ฐ์๋ฅผ ๋ณผ๋ *this์ rhs๋ ๋ค๋ฅธ๊ฒ ์ฒ๋ผ ๋ณด์ด์ง๋ง, ์ด ๋์ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ pointingํ๊ณ ์๋ค. (๊ฐ์ ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์..)
์นํ ์ฐ์ฐ์๊ฐ ์ํํ๋ ์ฒซ ๋ฒ์งธ ์์ ์ด data๋ฅผ ์ญ์ ํ๋ ๊ฒ์ด๋ฉฐ, ๊ฒฐ๊ณผ๋ ๋ค์๊ณผ ๊ฐ๋ค.
์ด์ ์นํ์ฐ์ฐ์์์ strcpy๋ฅผ ์ํํ ๋ ๋ฐ์ํ๋ ์ผ์ ์์ธกํ ์ ์๊ฒ ๋์๋ค. ์ด๊ฒ์ data๊ฐ ์ญ์ ๋๋ฉด์ rhs.data๊ฐ ์ญ์ ๋์๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๊ฒ์ data, this->data ๊ทธ๋ฆฌ๊ณ , rhs.data๊ฐ ๋ชจ๋ ๊ฐ์ ํฌ์ธํฐ๊ธฐ ๋๋ฌธ์ ๊ทธ๋ ๊ฒ ๋๊ฒ์ด๋ค. ์ต์ ์ ์ํฉ์ด๋ค..
์ด์ ์? ์ฌ๊ท์นํ์ ๊ฒ์ฌํด์ผ ํ๋์ง ์์์ ๊ฒ์ด๋ค.
๊ทธ๋ผ, ์ด๋ค์์ผ๋ก ์ฌ๊ท์นํ์ธ์ง ์๋์ง๋ฅผ ๊ฒ์ฌํ ๊น? ์ข ๋ฅ๋ ๋ค์ํ๋ค.
~cpp // data์ ๋์ผ์ฑ์ ๊ฒ์ฌ String& String::operator=(const String& rhs) { if (strcmp(data, rhs.data) == 0) return *this; ... } // ๊ฐ์ฒด์ ๋ฉค๋ฒ ๋ณ์๋ค์ ๊ฐ์ด ๋์ผํ์ง ๊ฒ์ฌ // ์ด๋ operator== ์ ๋ค์ ์ฌ์ ์ ํด์ฃผ์ด์ผ ํ๋ค C& C::operator=(const C& rhs) { // check for assignment to self if (*this == rhs) // assumes op== exists return *this; ... } // ์ฃผ์๊ฐ์ ํตํ ๊ฒ์ฌ - ๊ฐ์ฅ ์ข์ ํจ๊ณผ๋ฅผ ๊ธฐ๋ํ ๋ง ํ๋ค. C& C::operator=(const C& rhs) { // check for assignment to self if (this == &rhs) return *this; ... } // ํด๋์ค๋ง๋ค ์๋ณ์๋ฅผ ๋์ด ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ // ์ด๊ฒฝ์ฐ์๋ operator == ์ ์ ์ํ์ฌ ์๋ณ์๊ฐ ๊ฐ์์ง ๊ฒ์ฌํด๋ณด์์ผ ํ๋ค. class C { public: ObjectID identity() const; // see also Item 36 ... };
4. Classes and Functions: Design and Declaration ¶
ํจ๊ณผ์ ์ธ ํด๋์ค ์ค๊ณ๋ ๋ฌด์์ธ๊ฐ? ๋ฅผ ๋ค๋ฃจ๋ ๋ถ๋ถ
1. ๊ฐ์ฒด๋ค์ด ์ด๋ป๊ฒ ์์ฑ๋๊ณ ์๋ฉธ๋ ๊ฒ์ธ๊ฐ?
2. ๊ฐ์ฒด ์ด๊ธฐํ์ ๊ฐ์ฒด ์นํ์ด ์ด๋ ์ ๋ ์ฐจ์ด๊ฐ ๋๋๊ฐ?
3. ์๋ก์ด ํ์ ์ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ์ํด ์ ๋ฌํ๋ ๊ฒ์ ๋ฌด์์ ์๋ฏธ ํ๋๊ฐ?
4. ์๋ก์ด ํ์ ์ ๊ฐ์ฒด๊ฐ ์์ ๊ทธ๋ํ์ ๋ง๋๊ฐ?
5. ์ด๋ค ์ข ๋ฅ์ ํ์ ๋ณํ์ด ํ์ฉ๋๋๊ฐ?
6. ์ด๋ค ์ฐ์ฐ์์ ํจ์๊ฐ ์๋ก์ด ํ์ ์ ์ํด ์ ๋นํ๊ฐ?
7. ์ ๊ทผ ์ฐ์ฐ์(public, protected, private)๋ฅผ ์ด๋ป๊ฒ ์ ์ฉํ ๊ฒ์ธ๊ฐ?
8. etc..
1. ๊ฐ์ฒด๋ค์ด ์ด๋ป๊ฒ ์์ฑ๋๊ณ ์๋ฉธ๋ ๊ฒ์ธ๊ฐ?
2. ๊ฐ์ฒด ์ด๊ธฐํ์ ๊ฐ์ฒด ์นํ์ด ์ด๋ ์ ๋ ์ฐจ์ด๊ฐ ๋๋๊ฐ?
3. ์๋ก์ด ํ์ ์ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ์ํด ์ ๋ฌํ๋ ๊ฒ์ ๋ฌด์์ ์๋ฏธ ํ๋๊ฐ?
4. ์๋ก์ด ํ์ ์ ๊ฐ์ฒด๊ฐ ์์ ๊ทธ๋ํ์ ๋ง๋๊ฐ?
5. ์ด๋ค ์ข ๋ฅ์ ํ์ ๋ณํ์ด ํ์ฉ๋๋๊ฐ?
6. ์ด๋ค ์ฐ์ฐ์์ ํจ์๊ฐ ์๋ก์ด ํ์ ์ ์ํด ์ ๋นํ๊ฐ?
7. ์ ๊ทผ ์ฐ์ฐ์(public, protected, private)๋ฅผ ์ด๋ป๊ฒ ์ ์ฉํ ๊ฒ์ธ๊ฐ?
8. etc..
4.1. Item 18. ์ต์ํ์ ์์ ํ ํด๋์ค ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ตฌํ๋ค. ¶
interface? ํด๋์ค๋ฅผ ์ด์ฉํ๋ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ ๊ทผํ ์ ์๋ ์๋จ์ ์ฃผ๋ ๊ฒ์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก ํจ์๋ค๋ง ์ด๋ฌํ ์ธํฐํ์ด์ค ๋ด์ ์กด์ฌํ๋ค. ๋ง์ฝ ํด๋์ค๋ด์ ๋ฐ์ดํ ๋ณ๋ค์๊ฒ ์ ๊ทผ์ ํ์ฉํ๊ฒ ๋๋ฉด ๋ง์ ๋จ์ ๋ค์ด ์๊ธฐ๊ธฐ ๋๋ฌธ์ด๋ค. (๋ณ๋ก ๋๋ผ์ง๋ ๋ชปํด ๋ดค๋ค.. ^^;)
์ต์ํ์ ์์ ํ ํด๋์ค ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ตฌํ๋ค(?) ์ด๋ง์ ํด๋์ค๋ด์ ๊ตฐ๋๋๊ธฐ ์ฆ ๋น์ทํ ์ผ์ ํ๋ ๋ฉค๋ฒ ํจ์๊ฐ ์กด์ฌ ํ์ง ์๋๋ค๋ ์๋ฏธ๋ ๋๋ค. ๊ทธ๋ฆฌ๊ณ , ๊ทธ ํด๋์ค๋ ๊ทธ๋งํผ ๋ณต์กํ์ง์์ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ , ์ต์ํ์ ์ธํฐํ์ด์ค๋ก ์ด ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ์ฌ์ฉ์๊ฐ ๋ชจ๋ ์ผ(?)์ ํ ์๊ฐ ์์ด์ผํ๋ค.
๊ทธ๋ฐ๋ฐ, ์ ์ต์ํ์ธ๊ฐ? ์ฌ๋ฌ๊ฐ์ง ์ผ์ ํ ์ ์๋ ๋ฉค๋ฒ ํจ์๋ค์ ๊ณ์ ์ถ๊ฐํด ๋๊ฐ๋ฉด ์๋๋ ๊ฒ์ธ๊ฐ? ๋๋ต์ ์๋๋ค. ์ ์๋๋ ๊ฒ์ผ๊น? ๋น์ ์ ๋ฉค๋ฒ ํจ์๊ฐ 10๊ฐ ์๋ ํด๋์ค์ 100๊ฐ๊ฐ ์๋ ํด๋์ค์ค ์ด๋ค๊ฒ์ด ์ดํดํ๊ธฐ ์ฝ๋ค๊ณ ์๊ฐํ๋๊ฐ? ๋ ๋ง ์ฐ๋ ค๋ ํด๋์ค๊ฐ ์๋์ด์ ๋ค๋ฅธ ์ฌ์ฉ์๋ค์ด ์ฝ๊ฒ ์ดํด ํ ์ ์๋๋ก ๋ง๋ค์ด์ผ ํ์ง ์๊ฒ ๋๊ฐ? ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ต์ํ์ ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ตฌํ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ , ๊ด๋ฆฌ์ ์ธ ๋ฉด์์ ๋ณผ๋ ์ ์ ํจ์๋ค์ ๊ฐ์ง ํด๋์ค๊ฐ ์ฉ์ดํ๋ค๋ ๊ฒ์ด๋ค. ์ค๋ณต๋ ์ฝ๋๋ผ๋์ง ์๋๋ฉด ๊ฐ์ ํ ๊ฒ๋ค์ ํฅํ์ ํ๊ธฐ ์ฝ๋ค๋ ๊ฒ์ด๋ค. ๋ํ, document๋ฅผ ์์ฑํ๋ค ๋ ์ง ํ ๋ ์ ์ ๋ฉค๋ฒ ํจ์๋ค์ ๊ฐ์ง ํด๋์ค ์ชฝ์ด ์ฉ์ดํ๋ค๋ ๊ฒ์ด๋ค. ๋ง์ง๋ง์ผ๋ก ์์ฃผ ๊ธด ํด๋์ค ์ ์๋ ๊ธด ํค๋ ํ์ผ์ ์ด๋ ํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ํค๋ ํ์ผ๋ค์ ํ๋ก๊ทธ๋จ์ด ์ปดํ์ผ๋ ๋๋ง๋ค ๋งค ๋ฒ ์ฝํ์ ธ์ผ ํ๊ธฐ ๋๋ฌธ์ ํ์ ์ด์ ๊ธด ํด๋์ค ์ ์๋ ํ๋ก์ ํธ ์ฃผ๊ธฐ ์ค์ ์ด ์ปดํ์ผ ์๊ฐ์ ๊ฐ์ ๋จน๋๋ค. ๊ทธ๋ฐ ์ด์ ๋ค ๋๋ฌธ์ ์ต์ํ์ ํด๋์ค ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ตฌํ๋ ๊ฒ์ด ์ข๋ ๋์ ํ๋จ์ด๋ผ๋ ๊ฒ์ด๋ค.
์ต์ํ์ ์์ ํ ํด๋์ค ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ตฌํ๋ค(?) ์ด๋ง์ ํด๋์ค๋ด์ ๊ตฐ๋๋๊ธฐ ์ฆ ๋น์ทํ ์ผ์ ํ๋ ๋ฉค๋ฒ ํจ์๊ฐ ์กด์ฌ ํ์ง ์๋๋ค๋ ์๋ฏธ๋ ๋๋ค. ๊ทธ๋ฆฌ๊ณ , ๊ทธ ํด๋์ค๋ ๊ทธ๋งํผ ๋ณต์กํ์ง์์ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ , ์ต์ํ์ ์ธํฐํ์ด์ค๋ก ์ด ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ์ฌ์ฉ์๊ฐ ๋ชจ๋ ์ผ(?)์ ํ ์๊ฐ ์์ด์ผํ๋ค.
๊ทธ๋ฐ๋ฐ, ์ ์ต์ํ์ธ๊ฐ? ์ฌ๋ฌ๊ฐ์ง ์ผ์ ํ ์ ์๋ ๋ฉค๋ฒ ํจ์๋ค์ ๊ณ์ ์ถ๊ฐํด ๋๊ฐ๋ฉด ์๋๋ ๊ฒ์ธ๊ฐ? ๋๋ต์ ์๋๋ค. ์ ์๋๋ ๊ฒ์ผ๊น? ๋น์ ์ ๋ฉค๋ฒ ํจ์๊ฐ 10๊ฐ ์๋ ํด๋์ค์ 100๊ฐ๊ฐ ์๋ ํด๋์ค์ค ์ด๋ค๊ฒ์ด ์ดํดํ๊ธฐ ์ฝ๋ค๊ณ ์๊ฐํ๋๊ฐ? ๋ ๋ง ์ฐ๋ ค๋ ํด๋์ค๊ฐ ์๋์ด์ ๋ค๋ฅธ ์ฌ์ฉ์๋ค์ด ์ฝ๊ฒ ์ดํด ํ ์ ์๋๋ก ๋ง๋ค์ด์ผ ํ์ง ์๊ฒ ๋๊ฐ? ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ต์ํ์ ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ตฌํ๋ ๊ฒ์ด๋ค. ๊ทธ๋ฆฌ๊ณ , ๊ด๋ฆฌ์ ์ธ ๋ฉด์์ ๋ณผ๋ ์ ์ ํจ์๋ค์ ๊ฐ์ง ํด๋์ค๊ฐ ์ฉ์ดํ๋ค๋ ๊ฒ์ด๋ค. ์ค๋ณต๋ ์ฝ๋๋ผ๋์ง ์๋๋ฉด ๊ฐ์ ํ ๊ฒ๋ค์ ํฅํ์ ํ๊ธฐ ์ฝ๋ค๋ ๊ฒ์ด๋ค. ๋ํ, document๋ฅผ ์์ฑํ๋ค ๋ ์ง ํ ๋ ์ ์ ๋ฉค๋ฒ ํจ์๋ค์ ๊ฐ์ง ํด๋์ค ์ชฝ์ด ์ฉ์ดํ๋ค๋ ๊ฒ์ด๋ค. ๋ง์ง๋ง์ผ๋ก ์์ฃผ ๊ธด ํด๋์ค ์ ์๋ ๊ธด ํค๋ ํ์ผ์ ์ด๋ ํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ํค๋ ํ์ผ๋ค์ ํ๋ก๊ทธ๋จ์ด ์ปดํ์ผ๋ ๋๋ง๋ค ๋งค ๋ฒ ์ฝํ์ ธ์ผ ํ๊ธฐ ๋๋ฌธ์ ํ์ ์ด์ ๊ธด ํด๋์ค ์ ์๋ ํ๋ก์ ํธ ์ฃผ๊ธฐ ์ค์ ์ด ์ปดํ์ผ ์๊ฐ์ ๊ฐ์ ๋จน๋๋ค. ๊ทธ๋ฐ ์ด์ ๋ค ๋๋ฌธ์ ์ต์ํ์ ํด๋์ค ์ธํฐํ์ด์ค๋ฅผ ์ถ๊ตฌํ๋ ๊ฒ์ด ์ข๋ ๋์ ํ๋จ์ด๋ผ๋ ๊ฒ์ด๋ค.
4.2. Item 19. ๋ฉค๋ฒ ํจ์, ๋น๋ฉค๋ฒ ํจ์ ๋ฐ ํ๋ ๋ ํจ์๋ฅผ ๊ตฌ๋ณํ๋ค. ¶
๋๊ฒ class๋ด์ operator ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํจ์ผ๋ก์ ์ข๋ ํธํ code(?)๋ผ๋ ๊ฒ์ ํ๊ธฐ ์ํด์ ์ ์ธ ํ๋ ํจ์๋ค์ด ๋ฉค๋ฒ ํจ์์ฌ์ผ ํ๋์ง ์๋๋ฉด friendํจ์์ฌ์ผ ํ๋์ง๋ฅผ
์ฅ๋ ์ฅ๋ ํ๋ ๊ฒ์ด๋ค. ๋ฉค๋ฒ ๋ณ์๋ค์ ์ฐ์ฐ์ ๋ค์ํ๊ฒ ์ ์ฉ์ํค๊ณ ์ถ๋ค๋ฉด friend ํจ์๋ฅผ ์จ์ ์ผ๋ฐ ์์๊ฐ ํด๋์ค ์ธ์คํด์ค์ ์ผํธ์ ์๋ฆฌ ์ก๊ณ ์์ด๋ ์ฐ์ฐ์ด ๋๊ฒ ํ๊ณ ์ถ๋ค๋ผ๋ ์๊ฐ์ ๊ฐ์ง๊ณ ์์ผ๋ฉด friendํจ์๋ฅผ ์จ์ ๋น ๋ฉค๋ฒ ํจ์๋ฅผ ๋ง๋ค์ด ๊ทธ ์ฐ์ฐ์ ์ง์ํ๋ผ๋ ์๊ธฐ ์ด๋ค.
- tip -
์ฌ๊ธฐ์ f๋ ์ ์ ํ ์ ์ธํ๊ณ ์ ํ๋ ํจ์๋ฅผ ๋ํ๋ด๊ณ C๋ ๊ฐ๋ ์ ์ผ๋ก ๊ด๋ จ์๋ ํด๋์ค๋ฅผ ์๋ฏธํ๋ค.
์ฅ๋ ์ฅ๋ ํ๋ ๊ฒ์ด๋ค. ๋ฉค๋ฒ ๋ณ์๋ค์ ์ฐ์ฐ์ ๋ค์ํ๊ฒ ์ ์ฉ์ํค๊ณ ์ถ๋ค๋ฉด friend ํจ์๋ฅผ ์จ์ ์ผ๋ฐ ์์๊ฐ ํด๋์ค ์ธ์คํด์ค์ ์ผํธ์ ์๋ฆฌ ์ก๊ณ ์์ด๋ ์ฐ์ฐ์ด ๋๊ฒ ํ๊ณ ์ถ๋ค๋ผ๋ ์๊ฐ์ ๊ฐ์ง๊ณ ์์ผ๋ฉด friendํจ์๋ฅผ ์จ์ ๋น ๋ฉค๋ฒ ํจ์๋ฅผ ๋ง๋ค์ด ๊ทธ ์ฐ์ฐ์ ์ง์ํ๋ผ๋ ์๊ธฐ ์ด๋ค.
~cpp Num a(10); int temp; temp = 2 * a; // ์ด๋ฐ ์ฐ์ฐ. - friendํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ์ฐ์๋ฅผ ์ ์ ํด์ค์ผ์ง๋ง ์๋ํ๋ค.๊ทธ๋ ์ง๋ง, ์ด๋ฐ ์ฐ์ฐ์๋ค์ ๊ฑฐ์ ์์ฐ๋ ๊ฒ๊ฐ๋ค.. ใ กใ ก; ๋๋ friendํจ์ ์จ๋ณธ ์ผ์ด ์๋ค.. ใ กใ ก; ํ๊ต ์ํ์์ ๋์ฌ๋ฒํ ์๊ธฐ๋ค.
- tip -
์ฌ๊ธฐ์ f๋ ์ ์ ํ ์ ์ธํ๊ณ ์ ํ๋ ํจ์๋ฅผ ๋ํ๋ด๊ณ C๋ ๊ฐ๋ ์ ์ผ๋ก ๊ด๋ จ์๋ ํด๋์ค๋ฅผ ์๋ฏธํ๋ค.
- operator>>์ operator<<๋ ๊ฒฐ์ฝ ๋ฉค๋ฒ๊ฐ ๋ ์ ์๋ค. ๋ง์ผ f๊ฐ operator>>๋๋ operator<<์ด๋ผ๋ฉด, f๋ฅผ ๋น๋ฉค๋ฒ ํจ์๋ก ๋ง๋ ๋ค. ๊ฒ๋ค๊ฐ f๊ฐ C์ ๋น๊ณต์ฉ ๋ฉค๋ฒ๋ก ์ ๊ทผ์ด ์๊ตฌ๋๋ค๋ฉด f๋ฅผ C์ ํ๋ ๋๋ก ๋ง๋ ๋ค.
- ๋น๋ฉค๋ฒ ํจ์๋ค๋ง ๊ทธ๋ค์ ๊ฐ์ฅ ์ผ์ชฝํธ์ ์๋ ์ธ์์์ ํ์
๋ณํ์ด ์ผ์ด๋๋ค. ๋ง์ผ f๊ฐ ๊ฐ์ฅ ์ผ์ชฝํธ์ ์๋ ์ธ์์์ ํ์
๋ณํ์ ํ์๋ก ํ๋ค๋ฉด f๋ฅผ ๋น๋ฉค๋ฒ ํจ์๋ก ๋ง๋ ๋ค. ๊ฒ๋ค๊ฐ f๊ฐ C์ ๋น๊ณต์ฉ ๋ฉค๋ฒ์ ์ ๊ทผ์ด ํ์ํ๋ค๋ฉด f๋ฅผ C์ ํ๋ ๋๋ก ๋ง๋ ๋ค.
- ๊ทธ ๋ฐ์ ๋ชจ๋ ๊ฒ์ ๋ฉค๋ฒ ํจ์์ด์ด์ผ ํ๋ค. ์ด์์ ์ด๋ค ๊ฒ์๋ ํด๋น๋์ง ์์ผ๋ฉด f๋ฅผ C์ ๋ฉค๋ฒ ํจ์๋ก ๋ง๋ ๋ค.
4.3. Item 20. ๋ฐ์ดํฐ ๋ฉค๋ฒ๋ฅผ ๊ณต์ฉ(public) ์ธํฐํ์ด์ค์ ํฌํจ์ํค์ง ์๋๋ค. ¶
์ ๋ชฉ๊ทธ๋๋ก.
4.4. Item 21. ๊ฐ๋ฅํ const๋ฅผ ์ด์ฉํ๋ค. ¶
const๋ฅผ ์ฐ๋ ์ด์ ๋ ์๋์ ๊ฐ์ ์ ๋๋ก ๋ณํ์ง ๋ง์์ผ ํ๋ค๋๊ฒ์ ๋ณด์ฌ์ฃผ๊ธฐ ์ํจ์ด๋๊น? ์๋ฌดํผ const๋ก ์ง์ ์ ํด๋์ผ๋ฉด ์ด๋ป๊ฒ ํ๋ ๊ทธ ๊ฐ์ ์ ๋๋ก ๋ณํ์ง ์๋ ๋ค๋๊ฒ์ ๋ณด์ฅ์ด ๋๋ค.
~cpp const char *p = "Hello"; char * const p = "Hello"; const char * const p = "Hello"; // ์ด ์ธ๊ฐ์ง์ ์ฐจ์ด์ ์ ๋ญ๊น์? // ์ ์๊ฐ ํ๋ฉด ์์ ์์ ๊ฑฐ์์. // pointer๋ ๊ฐ๋ฆฌํค๋ ๊ณณ์ ๊ฐ๊ณผ, ์ฃผ์๋ก ์ด๋ฃจ์ด ์ง ๋์ด๋๊น. // ์ด๋ค๋๋ ์ฃผ์๊ฐ ๋ณํ์ง ๋ง์์ผ๋ฉด ํ ๋์ด๊ณ , // ์ด๋ค๋์ ๊ฐ๋ฆฌํค๋ ๊ณณ์ ๊ฐ์ด ๋ณํ์ง ๋ง์์ผ๋ฉด ํ ๋.. ์ด๋ฐ ์์ผ๋ก ์๊ฐํ๋ฉด ์ฌ์ธ๋ฏ ํ๋ค์.. ใ ใ .. ์ถํ์ ์ ๋ฆฌ..
4.5. ํญ๋ชฉ 22. ๊ฐ์ ์ํ ํธ์ถ๋ณด๋ค๋ ๋ ํผ๋ฐ์ค์ ์ํ ํธ์ถ์ ์ ํธํ๋ค. ¶
์ด ํญ๋ชฉ์ ์ฐธ์กฐ๋ฅผ ์ ์ฉํ๊ฒ ์ฌ์ฉํ ์ ์๋ ๊ฒฝ์ฐ์ด๋ค.
์ฒซ๋ฒ์งธ๋ ํจ์์ ๋ฆฌํด๊ฐ์ผ๋ก ์ฌ์ฉ์ ๋ฌด๋ฆฌํ๊ฒ ์์๊ฐ์ฒด๊ฐ ์์ฑ์ด ๋ ์ ์๋ค.
{{|
class Person
{
class Student : public Person
{
|}}
์ด๋ ๊ฒ ํด๋์ค๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ
{{|
Student returnStudent(Student s)
{
์ฒซ๋ฒ์งธ๋ ํจ์์ ๋ฆฌํด๊ฐ์ผ๋ก ์ฌ์ฉ์ ๋ฌด๋ฆฌํ๊ฒ ์์๊ฐ์ฒด๊ฐ ์์ฑ์ด ๋ ์ ์๋ค.
{{|
class Person
{
...
private:
}private:
string name, address;
class Student : public Person
{
...
private:
}private:
string schoolName, schoolAddress;
|}}
์ด๋ ๊ฒ ํด๋์ค๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ
{{|
Student returnStudent(Student s)
{
return s;
}...
Student plato;
returnStudent(plato);
|}}
์ด๋ ๊ฒ ํธ์ถ์ด ๋๋ค๋ฉด
|}}
์ด๋ ๊ฒ ํธ์ถ์ด ๋๋ค๋ฉด
plato๋ returnStudentํจ์์์ ์ธ์๋ก ๋์ด๊ฐ๋ฉด์ ์์๊ฐ์ฒด๋ฅผ ๋ง๋ค๊ฒ ๋๊ณ ํจ์ ๋ด์ ์ฐ์ด๋ฉด์ s๋ก ๋ ํ๋ฒ ์์ฑ๋๊ณ ํจ์๊ฐ ํธ์ถ์ด ๋๊ณ ๋ฐํ ๋ ๋ ๋ฐํ๋ ๊ฐ์ฒด๋ฅผ ์ํด ๋ ํ๋ฒ ๋ณต์ฌ ์์ฑ์๊ฐ ํธ์ถ๋๋ค.
์ด 3๋ฒ์ ๋ถ๊ฐ์ ์ธ ํธ์ถ์ด ์ผ์ด๋๋ฉด์ ๋ฉค๋ฒ์ธ string๋ค์ ์ด 12๋ฒ์ด๋ ์์ฑ์ด๋๊ณ ํ๊ดด๊ฐ ๋๋ค.
์ด 3๋ฒ์ ๋ถ๊ฐ์ ์ธ ํธ์ถ์ด ์ผ์ด๋๋ฉด์ ๋ฉค๋ฒ์ธ string๋ค์ ์ด 12๋ฒ์ด๋ ์์ฑ์ด๋๊ณ ํ๊ดด๊ฐ ๋๋ค.
๋๋ฒ์งธ๋ ์๋ผ์ง๋ ๋ฌธ์ (slicing problem)๋ก ์์ ์์์ returnStudentํจ์์ ์ธ์๋ก Personํ ๊ฐ์ฒด๊ฐ ๋ค์ด ์บ์คํ
ํด์ ๋ค์ด๊ฐ๋ ๊ฒฝ์ฐ ๋ด๋ถ์ ์ธ ์์๊ฐ์ฒด๋ค์ ์์ฑ์ผ๋ก Studentํ ๊ฐ์ฒด๋ก ์ธ์๋ Studentํ ๊ฐ์ฒด๋ง์ ๋ฉค๋ฒ๋ฅผ ํธ์ถํ๊ฒ๋๋ฉด ์ ์์๋์ ๋ณด์ฅํ ์ ์๊ฒ ๋๋ค.
4.6. ํญ๋ชฉ 23. ๊ฐ์ฒด ๋ฐํ์ ๋ ํผ๋ฐ์ค๋ฅผ ๋ฐํํ์ง ์๋๋ค. ¶
๊ฐ์ฒด ๋ฐํ์ ๊ฐ์ ์ํ ํธ์ถ์ด ์ฐธ์กฐ๋ณด๋ค ํจ์ฌ ๊ฐ๋จํ๊ณ ๋ช
ํํ๋ค.
๊ทธ๋ ์ง ์๊ณ ์ฐธ์กฐ์ ์ํ ํธ์ถ์ ํ ๊ฒฝ์ฐ์ ์ฑ ์์๋ ๋ด๋ถ ์์๊ฐ์ฒด๋ฅผ ํตํด ๋ฐํ์ ํ๋ ค๊ณ ํ ๋ ๊ทธ ์์ ๊ฐ์ฒด์ ๋ฉ๋ชจ๋ฆฌ๋ ์คํ์ ์๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ๊ฐ ๋๊ณ , new๋ฅผ ์ฌ์ฉํด์ ํ ๊ธฐ๋ฐ์ผ๋ก ๋ง๋ค๋๋ ์ฐ๋ฌ์ ์ธ๋ฒ์ ํธ์ถ์ด ์์ ๊ฒฝ์ฐ ํ์ฐ์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋์ถ๋๋ค. ๊ทธ๋ ๋ค๊ณ static์ ์ ์ ๊ฐ์ฒด์ ๊ฒฝ์ฐ์๋ ๋น๊ต๋ฌธ(operator =)์์ ์ฌ์ฉ๋๋ค๋ฉด ์ธ์ ๊ฐ ์ฐธ์ผ๋ก ๊ณ์ฐ์ด ๋ ๊ฒ์ด๋ค. ๊ทธ๋ ๋ค๊ณ ์ ์ ๊ฐ์ฒด ๋ฐฐ์ด๋ก ๋ฌด๋ฆฌํด์ ๊ตฌํ์ ํ๊ณ ์ ํ๋ค๋ฉด ๊ทธ๊ฑด ๋ฐ๋ก ์ฝ์ง์ด๋ค.
๊ทธ๋ ์ง ์๊ณ ์ฐธ์กฐ์ ์ํ ํธ์ถ์ ํ ๊ฒฝ์ฐ์ ์ฑ ์์๋ ๋ด๋ถ ์์๊ฐ์ฒด๋ฅผ ํตํด ๋ฐํ์ ํ๋ ค๊ณ ํ ๋ ๊ทธ ์์ ๊ฐ์ฒด์ ๋ฉ๋ชจ๋ฆฌ๋ ์คํ์ ์๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ๊ฐ ๋๊ณ , new๋ฅผ ์ฌ์ฉํด์ ํ ๊ธฐ๋ฐ์ผ๋ก ๋ง๋ค๋๋ ์ฐ๋ฌ์ ์ธ๋ฒ์ ํธ์ถ์ด ์์ ๊ฒฝ์ฐ ํ์ฐ์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋์ถ๋๋ค. ๊ทธ๋ ๋ค๊ณ static์ ์ ์ ๊ฐ์ฒด์ ๊ฒฝ์ฐ์๋ ๋น๊ต๋ฌธ(operator =)์์ ์ฌ์ฉ๋๋ค๋ฉด ์ธ์ ๊ฐ ์ฐธ์ผ๋ก ๊ณ์ฐ์ด ๋ ๊ฒ์ด๋ค. ๊ทธ๋ ๋ค๊ณ ์ ์ ๊ฐ์ฒด ๋ฐฐ์ด๋ก ๋ฌด๋ฆฌํด์ ๊ตฌํ์ ํ๊ณ ์ ํ๋ค๋ฉด ๊ทธ๊ฑด ๋ฐ๋ก ์ฝ์ง์ด๋ค.
4.7. ํญ๋ชฉ 24. ํจ์ ์ค๋ฒ๋ก๋ฉ๊ณผ ๋ํดํธ ์ธ์๊ฐ ์ค์์ ์ฃผ์๊น๊ฒ ์ ํํ๋ค. ¶
- std::numeric_limits<TYPE>::min(); // ํค๋ <limits> TYPE์ ์ต์๊ฐ์ ๊ตฌํด์ค๋ค. INT_MIN๊ณผ ๊ฐ์ ๊ฐ.
์๋ฅผ ๋ค๋ฉด 5๊ฐ์ ๊ฐ์ ํ๊ท ์ ๋ธ๋ค๋๊ฐ ํ๋ ๊ฒฝ์ฐ๋ ๋ํดํธ ์ธ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
์์ ์ด ์์์ ์ํฉ์ ๋ฐ๋ผ ์ฒ์ ํ๋๋ก.
4.8. ํญ๋ชฉ 25. ํฌ์ธํฐ๋ ์์นํ ํ์ ์์ ์ค๋ฒ๋ก๋ฉ์ ํผํ๋ค. ¶
๋ง์ฝ ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ
{{|
void f(string *);
f(int);
..
f(0); // ์ ์ํ 0์ด๋ฏ๋ก f(int)๊ฐ ํธ์ถ
f(NULL); // ?-_-? ๊ต์ฅํ ๋ณต์ก ๋ฏธ๋ฌํ๋ค-_-; ์ ์ธ์ ๋ฐ๋ผ์ 0์ด ๋ ์๋ (void*)0์ด ๋ ์๋ 0L์ด ๋ ์๋ ๋ฑ๋ฑ์ ๊ฒฝ์ฐ๊ฐ ์๋ค.
|}}
NULL์ด๋ผ๋ ์์์ ๋ํ ํ์ ์ ์ ์๊ฐ ๋ชจํธํ๋ค.
{{|
void f(string *);
f(int);
..
f(0); // ์ ์ํ 0์ด๋ฏ๋ก f(int)๊ฐ ํธ์ถ
f(NULL); // ?-_-? ๊ต์ฅํ ๋ณต์ก ๋ฏธ๋ฌํ๋ค-_-; ์ ์ธ์ ๋ฐ๋ผ์ 0์ด ๋ ์๋ (void*)0์ด ๋ ์๋ 0L์ด ๋ ์๋ ๋ฑ๋ฑ์ ๊ฒฝ์ฐ๊ฐ ์๋ค.
|}}
NULL์ด๋ผ๋ ์์์ ๋ํ ํ์ ์ ์ ์๊ฐ ๋ชจํธํ๋ค.
์ด๋ฐ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ ๋ฐฉ๋ฒ์ด ์๋ค.
{{|
const class // ํด๋์ค์ ์ด๋ฆ์ด ํ์ํ์ง ์๋ค.
{
|}}
๊ฒฐ๋ก ์ ๋๋๋ก์ด๋ฉด ์ด๋ ๊ฒ ๋ณต์กํ๊ฒ ๋ค์ด๊ฐ๋ ๊ฒฝ์ฐ๋ฅผ ๋ง๋ค์ง ์์ผ๋ฉด ๋๋ค.
{{|
const class // ํด๋์ค์ ์ด๋ฆ์ด ํ์ํ์ง ์๋ค.
{
public:
} NULL;template<class T> operator T*() const // ๋ชจ๋ NULL ํฌ์ธํฐ๋ฅผ ๋์ฒดํ๋ค.
{
template
{
private:{
return 0;
}template
{
return 0;
}void operator&() const; // NULL์ ์ฃผ์๊ฐ์ด๋ ์กด์ฌํ์ง ์๋๋ค.
|}}
๊ฒฐ๋ก ์ ๋๋๋ก์ด๋ฉด ์ด๋ ๊ฒ ๋ณต์กํ๊ฒ ๋ค์ด๊ฐ๋ ๊ฒฝ์ฐ๋ฅผ ๋ง๋ค์ง ์์ผ๋ฉด ๋๋ค.
4.9. ํญ๋ชฉ 26. ์ ์ฌ์ ๋ชจํธ์ฑ์ ๊ฒฝ๊ณํ๋ค. ¶
- ๋๊ตฌ๋ ๋๋ฆ๋๋ก์ ์ฒ ํ์ ๊ฐ์ ธ์ผ ํ๋ค. ์ด๋ค ์ด๋ ๋ถ๊ฐ์ญ์ฃผ์ ๊ฒฝ์ ํ์ ๋ฏฟ๊ณ ์ด๋ค ์ด๋ ์คํ์ค์ ๋ฏฟ๋๋ค. ๋ ์ด๋ค ์ด๋ COBOL์ด ์ง์ง ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ผ๊ณ ๋ฏฟ๋๋ค. C++๋ ๋๋ฆ์ ์ฒ ํ์ ๊ฐ์ง๊ณ ์๋ค. C++๋ ์ ์ฌ์ ์ธ ์ ๋งค๋ชจํธ์ฑ์ ์๋ฌ๊ฐ ์๋๋ผ๊ณ ์๊ฐํ๋ค. ๋๋ ๊ณผํ-๊ธฐ์ ์์ ์์๋ ์ด๋ฌํ ์ถฉ๋ถํ ๊น์ ์๊ฐ์ ์ด์ผ๊ธฐ๋ ํ์ํ๋ค๊ณ ์๊ฐํ๋ค.
์ฑ ์์๋ ๋ช๊ฐ์ง ์๋ฅผ ๋ค๊ณ ์๋ค.
{{|
void f(A);
...
B b;
f(b);
|}}
๋ฅผ ํธ์ถ์ ํจ์ f๋ ์ธ์๋ก A๋ฅผ ์๊ตฌํ๋ค. ์ฐ์ B๊ฐ A์ ์์์ด๋ ๋ถ๋ชจ์ธ์ง๋ฅผ ํ์ธ ํด๋ณผํ ๊ณ operator A()๋ฅผ ์ฐพ์ ๋ณผ์ง๋ ๋ชจ๋ฅธ๋ค.
๋ง์ฝ ์ด ๋๊ฐ๊ฐ ๋ง์กฑํ๋ B๋ผ๋ฉด ์ ๋งค๋ชจํธ์ฑ์ ๊ฒฝ์ฐ์ด๋ค. (์ด๋ฐ ๊ฒฝ์ฐ๋ ๋ง๋ค๋ฉด ์๋ ๊บผ๋ผ๊ณ ์๊ฐํ๋ค.)
f(b);
|}}
๋ฅผ ํธ์ถ์ ํจ์ f๋ ์ธ์๋ก A๋ฅผ ์๊ตฌํ๋ค. ์ฐ์ B๊ฐ A์ ์์์ด๋ ๋ถ๋ชจ์ธ์ง๋ฅผ ํ์ธ ํด๋ณผํ ๊ณ operator A()๋ฅผ ์ฐพ์ ๋ณผ์ง๋ ๋ชจ๋ฅธ๋ค.
๋ง์ฝ ์ด ๋๊ฐ๊ฐ ๋ง์กฑํ๋ B๋ผ๋ฉด ์ ๋งค๋ชจํธ์ฑ์ ๊ฒฝ์ฐ์ด๋ค. (์ด๋ฐ ๊ฒฝ์ฐ๋ ๋ง๋ค๋ฉด ์๋ ๊บผ๋ผ๊ณ ์๊ฐํ๋ค.)
{{|
void f(int);
void f(char);
void f(int);
void f(char);
...
double d=6.02;
f(d)
|}}
๊ฐ์ฅ ์ฝ๊ฒ ์ ํ ์ ์๋ ์ ๋งค๋ชจํธํ ๊ฒฝ์ฐ์ด๋ค.
์ด ๊ฒฝ์ฐ๋ static_cast<TYPE>๋ฅผ ํตํด ์ฝ๊ฒ ํด๊ฒฐ ๊ฐ๋ฅํ๋ค.
f(d)
|}}
๊ฐ์ฅ ์ฝ๊ฒ ์ ํ ์ ์๋ ์ ๋งค๋ชจํธํ ๊ฒฝ์ฐ์ด๋ค.
์ด ๊ฒฝ์ฐ๋ static_cast<TYPE>๋ฅผ ํตํด ์ฝ๊ฒ ํด๊ฒฐ ๊ฐ๋ฅํ๋ค.
{{|
class Base1
{
class Base2
{
class Derived : public Base1, public Base2
{
}
class Base1
{
public:
}int doIt();
class Base2
{
public:
}int doIt();
class Derived : public Base1, public Base2
{
}
...
Derived d;
d.doIt();
|}}
๋ํ์ ์ธ ๋ค์ค์์์ ์ ๋งค๋ชจํธ์ฑ์ด๋ค.
์ด๊ฒ ๋ํ ์ ๊ทผ๋ฒ์๋ฅผ ์ค์ ํด ์ค์ผ๋ก ์ฝ๊ฒ ํด๊ฒฐ ๊ฐ๋ฅํ๋ค. (d.Base1::doIt()๊ณผ ๊ฐ์ ๊ฒฝ์ฐ)
d.doIt();
|}}
๋ํ์ ์ธ ๋ค์ค์์์ ์ ๋งค๋ชจํธ์ฑ์ด๋ค.
์ด๊ฒ ๋ํ ์ ๊ทผ๋ฒ์๋ฅผ ์ค์ ํด ์ค์ผ๋ก ์ฝ๊ฒ ํด๊ฒฐ ๊ฐ๋ฅํ๋ค. (d.Base1::doIt()๊ณผ ๊ฐ์ ๊ฒฝ์ฐ)
์ด์ ๊ฐ์ ์์์ ์์ ์๋ฏ์ด C++์ ์ ๋งค๋ชจํธ์ฑ์ ํ๋์ ์ฑ์ง๋ก ๋ฐ์ ๋ค์๋ค๊ณ ์๊ฐํ๋ค.
๊ทธ๋์ ๋๋ถ๋ถ์ ์ด์ ๊ฐ์ ๊ฒฝ์ฐ์ ํด๊ฒฐํ ์ ์๋ ์ ์ฐ์ฑ์ด ์๋ค.
๊ทธ๋์ ๋๋ถ๋ถ์ ์ด์ ๊ฐ์ ๊ฒฝ์ฐ์ ํด๊ฒฐํ ์ ์๋ ์ ์ฐ์ฑ์ด ์๋ค.
4.10. ํญ๋ชฉ 27. ์๋ํ์ง ์์ ๋ด๋ถ ์์ฑ ๋ฉค๋ฒ ํจ์์ ์ด์ฉ์ ๋ช ์์ ์ผ๋ก ๋ง๋๋ค. ¶
์์ ํญ๋ชฉ์์ ๋ณด๋ฏ์ด C++์ ์ ๋งค๋ชจํธ์ฑ์ ์ง๋๊ณ ์๋ค.
๋ฐ๋ผ์ ์ฝ๋ฉ์์ ์๋ฌ ์ํ์ฑ์ ๋ฎ์ถ๊ธฐ ์ํด์๋ ์ต๋ํ ๋ช ์์ ์ผ๋ก ํด๊ฒฐํ ์ ์๋ ๋ฐฉ์์ ๋ฃ์ผ๋ฉด ์ข๋ค.
๋ฐ๋ผ์ ์ฝ๋ฉ์์ ์๋ฌ ์ํ์ฑ์ ๋ฎ์ถ๊ธฐ ์ํด์๋ ์ต๋ํ ๋ช ์์ ์ผ๋ก ํด๊ฒฐํ ์ ์๋ ๋ฐฉ์์ ๋ฃ์ผ๋ฉด ์ข๋ค.
์๋ก ์นํ์ฐ์ฐ์๋ฅผ ์ค๋ช
ํ๋ค.
๋ง์ฝ C++์ ํด๋์ค๋ก C ์ธ์ด์ ๋ฐฐ์ด๊ณผ ์ ์ฌํ ํด๋์ค๋ฅผ ๋ง๋ค๊ณ ์ ํ๋ค๋ฉด
C ์ธ์ด์ ๋ฐฐ์ด๊ณผ ์ ์ฌํ ์ฑ์ง์ ์ง๋ ์ผ ํ๋ค.
C ์ธ์ด์์ ๋ฐฐ์ด์ ์นํ์ ๋ถ๋ฒ์ด๋ค.
๊ทธ๋ฌ๋ฏ๋ก C++์ ๋ฐฐ์ดํด๋์ค์ ๊ฒฝ์ฐ๋ ์นํ์ฐ์ฐ์๋ฅผ ์ฝ๋ฉ์์ ๋ถ๋ฒ์ผ๋ก ๋ง๋ค๋ฉด ์ฐจํ ์ ๋งค๋ชจํธํ์ ์ด ์์ด์ง๋ค.
C++์ธ์ด ํด๋์ค ๊ธฐ๋ณธ ์นํ ์ฐ์ฐ์๋ฅผ ๋ฉค๋ฒ์ ๋ณต์ฌ๋ก ์ ์๋์ด ์์ผ๋ฏ๋ก
private์ผ๋ก ์ค๋ฒ๋ผ์ด๋ฉํ๋ฉด ์ ์ ํ๊ฒ ๋์ฒํ ๊ฒฝ์ฐ์ด๋ค.
๋ง์ฝ C++์ ํด๋์ค๋ก C ์ธ์ด์ ๋ฐฐ์ด๊ณผ ์ ์ฌํ ํด๋์ค๋ฅผ ๋ง๋ค๊ณ ์ ํ๋ค๋ฉด
C ์ธ์ด์ ๋ฐฐ์ด๊ณผ ์ ์ฌํ ์ฑ์ง์ ์ง๋ ์ผ ํ๋ค.
C ์ธ์ด์์ ๋ฐฐ์ด์ ์นํ์ ๋ถ๋ฒ์ด๋ค.
๊ทธ๋ฌ๋ฏ๋ก C++์ ๋ฐฐ์ดํด๋์ค์ ๊ฒฝ์ฐ๋ ์นํ์ฐ์ฐ์๋ฅผ ์ฝ๋ฉ์์ ๋ถ๋ฒ์ผ๋ก ๋ง๋ค๋ฉด ์ฐจํ ์ ๋งค๋ชจํธํ์ ์ด ์์ด์ง๋ค.
C++์ธ์ด ํด๋์ค ๊ธฐ๋ณธ ์นํ ์ฐ์ฐ์๋ฅผ ๋ฉค๋ฒ์ ๋ณต์ฌ๋ก ์ ์๋์ด ์์ผ๋ฏ๋ก
private์ผ๋ก ์ค๋ฒ๋ผ์ด๋ฉํ๋ฉด ์ ์ ํ๊ฒ ๋์ฒํ ๊ฒฝ์ฐ์ด๋ค.
4.11. ํญ๋ชฉ 28. ์ ์ญ ๋ค์์คํ์ด์ค๋ฅผ ๋ถํ ํ๋ค. ¶
C++์ ๋ค์ด์ค๋ฉด์ ์ฌ์ฉ๋ ๋ค์์คํ์ด์ค๋ ํ๋ฅญํ ๋ชจ๋๊ด๋ฆฌ๋ฐฉ๋ฒ์ด๋ค.
์ฝ๊ฐ์ ์ถ๊ฐ์ฝ๋ฉ์ผ๋ก ๋งค์ฐ ์ฝ๊ฒ ์ ๋งค๋ชจํธ์ฑ์ ์ ๊ฑฐํ๋ค.
์ฝ๊ฐ์ ์ถ๊ฐ์ฝ๋ฉ์ผ๋ก ๋งค์ฐ ์ฝ๊ฒ ์ ๋งค๋ชจํธ์ฑ์ ์ ๊ฑฐํ๋ค.
5.1. ํญ๋ชฉ 29. ๋ด๋ถ ๋ฐ์ดํฐ์ ๋ํ "ํธ๋ค"์ ๋ฆฌํดํ๋ ๊ฒ์ ํผํด๋ผ. ¶
๋ด๋ถ ์์์ ๋ํ ์์ /์ญ์ ๊ฐ ๊ฐ๋ฅํ๋๋ก ๋ฐํํ๋ ๊ฒ์ ์ข์ง ๋ชปํ ๋ฐฉ๋ฒ์ด๋ค.
๋ง์ฝ ์ด์ ๊ฐ์ ๊ฒฝ์ฐ
{{|
class String
{
{{|
class String
{
...
public:
}public:
operator char *() const;
private:char *data;
...
String B("Hello World");
char *str = B;
strcpy(str, "Hi Mom");
|}}
String B๋ ์์์ ๋ํ ํธ๋ค์ ๋๊ฒจ์ฃผ๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ์ ์ ์ถ์ด ๋ถ๊ฐํผํ๋ค.
char *str = B;
strcpy(str, "Hi Mom");
|}}
String B๋ ์์์ ๋ํ ํธ๋ค์ ๋๊ฒจ์ฃผ๋ฏ๋ก ๋ฉ๋ชจ๋ฆฌ์ ์ ์ถ์ด ๋ถ๊ฐํผํ๋ค.
C++ ํ์ค์ String์ ๋ฐํ๊ฐ์ constํ์ผ๋ก ๋ฐํํ๋ c_str๋ฉค๋ฒ ํจ์๋ฅผ ํตํด ์ด๋ฅผ ํผํ๊ณ ์๋ค.
{{|
class String
{
|}}
์ด์ ๊ฐ์ด ์ฌ์ฉํ๋ค๋ฉด ์ถฉ๋ถํ ์ํ์ ํผํด๊ฐ ์ ์๋ค.
{{|
class String
{
...
public:
}public:
operator const char*() const;
|}}
์ด์ ๊ฐ์ด ์ฌ์ฉํ๋ค๋ฉด ์ถฉ๋ถํ ์ํ์ ํผํด๊ฐ ์ ์๋ค.
{{|
String someFamousAuthor()
{
String someFamousAuthor()
{
return "E.H.Gombrich"; // the story of art์ ์ ์
}...
const char *pc = someFamousAuthor();
cout << pc;
|}}
์ด์ ๊ฐ์ด ๋ฐํ๊ฐ์ผ๋ก ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ ์์๊ฐ์ฒด๊ฐ ๋ฐํ๋๋ฉด์ ํฌ์ธํฐ๋ฅผ ๋๊ฒจ์ฃผ๊ณ ์ญ์ ๋๋ค.
๊ทธ๋ ๊ฒ ๋๋ฏ๋ก ์์ด๋ฒ๋ฆฐ ํธ๋ค(dangle handle)๋ง ๋จ๊ฒ ๋๋ค.
cout << pc;
|}}
์ด์ ๊ฐ์ด ๋ฐํ๊ฐ์ผ๋ก ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ ์์๊ฐ์ฒด๊ฐ ๋ฐํ๋๋ฉด์ ํฌ์ธํฐ๋ฅผ ๋๊ฒจ์ฃผ๊ณ ์ญ์ ๋๋ค.
๊ทธ๋ ๊ฒ ๋๋ฏ๋ก ์์ด๋ฒ๋ฆฐ ํธ๋ค(dangle handle)๋ง ๋จ๊ฒ ๋๋ค.
์ปดํ์ผ์ด ๋๋ค๋ ์ ์์ ์ ๋งค๋ชจํธ์ฑ๋ผ๊ณ ํ ์ ์์ผ๋ ํด๊ฒฐํ๋๋ฐ ๋น์ฉ์ด ๋ง์ด ๋ ๋ค.
(์นํ์ฐ์ฐ์์์ const char*ํํ์ ๋ฐํ๊ฐ์ ๋๊ฒจ์ค๋ ํธ๋ค์ ๋ํ ์์์ ํ๋ ๋ ๋ง๋ค์ด ๋ฐํํ๋ฉด ๊ฐ๋ฅ์ ํ๋ค.)
(์นํ์ฐ์ฐ์์์ const char*ํํ์ ๋ฐํ๊ฐ์ ๋๊ฒจ์ค๋ ํธ๋ค์ ๋ํ ์์์ ํ๋ ๋ ๋ง๋ค์ด ๋ฐํํ๋ฉด ๊ฐ๋ฅ์ ํ๋ค.)
์ฌ์ฉ๋ ์ฑ์ง์ ๋ฐ๋ผ์ ํํ;์ ํ์.
5.2. ํญ๋ชฉ 30. ์ ๊ทผํ๊ธฐ ์ด๋ ค์ด ๋ฉค๋ฒ์ ๋ํ ๋น์์ ํฌ์ธํฐ๋ ๋ ํผ๋ฐ์ค๋ฅผ ๋ฆฌํดํ๋ ๋ฉค๋ฒ ํจ์ ์ฌ์ฉ์ ํผํ๋ผ. ¶
๊ทผ๋ณธ์ ์ธ C++ ํด๋์ค์ ์กด์ฌ์ ์ด์ ์ด๋ค.
ํด๋์ค์ ๋ฉค๋ฒ๋ ์ด๋ฏธ ์ ๊ทผ์์ ๋ป์ ๊ฐ์ง๊ณ ์๋ค.
์ด ๋, ๋ด์ฉ์ด privateํ๊ณผ ๊ฐ์ด ๋ด๋ถ์ฌ์ฉ๋ง ํ๋ฝํ ๊ฒฝ์ฐ ์ด ๋ด์ฉ์ ๋ฐํํ๋ ํ์์ด ๋์ค๋ฉด ์๋๋ค.
(Stringํ๊ณผ ๊ฐ์ด C ์ธ์ด์ ํน์ฑ๊ณผ ๋ฐ๋์ ํธํ๋๊ฒ ํด์ผํ ๊ฒฝ์ฐ ์กฐ๊ธ์ ์์ธ๋ผ๊ณ ์๊ฐํด๋ ์ข์๋ฏ ํ๋ค;;)
ํด๋์ค์ ๋ฉค๋ฒ๋ ์ด๋ฏธ ์ ๊ทผ์์ ๋ป์ ๊ฐ์ง๊ณ ์๋ค.
์ด ๋, ๋ด์ฉ์ด privateํ๊ณผ ๊ฐ์ด ๋ด๋ถ์ฌ์ฉ๋ง ํ๋ฝํ ๊ฒฝ์ฐ ์ด ๋ด์ฉ์ ๋ฐํํ๋ ํ์์ด ๋์ค๋ฉด ์๋๋ค.
(Stringํ๊ณผ ๊ฐ์ด C ์ธ์ด์ ํน์ฑ๊ณผ ๋ฐ๋์ ํธํ๋๊ฒ ํด์ผํ ๊ฒฝ์ฐ ์กฐ๊ธ์ ์์ธ๋ผ๊ณ ์๊ฐํด๋ ์ข์๋ฏ ํ๋ค;;)
5.3. ํญ๋ชฉ 31. ์ง์ญ ๊ฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋ ํจ์ ๋ด์์ new๋ฅผ ์ด์ฉํด ์ด๊ธฐํ๋ ํฌ์ธํฐ๋ฅผ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ๋ฅผ ๋ฆฌํดํ์ง ๋ง๋ผ. ¶
์ด๋ฒ ํญ๋ชฉ์ ์์์ ๋ช๋ฒ ์ธ๊ธ ๋์๋๋ฏ ํ๋ฐ
{{|
class Rational
{
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ ์ง์ญ ๊ฐ์ฒด result๋ ํจ์์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ฉด์ ์ญ์ ๋๋ค.
{{|
class Rational
{
...
public:
}public:
friend const Rational& operator*(const Rational& lhs, const Rational& rhs)
{
private:{
Rational result(lhs.n*rhs.n, lhs.d,lhs.d);
return result;
}return result;
int n,d; // ๋ถ๋ชจ์ ๋ถ์๊ฐ
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ ์ง์ญ ๊ฐ์ฒด result๋ ํจ์์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ฉด์ ์ญ์ ๋๋ค.
{{|
class Rational
{
|}}
๋ง์ฝ ์ด์ ๊ฐ์ ๊ฒฝ์ฐ ํ์์ญ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฑํ๊ณ ํจ์์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋๋ผ๋ ์ญ์ ๊ฐ ๋์ง ์์ง๋ง
์ค๋ณต๋ operator *์ ์ฌ์ฉ์ ๋ฉ๋ชจ๋ฆฌ ๋์ถ์ด ๋ถ๊ฐํผํ๋ค.
class Rational
{
...
public:
}public:
friend const Rational& operator*(const Rational& lhs, const Rational& rhs)
{
private:{
Rational *result = new Rational(lhs.n*rhs.n, lhs.d,lhs.d);
return *result;
}return *result;
int n,d; // ๋ถ๋ชจ์ ๋ถ์๊ฐ
|}}
๋ง์ฝ ์ด์ ๊ฐ์ ๊ฒฝ์ฐ ํ์์ญ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ฑํ๊ณ ํจ์์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋๋ผ๋ ์ญ์ ๊ฐ ๋์ง ์์ง๋ง
์ค๋ณต๋ operator *์ ์ฌ์ฉ์ ๋ฉ๋ชจ๋ฆฌ ๋์ถ์ด ๋ถ๊ฐํผํ๋ค.
์ด ๋ฌธ์ ์์๋ ๋ ํผ๋ฐ์ค๊ฐ ์๋ ๊ฐ์ผ๋ก ๋ฐํํจ์ผ๋ก ํด๊ฒฐํ ์ ์์ผ๋ ๋๋ฌด ํฐ ๋น์ฉ์ด ๋ ๋ค.
- ๋ ๋์ ๋ฐฉ๋ฒ์ ์์๋ ๋ถ์ ์ถ๊ฐํด์ฃผ์ธ์;;
5.4. ํญ๋ชฉ 32. ๋ณ์ ์ ์๋ ๊ฐ๋ฅํ ๋ค๋ก ๋ฆ์ถฐ๋ผ. ¶
C ์ธ์ด๋ฅผ ์ฌ์ฉํ ๋๋ ํจ์์ ์ฒซ๋จธ๋ฆฌ์ ๋ณ์๋ฅผ ์ ์ํ๊ณ ์์ํ์๋ค.
์๋ง ์ด๊ธฐ์ C ์ธ์ด์์ ๋ณ์์ ์ ์๊ฐ ์ฒซ๋จธ๋ฆฌ์ ์์ด์ผ ํจ๋ ์์ํ ๊ณ ๋ณ์๋ฅผ ์ฝ๊ฒ ์๋ณํ๊ธฐ ์ํด์๋ ์ฌ์ฉ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ด๋ฒ ๋ด์ฉ์ ์ ๋ชฉ๋๋ก ๋ณ์์ ์ ์๋ฅผ ๊ฐ๋ฅํ ๋ฆ์ถฐ์ ์ฌ์ฉ๋์ง ์์ ๊ฒฝ์ฐ ๋ถํ์ํ ์์ ์ ์์ ๊ธฐ ์ํจ์ด๋ค.
์๋ง ์ด๊ธฐ์ C ์ธ์ด์์ ๋ณ์์ ์ ์๊ฐ ์ฒซ๋จธ๋ฆฌ์ ์์ด์ผ ํจ๋ ์์ํ ๊ณ ๋ณ์๋ฅผ ์ฝ๊ฒ ์๋ณํ๊ธฐ ์ํด์๋ ์ฌ์ฉ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ด๋ฒ ๋ด์ฉ์ ์ ๋ชฉ๋๋ก ๋ณ์์ ์ ์๋ฅผ ๊ฐ๋ฅํ ๋ฆ์ถฐ์ ์ฌ์ฉ๋์ง ์์ ๊ฒฝ์ฐ ๋ถํ์ํ ์์ ์ ์์ ๊ธฐ ์ํจ์ด๋ค.
{{|
string encryptedPassword(const string &password)
{
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ ์์ธ๋ก ๋์ด๊ฐ๊ฒ ๋ ๊ฒฝ์ฐ string encrypted; ์ฝ๋๋ ์ธ๋ชจ๊ฐ ์๋ค.
string encryptedPassword(const string &password)
{
string encrypted;
if(password.length() < MINIMUM_PASS_LENGTH)
encrypt(encrypted);
return encrypted;
}if(password.length() < MINIMUM_PASS_LENGTH)
throw logic_error("password is too short");
encrypted = password;encrypt(encrypted);
return encrypted;
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ ์์ธ๋ก ๋์ด๊ฐ๊ฒ ๋ ๊ฒฝ์ฐ string encrypted; ์ฝ๋๋ ์ธ๋ชจ๊ฐ ์๋ค.
{{|
string encryptedPassword(const string &password)
{
|}}
์ด๋ ๊ฒ ๊ณ ์นจ์ด ํ๋ช ํ๋ค.
string encryptedPassword(const string &password)
{
if(password.length() < MINIMUM_PASS_LENGTH)
string encrypted(password);
encrypt(encrypted);
return encrypted;
}throw logic_error("password is too short");
string encrypted(password);
encrypt(encrypted);
return encrypted;
|}}
์ด๋ ๊ฒ ๊ณ ์นจ์ด ํ๋ช ํ๋ค.
- ์์ฆ ์ปดํ์ผ๋ฌ๋ ๋์ถฉ ์ด์ ๋๋ ์์์ ํด์ฃผ์ง ์๋์?;;
5.5. ํญ๋ชฉ 33. ์ธ๋ผ์ธ์ ์ ๋ณ์ ์ผ๋ก ์ฌ์ฉํ๋ผ. ¶
์ธ๋ผ์ธ์ ๋งคํฌ๋ก๋ณด๋ค ๋ฐ์ด๋๊ณ ์คํ์๋๋ฅผ ์ฆ๊ฐ ์ํฌ์๋ ์์ผ๋ ๋์ ๋ฐ๋ผ ์ถ๊ฐ์ ์ธ ์ฉ๋์ ์์ฑ ์ํฌ์๋ ์๋ค.
{{|
// "example.h" file
inline void f() { ... }
{{|
// "example.h" file
inline void f() { ... }
// "source1.cpp" file
#include "example.h"
#include "example.h"
// "source2.cpp" file
#include "example.h"
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ ์ธ๋ผ์ธํจ์ f๋ฅผ source1.cpp์ source2.cpp์์ ๊ฐ๊ฐ ์์ฑ์ํฌ์๋ ์๋ค.
์ด๊ฒ ๋ง๊ณ ๋ ์ธ๋ผ์ธ ํจ์์ ํจ์ํฌ์ธํฐ๋ฅผ ์ทจํ ๋ ์ปดํ์ผ๋ฌ์ ๋ฐ๋ผ ํ์ผ๋ง๋ค ์ ์ ๋ณต์ฌ๋ณธ์ ์์ฑ์ํฌ์๋ ์๋ค.
์ด๋ ๊ฒ ์ถ๊ฐ์ ์ธ ์ฉ๋์ด ๋์ด๋๋ ๊ฒฝ์ฐ ์ธ์๋ ์บ์์ ์ ์ค๋ฅ ์ ๊ฐ์์์ผ ์คํ๋ ค ์ฑ๋ฅ์ด ๊ฐ์ํ ์๋ ์๋ค.
#include "example.h"
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ ์ธ๋ผ์ธํจ์ f๋ฅผ source1.cpp์ source2.cpp์์ ๊ฐ๊ฐ ์์ฑ์ํฌ์๋ ์๋ค.
์ด๊ฒ ๋ง๊ณ ๋ ์ธ๋ผ์ธ ํจ์์ ํจ์ํฌ์ธํฐ๋ฅผ ์ทจํ ๋ ์ปดํ์ผ๋ฌ์ ๋ฐ๋ผ ํ์ผ๋ง๋ค ์ ์ ๋ณต์ฌ๋ณธ์ ์์ฑ์ํฌ์๋ ์๋ค.
์ด๋ ๊ฒ ์ถ๊ฐ์ ์ธ ์ฉ๋์ด ๋์ด๋๋ ๊ฒฝ์ฐ ์ธ์๋ ์บ์์ ์ ์ค๋ฅ ์ ๊ฐ์์์ผ ์คํ๋ ค ์ฑ๋ฅ์ด ๊ฐ์ํ ์๋ ์๋ค.
80-20 ํ๋ ํ ์ ๋ถ์์ ๋ฐ๋ผ ์ค์ํ ์ฝ๋๋ ์ฝ 20%๊ฐ ์ฐจ์งํ๋ค๋ ๊ฒ์ ์๊ฐํ๊ณ ์ค์ํ ๋ถ๋ถ์๋ง ์ธ๋ผ์ธ ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ์.
- ์์ฑ์์ ์๋ฉธ์๋ ์ธ๋ผ์ธ์ผ๋ก ์ฌ์ฉํด์๋ ์๋๋ค. ์ด๋ ์ปดํ์ผ๋ฌ๊ตฌํ์๊ฐ ๋์ ๋ฐ๋ผ ์์ฑ์์ ์๋ฉธ์์ ๋ณด์ด์ง์๋ ์ฝ๋๋ถ๋ถ์ ํฌํจํ ์๋ ์๊ธฐ ๋๋ฌธ์ด๋ค.
5.6. ํญ๋ชฉ 34. ํ์ผ๊ฐ์ ์ปดํ์ผ ์์กด์ฑ(dependency)์ ์ต์ํํ๋ผ. ¶
ํ์ผ ํ๋ถ๋ถ์ ์์ ํ๊ณ ๋ค์ ์ปดํ์ผ์ ์๋ ํ์๋ ๋ชจ๋ ํ์ผ์ ๋ค์ ์ปดํ์ผํ๊ณ ๋งํฌํ๊ณ ์คํํ๋ ๊ฒฝํ์ ํ๋ฒ์ฏค์ ํด๋ณด์์ผ๋ฆฌ๋ผ ์๊ฐํ๋ค.
์ด์ ๊ฐ์ด ํ์ผ๊ฐ์ ์์กด์ฑ์ผ๋ก ์ธํด ๋๋ฌด ๋ง์ ์ปดํ์ผ ์๊ฐ์ ์ก์๋จน๋๊ฒ์ ์๊ฐ๋ญ๋น์ด๊ณ ์ฌ๋์ ๋ฐ๋ผ ๋งค์ฐ ์ง์ฆ๋๋ ์ผ์ด๋ค.
์ด๋ฒ ํญ๋ชฉ์ ๋ช๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ํ์ผ๊ฐ์ ์์กด์ฑ์ ์ค์ด๋ ๋ฐฉ๋ฒ์ ์ ์ํ๋ค.
์ด์ ๊ฐ์ด ํ์ผ๊ฐ์ ์์กด์ฑ์ผ๋ก ์ธํด ๋๋ฌด ๋ง์ ์ปดํ์ผ ์๊ฐ์ ์ก์๋จน๋๊ฒ์ ์๊ฐ๋ญ๋น์ด๊ณ ์ฌ๋์ ๋ฐ๋ผ ๋งค์ฐ ์ง์ฆ๋๋ ์ผ์ด๋ค.
์ด๋ฒ ํญ๋ชฉ์ ๋ช๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ํ์ผ๊ฐ์ ์์กด์ฑ์ ์ค์ด๋ ๋ฐฉ๋ฒ์ ์ ์ํ๋ค.
์ฐ์ ํด๋์ค์ ์ ๋ฐฉ ์ฐธ์กฐ๋ฅผ ์ค๋ช
ํ๋ค.
์ ๋ฐฉ ์ฐธ์กฐ๋ฅผ ํจ์ผ๋ก ํค๋๋ถ๋ถ์์๋ ์ธ๋ถ ํด๋์ค์ ๋ด์ฉ์ ์ฌ์ฉํ์ง ์์ ๋ ์ด์์ ๋ฌด์๋ฏธํ ์ปดํ์ผ์ ์ฐ๊ฒฐ๊ณ ๋ฆฌ๋ฅผ ๋์์ ์๋ค.
ํ์ง๋ง ์ํฉ์ ๋ฐ๋ผ์๋ ๋ฐ๋์ ํด๋์ค์ ๋ด์ฉ์ ์ฌ์ฉํด์ผํ๋ ๊ฒฝ์ฐ๋ ์๊ณ ๊ทธ๋ด๋๋ ์ ๋ฐฉ ์ฐธ์กฐ์ ์๋ฏธ๋ ์ฝํด์ง๋ค.
์ ๋ฐฉ ์ฐธ์กฐ๋ฅผ ํจ์ผ๋ก ํค๋๋ถ๋ถ์์๋ ์ธ๋ถ ํด๋์ค์ ๋ด์ฉ์ ์ฌ์ฉํ์ง ์์ ๋ ์ด์์ ๋ฌด์๋ฏธํ ์ปดํ์ผ์ ์ฐ๊ฒฐ๊ณ ๋ฆฌ๋ฅผ ๋์์ ์๋ค.
ํ์ง๋ง ์ํฉ์ ๋ฐ๋ผ์๋ ๋ฐ๋์ ํด๋์ค์ ๋ด์ฉ์ ์ฌ์ฉํด์ผํ๋ ๊ฒฝ์ฐ๋ ์๊ณ ๊ทธ๋ด๋๋ ์ ๋ฐฉ ์ฐธ์กฐ์ ์๋ฏธ๋ ์ฝํด์ง๋ค.
์ด๋ด๋ Handleํด๋์ค์ ํ๋กํ ์ฝ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ค.
Handleํด๋์ค๋ ์ธ๋ถ์์ ์ฌ์ฉ๋ ๋ด์ฉ์ ๋ถ๋ถ์ ๋ฐ๋ก ๋ผ์ด Handleํด๋์ค๋ก ๋ง๋ฌ์ผ๋ก ์ต์ํ์ ๋ด์ฉ์ ํค๋์ ํฌํจ์ํจ๋ค.
ํ๋กํ ์ฝ ํด๋์ค๋ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ค. ์ถ์ํ๋ ์ธํฐํ์ด์ค๋ง ๋ง๋ค์ด ํค๋์ ํฌํจ์ํค๋ ๋ฐฉ๋ฒ์ผ๋ก ํ์ผ๊ฐ์ ์์กด์ฑ์ ์ฝํ์ํจ๋ค.
Handleํด๋์ค๋ ์ธ๋ถ์์ ์ฌ์ฉ๋ ๋ด์ฉ์ ๋ถ๋ถ์ ๋ฐ๋ก ๋ผ์ด Handleํด๋์ค๋ก ๋ง๋ฌ์ผ๋ก ์ต์ํ์ ๋ด์ฉ์ ํค๋์ ํฌํจ์ํจ๋ค.
ํ๋กํ ์ฝ ํด๋์ค๋ ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ค. ์ถ์ํ๋ ์ธํฐํ์ด์ค๋ง ๋ง๋ค์ด ํค๋์ ํฌํจ์ํค๋ ๋ฐฉ๋ฒ์ผ๋ก ํ์ผ๊ฐ์ ์์กด์ฑ์ ์ฝํ์ํจ๋ค.
6.1. ํญ๋ชฉ 35. public ๊ณ์น์ด "isa"๋ฅผ ๋ชจ๋ธ๋งํ๋๋ก ํ๋ผ. ¶
{{|
class Person
{
class Student : public Person
{
|}}
์ด ๊ด๊ณ๋ public ๊ณ์น์ธ "isa"๊ด๊ณ์ด๋ค.
ํ์ง๋ง Person isa Student์ด์ง Student isa Person์ด ์๋์ ์ฃผ์ํด์ผํ๋ค.
class Person
{
...
}class Student : public Person
{
...
}|}}
์ด ๊ด๊ณ๋ public ๊ณ์น์ธ "isa"๊ด๊ณ์ด๋ค.
ํ์ง๋ง Person isa Student์ด์ง Student isa Person์ด ์๋์ ์ฃผ์ํด์ผํ๋ค.
์ปดํจํฐ๋ 0๊ณผ 1๋ก ์ด๋ฃจ์ด์ง ๊ณ ์ฒ ์ด๋ค. ์ฐ๋ฆฌ๊ฐ ์๊ฐํ๋ ๊ฒ์ ๋ฐ๋ก ํํํ์ง ๋ชปํ๋ค.
์ฐ๋ฆฌ๊ฐ ์ํ์ ํฌํจํ ๋ค๋ฅธ ๋ถ๋ถ๋ค์์ ์ตํ ์ง๊ด์ด ๋ฐ๋ก ์ ์ฉ๋์ง ๋ชปํจ์ ์ธ์ํด์ผ ํ๋ค.
์ฐ๋ฆฌ๊ฐ ์ํ์ ํฌํจํ ๋ค๋ฅธ ๋ถ๋ถ๋ค์์ ์ตํ ์ง๊ด์ด ๋ฐ๋ก ์ ์ฉ๋์ง ๋ชปํจ์ ์ธ์ํด์ผ ํ๋ค.
6.2. ํญ๋ชฉ 36. ์ธํฐํ์ด์ค ๊ณ์น๊ณผ ๊ตฌํ ๊ณ์น์ ์ฐจ์ด์ ์ ์ดํดํ๋ผ. ¶
{{|
class Shape
{
class Rectangle : public Shape { ... };
class Ellipse : public Shape { ... };
class Shape
{
...
public:
}public:
virtual void draw() const;
class Rectangle : public Shape { ... };
class Ellipse : public Shape { ... };
...
Shape *ps1 = new Rectangle;
ps1->draw();
Shape *ps2 = new Ellipse;
ps2->draw();
|}}
ํด๋์ค Shape์์๋ ๊ตฌํํ ๋ด์ฉ์ ์ค๊ณ๋ง ์๋ค.
๊ทธ๋ฆฌ๊ณ ์์๋ฐ์ ํด๋์ค๋ค์์ ๋ด์ฉ์ ๊ตฌํ์ด ์๋ค.
ps1->draw();
Shape *ps2 = new Ellipse;
ps2->draw();
|}}
ํด๋์ค Shape์์๋ ๊ตฌํํ ๋ด์ฉ์ ์ค๊ณ๋ง ์๋ค.
๊ทธ๋ฆฌ๊ณ ์์๋ฐ์ ํด๋์ค๋ค์์ ๋ด์ฉ์ ๊ตฌํ์ด ์๋ค.
๋ง์ฝ ์์๋ฐ์ ํด๋์ค์์ ๊ฐ์ํจ์์ ๊ตฌํ์ด ๋์ด ์์ง ์์ ๊ฒฝ์ฐ๊ฐ ์๋ค.
์ด๋ด๋ ๊ฐ์ํจ์๋ก ์ค์ ๋ ํจ์๋ฅผ ์คํํ๋ค๋ฉด ๋ฌธ์ ๊ฐ ๋๋ค.
{{|
class Shape
{
์ด๋ด๋ ๊ฐ์ํจ์๋ก ์ค์ ๋ ํจ์๋ฅผ ์คํํ๋ค๋ฉด ๋ฌธ์ ๊ฐ ๋๋ค.
{{|
class Shape
{
...
public:
}public:
virtual void draw const = 0;
protected:void defaultdraw() const;
class Rectangle : public Shape
{
|}}
์ด๋ ๊ฒ ๊ฐ์ํจ์๋ฅผ ์์๊ฐ์ํจ์๋ก ๋ฐ๊พธ๊ณ ๊ทธ์ ๋ฐ๋ฅธ ๊ธฐ๋ณธํ๋์ ๋ํ ์ ์๋ฅผ defaultํจ์๋ก ํ๋ ๋ง๋ค์ด ๋๋๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด๋ค.
{
...
public:
}public:
virtual void draw() const
{
{
defaultdraw();
}|}}
์ด๋ ๊ฒ ๊ฐ์ํจ์๋ฅผ ์์๊ฐ์ํจ์๋ก ๋ฐ๊พธ๊ณ ๊ทธ์ ๋ฐ๋ฅธ ๊ธฐ๋ณธํ๋์ ๋ํ ์ ์๋ฅผ defaultํจ์๋ก ํ๋ ๋ง๋ค์ด ๋๋๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด๋ค.
6.3. ํญ๋ชฉ 37. ๊ณ์น๋ ๋น๊ฐ์ ํจ์๋ฅผ ์ฌ์ ์ํ์ง ์๋๋ก ํ๋ค. ¶
๊ฐ์ํจ์์ ๋น๊ฐ์ํจ์์ ์ฌ์ฉ๋ฒ์ ๋ํ ๋ด์ฉ์ด๋ค.
์์์ด ๋๋ ํจ์์ ๋ํ์ฌ ๊ฐ์ํจ์๋ก ์ค์ ํ๋๊ฒ ์ณ๊ณ ์์์ด ๋์ง ์๊ฑฐ๋ ์์์ด ๋๋๋ผ๋ ๋ค์ ๊ตฌํ์ด ๋์ง ์๋ค๋ฉด ๋น๊ฐ์ํจ์๋ก ์ฌ์ฉ๋์ด์ผ ํ๋ค.
์์์ด ๋๋ ํจ์์ ๋ํ์ฌ ๊ฐ์ํจ์๋ก ์ค์ ํ๋๊ฒ ์ณ๊ณ ์์์ด ๋์ง ์๊ฑฐ๋ ์์์ด ๋๋๋ผ๋ ๋ค์ ๊ตฌํ์ด ๋์ง ์๋ค๋ฉด ๋น๊ฐ์ํจ์๋ก ์ฌ์ฉ๋์ด์ผ ํ๋ค.
6.4. ํญ๋ชฉ 38. ๊ณ์น๋ ๋ถ์ฌ ์ธ์๊ฐ์ ์ฌ์ ์ํ์ง ์๋๋ก ํ๋ค. ¶
class Shape
{
}
class Rectangle : public Shape
{
{
}
class Rectangle : public Shape
{
...
public:
};virtual void draw(ShapeColor = BLUE) const;
...
Shape *pr = new Rectangle;
pr->draw();
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ pr์ด ํ๋์ ์ฌ๊ฐํ์ ๊ทธ๋ฆด๊ฒ์ด๋ผ ์์์ ํ์ง๋ง ๊ทธ๋ ์ง ์๋ค.
pr์ Shapeํ์ ์ ์ ํฌ์ธํฐ๋ก ๋ํดํธ์ธ์์๋ ์ ์ ์ผ๋ก ๊ฒฐํฉํ๋ค.
๊ฒฐ๊ตญ ๋นจ๊ฐ์ ์ฌ๊ฐํ์ด ๊ทธ๋ ค์ง๋ค.
pr->draw();
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ pr์ด ํ๋์ ์ฌ๊ฐํ์ ๊ทธ๋ฆด๊ฒ์ด๋ผ ์์์ ํ์ง๋ง ๊ทธ๋ ์ง ์๋ค.
pr์ Shapeํ์ ์ ์ ํฌ์ธํฐ๋ก ๋ํดํธ์ธ์์๋ ์ ์ ์ผ๋ก ๊ฒฐํฉํ๋ค.
๊ฒฐ๊ตญ ๋นจ๊ฐ์ ์ฌ๊ฐํ์ด ๊ทธ๋ ค์ง๋ค.
์ด๋ ์ฑ๋ฅ์์ ์ด์ ์ธ๋ฐ ๋ํดํธ์ธ์์ ๋์ ์ผ๋ก ๊ฒฐํฉ์ ๋ณต์กํ๊ณ ๋๋ฆฌ๊ฒ ์๋ํ๋ค.
๋์ ์กฐ๊ธ ๋ ๋น ๋ฅด๊ฒ ์คํ์ด ๋๋ค.
๋์ ์กฐ๊ธ ๋ ๋น ๋ฅด๊ฒ ์คํ์ด ๋๋ค.
6.5. ํญ๋ชฉ 39. ๊ณ์ธต๋์ ์๋์ชฝ ํด๋์ค๋ฅผ ๋ค์ด์บ์คํธ(downcast)ํ์ง ์๋๋ก ํ๋ค. ¶
{{|
class Person { ... };
class Student : public Person { ... };
class Person { ... };
class Student : public Person { ... };
...
Student *s = new Person;
|}}
์ด๊ฒ์ ์ณ์ง ์๋ค. ๊ผญ 100์์ง๋ฆฌ ๋์ ๋ง ๋ค์ด๊ฐ ์ ์๋ ์ ๊ธํต์ 500์์ง๋ฆฌ ๋์ ์ ์ฐ๊ฒจ ๋ฃ๋๊ฒ๊ณผ ๊ฐ๋ค.
๊ทธ๋ฌ๋ฏ๋ก s๋ฅผ ํตํด Student๋ง์ ํจ์๋ฅผ ํธ์ถ์ ์์ ์๋ ๊ฒฐ๊ณผ๋ฅผ ๋ํ๋ผ ๊ฒ์ด๋ค.
|}}
์ด๊ฒ์ ์ณ์ง ์๋ค. ๊ผญ 100์์ง๋ฆฌ ๋์ ๋ง ๋ค์ด๊ฐ ์ ์๋ ์ ๊ธํต์ 500์์ง๋ฆฌ ๋์ ์ ์ฐ๊ฒจ ๋ฃ๋๊ฒ๊ณผ ๊ฐ๋ค.
๊ทธ๋ฌ๋ฏ๋ก s๋ฅผ ํตํด Student๋ง์ ํจ์๋ฅผ ํธ์ถ์ ์์ ์๋ ๊ฒฐ๊ณผ๋ฅผ ๋ํ๋ผ ๊ฒ์ด๋ค.
๋๋๋ก์ด๋ฉด ์ด๋ฐ ๊ฒฝ์ฐ๋ ๊ฐ์ํจ์์ ํด๋์ค์ ๊ณ์ธต๊ตฌ์กฐ๋ฅผ ํตํ ์ธํฐํ์ด์ค์ ํ์ฉ์ผ๋ก ํด๊ฒฐํ๋ค.
ํ์ง๋ง ์ด๋ ๊ฒ ํ๋ฆฌ์ง ์์ ๊ฒฝ์ฐ dynamic_cast์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ๋ฏธ๋ฆฌ ํ์ ์ ์ฒดํฌํํ ์คํ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๋๋ก ํ์.
ํ์ง๋ง ์ด๋ ๊ฒ ํ๋ฆฌ์ง ์์ ๊ฒฝ์ฐ dynamic_cast์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ๋ฏธ๋ฆฌ ํ์ ์ ์ฒดํฌํํ ์คํ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๋๋ก ํ์.
6.6. ํญ๋ชฉ 40. ๋ ์ด์ด๋ง(layering)์ ํตํด "๊ฐ์ง๊ณ ์๋" ๊ฒ๊ณผ "์ฌ์ฉํ์ฌ ๊ตฌํ๋" ๊ฒ์ ๋ชจ๋ธ๋งํ๋๋ก ํ์. ¶
Composition์ผ๋ก๋ ๋ถ๋ฆฌ๋ "has-a" ๊ด๊ณ์ ์ด์ผ๊ธฐ ์ด๋ค.
๋ง์ฝ STL์ ํฌํจ๋ set์ด์ธ์ ์์ ๋ง์ Set์ ๊ตฌํํ๊ณ ์ ํ๋ ์์ ๊ฐ ์๋ค.
{{|
template<class T> class Set: public list<T> { ... };
|}}
์ด๊ฒ์ ์ณ๋ค๊ณ ๋ณด์ด๋ ๊ทธ๋ ์ง ์๋ค.
์๋ํ๋ฉด Derived๊ฐ Base์ด๋ฉด (isa), Base๊ฐ ์ฐธ์ผ๋ ํญ์ Derived๋ ์ฐธ์ด ๋๋ค.
Set์ ์ค๋ณต๋ ๋ด์ฉ์ ๋ํด์ ํ๋ฒ๋ง ์ ๋ ฅ์ ๋ฐ๋ ์๋ฃํ์ด๋ค. ํ์ง๋ง ์ด๋ ๊ฒ "isa" ๊ด๊ณ๋ก ๋ํ๋ผ๋ ์ณ์ง ๋ชปํ๊ฒ ๋๋ค.
{{|
template<class T> class Set: public list<T> { ... };
|}}
์ด๊ฒ์ ์ณ๋ค๊ณ ๋ณด์ด๋ ๊ทธ๋ ์ง ์๋ค.
์๋ํ๋ฉด Derived๊ฐ Base์ด๋ฉด (isa), Base๊ฐ ์ฐธ์ผ๋ ํญ์ Derived๋ ์ฐธ์ด ๋๋ค.
Set์ ์ค๋ณต๋ ๋ด์ฉ์ ๋ํด์ ํ๋ฒ๋ง ์ ๋ ฅ์ ๋ฐ๋ ์๋ฃํ์ด๋ค. ํ์ง๋ง ์ด๋ ๊ฒ "isa" ๊ด๊ณ๋ก ๋ํ๋ผ๋ ์ณ์ง ๋ชปํ๊ฒ ๋๋ค.
{{|
template<class T> class Set
{
template<class T> class Set
{
...
public:
}public:
void insert(const T &ํญ๋ชฉ);
private: list<T> rep;
...
template<class T> void Set<T>::insert(const T& ํญ๋ชฉ);
{
|}}
์ด๋ ๊ฒ ๊ตฌํํ๋ค๋ฉด ํด๊ฒฐ์ด ๋๋ค.
{
// ์ค๋ณต๋ ๋ด์ฉ์ด ์๋์ง ๊ฒ์ฌํ ์ถ๊ฐ
} |}}
์ด๋ ๊ฒ ๊ตฌํํ๋ค๋ฉด ํด๊ฒฐ์ด ๋๋ค.
"isa" ๊ด๊ณ์ "has-a"๊ด๊ณ์ค ์ด๋๊ฒ์ธ์ง ์๊ฐํ๊ณ ๊ตฌํํ์.
6.7. ํญ๋ชฉ 41. ๊ณ์น๊ณผ ํ ํ๋ฆฟ๊ณผ์ ์ฐจ์ด์ ์ ์ดํดํ๋ค. ¶
ํ
ํ๋ฆฟ์ ๊ฐ์ฒด์ ํ์
์ด ํด๋์ค์ ์ ์๋ ํจ์๋ค์ ๋์ ์๋ฆฌ์ ์ํฅ์ ๋ฏธ์น์ง ์๋ ๊ฒฝ์ฐ์, ํด๋์ค์ ๋ชจ์์ ์์ฑํ๋ ๋ฐ ์ฌ์ฉ๋์ด์ผ ํ๋ค.
๊ณ์น์ ๊ฐ์ฒด์ ํ์ ์ด ํด๋์ค์ ์ ์๋ ํจ์๋ค์ ๋์ ์๋ฆฌ์ ์ํฅ์ ๋ฏธ์น๋ ๊ฒฝ์ฐ์, ํด๋์ค์ ๋ชจ์์ ์ํด ์ฌ์ฉ๋์ด์ผ ํ๋ค.
๊ณ์น์ ๊ฐ์ฒด์ ํ์ ์ด ํด๋์ค์ ์ ์๋ ํจ์๋ค์ ๋์ ์๋ฆฌ์ ์ํฅ์ ๋ฏธ์น๋ ๊ฒฝ์ฐ์, ํด๋์ค์ ๋ชจ์์ ์ํด ์ฌ์ฉ๋์ด์ผ ํ๋ค.
๋ง์ฝ ์คํ์ ํ
ํ๋ฆฟ์ด ์๋ ๊ณ์น์ ํตํด ๊ตฌํํ๊ณ ์ ํ๋ค๋ฉด ์ด๋ป๊ฒ ํ ๊ฒ์ธ๊ฐ๋ฅผ ์๊ฐํด ๋ณด๊ณ
์๋ฌผ->๋๋ฌผ->์ธ๊ฐ->ํ์๋ฑ์ ํ์์ ํ ํ๋ฆฟ์ผ๋ก ๊ตฌํํ๊ณ ์ ํ๋ค๊ณ ์๊ฐํด๋ณด์.
์๋ฌผ->๋๋ฌผ->์ธ๊ฐ->ํ์๋ฑ์ ํ์์ ํ ํ๋ฆฟ์ผ๋ก ๊ตฌํํ๊ณ ์ ํ๋ค๊ณ ์๊ฐํด๋ณด์.
ํ
ํ๋ฆฟ์ด ์๋ ๊ณ์น์ ํตํ ์คํ์ ๊ตฌํ์ด๋ผ๋ฉด voidํ ํฌ์ธํฐ๋ฑ์ ํตํด ์ฌ๋ฌ ์๋ฃํ์ ๋์ ์ผ๋ก ์
๋ ฅ๋ฐ๋๋ก ๋
ธ๋ ฅํ ๊ฒ์ด๋ฉฐ
๊ณ์ธต๊ตฌ์กฐ๋ฅผ ํ ํ๋ฆฟ์ผ๋ก ๋ฌถ๊ณ ์ ํ๋ค๋ฉด ํ ํ๋ฆฟํ์ ๋ฐ๋ผ if๋ฌธ์ ๋๋ฆฌ๋๋ฑ C, PASCAL์ ํ์์ ๋ฐ๋ฅผ์ง๋ ๋ชจ๋ฅธ๋ค.
๊ณ์ธต๊ตฌ์กฐ๋ฅผ ํ ํ๋ฆฟ์ผ๋ก ๋ฌถ๊ณ ์ ํ๋ค๋ฉด ํ ํ๋ฆฟํ์ ๋ฐ๋ผ if๋ฌธ์ ๋๋ฆฌ๋๋ฑ C, PASCAL์ ํ์์ ๋ฐ๋ฅผ์ง๋ ๋ชจ๋ฅธ๋ค.
6.8. ํญ๋ชฉ 42. private ๊ณ์น์ ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ผ. ¶
private ๊ณ์น์ layering๊ณผ ๋งค์ฐ ์ ์ฌํ๋ค. public ๊ณ์น๊ณผ๋ ๋ค๋ฅด๊ฒ Derived isa Base์ด์ง๋ ์๋ค.
๋จ์ง layering๊ณผ ์ฐจ์ด์ ์ Baseํด๋์ค์์ protected๊ณผ private์ ์ฌ์ฉ์ ๋ฌด์ ์ฐจ์ด์ด๋ค.
๋ง์ฝ ๋ง๋ค๊ณ ์ ํ๋ ํด๋์ค๊ฐ ๋ค๋ฅธ ํด๋์ค์ protected๋ private๋ฉค๋ฒ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค๋ฉด layering๋ง์ผ๋ก๋ ์ฒ๋ฆฌํ ์๊ฐ ์๋ค.
์ด๋ด๋ private ๊ณ์น์ ์ฌ์ฉํด์ผํ๋ค.
๋จ์ง layering๊ณผ ์ฐจ์ด์ ์ Baseํด๋์ค์์ protected๊ณผ private์ ์ฌ์ฉ์ ๋ฌด์ ์ฐจ์ด์ด๋ค.
๋ง์ฝ ๋ง๋ค๊ณ ์ ํ๋ ํด๋์ค๊ฐ ๋ค๋ฅธ ํด๋์ค์ protected๋ private๋ฉค๋ฒ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค๋ฉด layering๋ง์ผ๋ก๋ ์ฒ๋ฆฌํ ์๊ฐ ์๋ค.
์ด๋ด๋ private ๊ณ์น์ ์ฌ์ฉํด์ผํ๋ค.
{{|
class GenericStack
{
|}}
์ด๋ ๊ฒ ๊ฐ์ฒด๊ฐ ์๋ ํฌ์ธํฐ์ ๋ํ ์คํ์ด ์๋ค๊ณ ํ ๋. ์ด ํด๋์ค๋ง์ผ๋ก๋ ํ์ ์ด ์์ ํ์ง ๋ชปํ๋ค.
class GenericStack
{
...
public:
}public:
void push(const void *Object);
void *pop();
void *pop();
|}}
์ด๋ ๊ฒ ๊ฐ์ฒด๊ฐ ์๋ ํฌ์ธํฐ์ ๋ํ ์คํ์ด ์๋ค๊ณ ํ ๋. ์ด ํด๋์ค๋ง์ผ๋ก๋ ํ์ ์ด ์์ ํ์ง ๋ชปํ๋ค.
{{|
class GenericStack
{
class GenericStack
{
protected:
}... // ์์ฑ์, ์๋ฉธ์ ๋ฐ ์๋ต๋ ๋ด์ฉ
void push(const void *Object);
void *pop();
void push(const void *Object);
void *pop();
...
GenericStack gs; // ์๋ฌ : ์์ฑ์๊ฐ protected์ด๋ค.
IntStack is; // Int ํฌ์ธํฐํ์ ๋ํ ์์ ํ ์คํ์ด๋ค.
|}}
ํ์ ์์ ํ๊ณ GenericStack๋ง์ผ๋ก๋ ์์ฑํ ์ ์๋๋ก ๋ง์๋์๋ค.
IntStack is; // Int ํฌ์ธํฐํ์ ๋ํ ์์ ํ ์คํ์ด๋ค.
|}}
ํ์ ์์ ํ๊ณ GenericStack๋ง์ผ๋ก๋ ์์ฑํ ์ ์๋๋ก ๋ง์๋์๋ค.
๋๋ถ๋ถ์ ๊ฒฝ์ฐ layering์ด ์ฐ๊ณ ์ด์ ๊ฐ์ด ํน๋ณํ ๊ฒฝ์ฐ๋ง private ๊ณ์น์ ์ฐ๋๋ก ํ์.
6.9. ํญ๋ชฉ 43. ๋ค์ค ๊ณ์น์ ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋๋ก ํ๋ผ. ¶
๋ค์ค ๊ณ์น์ ์ ๋งค๋ชจํธํ ๋ถ๋ถ์ด ๋ง๋ค.
{{|
class A { ... };
class B : public A { ... };
class C : public A { ... };
class D : public B, public C { ... };
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ ๋งค์ฐ ์ค๋ณต์ ์ด๊ณ ๋งค์ฐ ์ํํ ์ฝ๋์ด๋ค.
ํด๋์ค A๋ถ๋ถ์ ์๋ ๊ฐ์ํจ์๋ฅผ B์ C์์ ๊ตฌํํ์๋ค๋ฉด ํด๋์ค D์์ ํธ์ถ๋๋ ๊ฐ์ํจ์๋ ๋ฌด์์ ๋ปํ๋์ง ์์ ์๋ค.
์ด๊ฒ์ ์ต์ ์ ์ค๊ณ๋ก ์ด๋ฐ ๋ฐฉ๋ฒ์ ํผํด์ผ ํ๋ค.
class A { ... };
class B : public A { ... };
class C : public A { ... };
class D : public B, public C { ... };
|}}
์ด์ ๊ฐ์ ๊ฒฝ์ฐ ๋งค์ฐ ์ค๋ณต์ ์ด๊ณ ๋งค์ฐ ์ํํ ์ฝ๋์ด๋ค.
ํด๋์ค A๋ถ๋ถ์ ์๋ ๊ฐ์ํจ์๋ฅผ B์ C์์ ๊ตฌํํ์๋ค๋ฉด ํด๋์ค D์์ ํธ์ถ๋๋ ๊ฐ์ํจ์๋ ๋ฌด์์ ๋ปํ๋์ง ์์ ์๋ค.
์ด๊ฒ์ ์ต์ ์ ์ค๊ณ๋ก ์ด๋ฐ ๋ฐฉ๋ฒ์ ํผํด์ผ ํ๋ค.
์ต๋ํ ์์ ๊ฐ์ ๋ค์ด์๋ชฌ๋ํ ์์์ ํผํ์.
์๋ฐ์์๋ ์์๋ฐ์ ํด๋์ค๋ ํ๋๋ง ๋ฐ์์ ์๊ณ ์ธํฐํ์ด์ค๋ ์ฌ๋ฌ๊ฐ์ง๋ฅผ ๋ฐ์ ์ ์๋ค.
์๋ฐ์์๋ ์์๋ฐ์ ํด๋์ค๋ ํ๋๋ง ๋ฐ์์ ์๊ณ ์ธํฐํ์ด์ค๋ ์ฌ๋ฌ๊ฐ์ง๋ฅผ ๋ฐ์ ์ ์๋ค.
6.10. ํญ๋ชฉ 44. ์๋ฏธํ๋ ๋ฐ๋ฅผ ํํํ๋๋ก ํ๋ผ. ์์ ์ด ํํํ ๊ฒ์ ์๋ฏธ๋ฅผ ์ดํดํ๋๋ก ํ๋ผ. ¶
์์ ๋ด์ฉ์ ์์ฝํ ๋ด์ฉ์ด๋ค.
7.1. ํญ๋ชฉ 45. C++๊ฐ ์๋ฐํ๊ฒ ์ด๋ค ํจ์๋ฅผ ๋ง๋ค์ด์ฃผ๊ณ ํธ์ถํ๋์ง ์ดํดํ๊ธฐ ¶
{{|
class Empty { };
|}}
๋ง์ฝ ์ด๋ ๊ฒ ํด๋์ค๋ฅผ ์์ฑํ๋ค๋ฉด
class Empty { };
|}}
๋ง์ฝ ์ด๋ ๊ฒ ํด๋์ค๋ฅผ ์์ฑํ๋ค๋ฉด
{{|
class Empty
{
|}}
์ด๋ ๊ฒ ๋ง๋ค์ด์ค๋ค.
class Empty
{
public:
Empty* operator();
const Empty* operator&() const;
}Empty();
Empty(const Empty& rhs);
~Empty();
Empty& operator=(const Empty& rhs);Empty(const Empty& rhs);
~Empty();
Empty* operator();
const Empty* operator&() const;
|}}
์ด๋ ๊ฒ ๋ง๋ค์ด์ค๋ค.
7.2. ํญ๋ชฉ 46. ์คํ ์๊ฐ ์๋ฌ๋ณด๋ค๋ ์ปดํ์ผ ์๊ฐ๊ณผ ๋งํฌ ์๊ฐ ์๋ฌ๊ฐ ์ข๋ค. ¶
C++์ ์ปดํ์ผ๋๋ ์ธ์ด๋ก ์คํ์๊ฐ์๋ ์๋ฌ๋ฅผ ํ์งํ์ง ์๋๋ค.
๊ทธ ๋์ ๋น ๋ฅธ ์ํ์๊ฐ์ ์ด์ต์ด ์๊ณ ์คํ ์๊ฐ์ ์๋ฌ๋ฅผ ์๋ฐฉํ๊ธฐ ์ํด์ ์ปดํ์ผ ์๊ฐ๊ณผ ๋งํฌ ์๊ฐ์ ์ํ์ ์ ๊ฑฐํ๋๋ก ํด์ผ ๋๋ค.
๊ทธ ๋์ ๋น ๋ฅธ ์ํ์๊ฐ์ ์ด์ต์ด ์๊ณ ์คํ ์๊ฐ์ ์๋ฌ๋ฅผ ์๋ฐฉํ๊ธฐ ์ํด์ ์ปดํ์ผ ์๊ฐ๊ณผ ๋งํฌ ์๊ฐ์ ์ํ์ ์ ๊ฑฐํ๋๋ก ํด์ผ ๋๋ค.
๋ ์ง๋ฅผ ๋ํ๋ด๊ธฐ ์ํ ํด๋์ค ์ด๋ค.
{{|
class Date
{
|}}
์ฌ๊ธฐ์ Month์ ๊ฐ์ ์ ํจ์ฑ ์ฒดํฌ๋ฅผ ์ํด์ ๊ณ ์ณ๋ณด์.
{{|
class Date
{
{{|
class Date
{
...
public:
}public:
Date(int day, int month, int year);
|}}
์ฌ๊ธฐ์ Month์ ๊ฐ์ ์ ํจ์ฑ ์ฒดํฌ๋ฅผ ์ํด์ ๊ณ ์ณ๋ณด์.
{{|
class Date
{
...
public:
}public:
Date(int day, const Month& month, int year);
class Month
{
{
public:
};static const Month Jan() { return 1; };
static const Month Feb() { return 2; };
...
static const Month Dec() { return 12; };
private:static const Month Feb() { return 2; };
...
static const Month Dec() { return 12; };
Month(int number) : monthNumber(number) { }
Month(const Month& rhs);
const int monthNumber;
Month(const Month& rhs);
const int monthNumber;
...
Date d(30,Month::Sep(),2003);
|}}
์ด์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก Month๋ ์คํ์๊ฐ์ ๊ฒ์ฌ๋ฅผ ํด์ผ ํ ๋ด์ฉ์ ์ปดํ์ผ ์๊ฐ์ผ๋ก ์ฎ๊ธธ์ ์๋ค.
|}}
์ด์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก Month๋ ์คํ์๊ฐ์ ๊ฒ์ฌ๋ฅผ ํด์ผ ํ ๋ด์ฉ์ ์ปดํ์ผ ์๊ฐ์ผ๋ก ์ฎ๊ธธ์ ์๋ค.
7.3. ํญ๋ชฉ 47. ๋น์ง์ญ ์ ์ (Non-local static) ๊ฐ์ฒด๋ ์ฌ์ฉ๋๊ธฐ ์ ์ ์ด๊ธฐํ๋๋๋ก ํด์ผ ํ๋ค. ¶
๋ง์ฝ ํ์ผ์์คํ
์ด ์ด๊ธฐํ๋ํ ๋๋ ํ ๋ฆฌ ์์คํ
์ ๋ถ๋ถ์ผ๋ก ์ด๊ธฐํ ๋์ด์ผ ํ๋ค๋ฉด
๋ฐ๋์ ๊ทธ๋ ๊ฒ ํ๋๋ก ํด์ผํ๋ค.
๋ฐ๋์ ๊ทธ๋ ๊ฒ ํ๋๋ก ํด์ผํ๋ค.
๊ทธ๋ฌ๋ ๋น์ง์ญ ๊ฐ์ฒด๋ก ์ ์ธ์ด ๋์ด ์๋ค๋ฉด ์ด๊ธฐํ ์์๋ฅผ ์ ํ๊ธฐ๊ฐ ๋งค์ฐ ํ๋ค ๊ฒ์ด๋ค.
(๋น์ง์ญ ๊ฐ์ฒด๋ ์ ์ญ์ด๋ ๋ค์์คํ์ด์ค ์์ญ์ด๊ฑฐ๋ ํด๋์ค๋ด static, ํ์ผ ์์ญ์ static์ ์ ์๋ ๊ฒฝ์ฐ์ด๋ค.)
(๋น์ง์ญ ๊ฐ์ฒด๋ ์ ์ญ์ด๋ ๋ค์์คํ์ด์ค ์์ญ์ด๊ฑฐ๋ ํด๋์ค๋ด static, ํ์ผ ์์ญ์ static์ ์ ์๋ ๊ฒฝ์ฐ์ด๋ค.)
...
class Directory
{
|}}
์ด๋ ๊ฒ ํจ์ผ๋ก ๋ฐ๋์ Directoryํด๋์ค๊ฐ ์ด๊ธฐํ ๋๊ธฐ์ ์ FileSystem์ ์ด๊ธฐํ ์ํฌ์ ์๋ค.
{
...
public:
}public:
Directory()
{
{
// theFileSystem ํจ์๋ฅผ ํธ์ถํ์ฌ ๋๋ ํ ๋ฆฌ ๋ถ๋ถ์ ์ด๊ธฐํ ์ํจ๋ค.
}|}}
์ด๋ ๊ฒ ํจ์ผ๋ก ๋ฐ๋์ Directoryํด๋์ค๊ฐ ์ด๊ธฐํ ๋๊ธฐ์ ์ FileSystem์ ์ด๊ธฐํ ์ํฌ์ ์๋ค.
7.4. ํญ๋ชฉ 48. ์ปดํ์ผ๋ฌ์ ๊ฒฝ๊ณ (Warning)์ ์ฃผ์๋ฅผ ๊ธฐ์ธ์ฌ๋ผ. ¶
C++ ์ธ์ด๋ ์ ์ฐํ๋ค.
{{|
class B
{
{{|
class B
{
public:
}virtual void f() const;
class D
{
|}}
์ด์ ๊ฐ์ด ์ฌ์ ์๋ฅผ ํ์์ ๋, Error๊ฐ ์๋ Warning์ ๋ง๋ค์ด ๋ผ์๋ ์๋ค.
{
public:
}virtual void f();
|}}
์ด์ ๊ฐ์ด ์ฌ์ ์๋ฅผ ํ์์ ๋, Error๊ฐ ์๋ Warning์ ๋ง๋ค์ด ๋ผ์๋ ์๋ค.
Error๋ฟ๋ง ์๋๋ผ Warning์๋ ์ฃผ์๋ฅผ ๊ธฐ์ธ์ด์. ์ ์ฌ์ ์ธ ๋ฌธ์ ์์๊ฐ ๋ ์๋ ์๋ค.
7.5. ํญ๋ชฉ 49. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ ์์๋์. ¶
ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ ์ฉํ๋ค!
8. Thread ¶
๊ทธ๋ฅ ๋ณด๋ฉด ์ ์ ์ ๋์ด ๊ฐ๋๋ฐ.. ์ฐ๋ ค๋ ๋ง๋งํ๊ตฌ๋.. guts__
Effective C++ ๋ด์ฉ์ ๋ณด๋ฉด์ ์ด๋ฏธ ํญ๋ชฉ 21 ๊น์ง๋ ์ ๋ฆฌ๊ฐ ๋์ด ์๋๊ตฐ์.
๊ทธ๋์ ๊ทธ ์ดํ ๋ด์ฉ์ ์ ๋ฆฌํด ์ฌ๋ฆฌ๊ณ ์ถ์ต๋๋ค. -- ๋ค๋ฅธํ๊ต์ปดํจํฐ๊ณตํ๋ถ
๊ทธ๋์ ๊ทธ ์ดํ ๋ด์ฉ์ ์ ๋ฆฌํด ์ฌ๋ฆฌ๊ณ ์ถ์ต๋๋ค. -- ๋ค๋ฅธํ๊ต์ปดํจํฐ๊ณตํ๋ถ
์ด๊ณณ์๋ ํน๋ณํ ํ๋ฝ์ ํ๊ฑฐ๋, ํ๋ฝ์ ๋ฐ์๋งํ ์ฌ๋์ด ์์ต๋๋ค. ์ธ์ ๋ ํ์์
๋๋ค
--sun
์ํ์คํ์ด ์ฝ์ผ๋ผ๊ณ ์ถ์ฒํด ์ค ์ฑ
.. ์ ์ํค์ ๋ฉ์ง๊ฒ๋ ์ ๋ฆฌ๊ฐ ๋์ด์๊ตฐ์. ์ ๋น
๋ฑ
์ ๋๊ฐ์ง ๋ชปํ๋ ํผ์์๋ผ๋ ์ด์ฌํ ํด์ผ๊ฒ ์ต๋๋ค. - ๊ถ์๊ธฐ.png)