U E D R , A S I H C RSS

More EffectiveC++/Miscellany

1. Item 32: Program in the Future tense

  • Item 32: 미래λ₯Ό λŒ€λΉ„ν•˜λŠ” ν”„λ‘œκ·Έλž¨
(μž‘μ„±μžμ£Ό:제λͺ©μ€ 직역보닀, 전체 λ‚΄μš©μœΌλ‘œ κ²°μ •ν–ˆλ‹€.)

사물은 λ³€ν™”ν•œλ‹€.

μ†Œν”„νŠΈ 웨어 개발자라면, 우린 μ•„λ§ˆ λ§Žμ€κ²ƒμ„ μ•Œ ν•„μš”λŠ” μ—†λ‹€. ν•˜μ§€λ§Œ λ³€ν•˜λŠ” 것은 인지해야 ν•œλ‹€. μš°λ¦¬λŠ” 무엇이 변할건가, μ–΄λ–»κ²Œ 변할건가, μ–Έμ œ λ³€ν™”κ°€ μΌμ–΄λ‚˜λŠ”κ°€, μ™œ κ±°κΈ°μ—μ„œ λ³€ν™”κ°€ μΌμ–΄λ‚˜λŠ”κ°€ μ΄λŸ°κ²ƒ λ”°μœ„λŠ” μ•Œν•„μš”κ°€ μ—†λ‹€. κ·Έλ ‡μ§€λ§Œ 우린 μ•Œμ•„μ•Ό ν•œλ‹€. λ³€ν™”ν•œλ‹€. λΌλŠ” 점 말이닀. (μž‘μ„±μžμ£Ό:개인적인 의견으둜 μ˜μ—­ν•œ 단락, ν˜Ήμ‹œλ‚˜ κ΄€μ‹¬μžˆμœΌλ©΄ μ˜κ²¬μ€ λ‚΄μ£Όμ„Έμš”.)

원문:As software developers, we may not know much, but we do know that things will change. We don't necessarily know what will change, how the changes will be brought about, when the changes will occur, or why they will take place, but we do know this: things will change.

쒋은 μ†Œν”„νŠΈμ›¨μ–΄λŠ” λ³€ν™”λ₯Ό 잘 μˆ˜μš©ν•œλ‹€. μƒˆλ‘œμš΄ κΈ°λŠ₯을 μˆ˜μš©ν•˜κ³ , μƒˆλ‘œμš΄ ν”Œλž«νΌμ— 잘 적용되고, μƒˆλ‘œμš΄ μš”κ΅¬λ₯Ό 잘 λ°›μ•„ 듀이며, μƒˆλ‘œμš΄ μž…λ ₯을 잘 μž‘λŠ”λ‹€. 이런 μ†Œν”„νŠΈμ›¨μ–΄λŠ” μœ μ—°ν•˜κ³ , κ°•ν•˜κ³ , μ‹ λ’°μ„±μžˆκ³ , 돌발 상황(사고)에 μ˜ν•΄ μ£½μ§€ μ•ŠλŠ”λ‹€. 이런 μ†Œν”„νŠΈμ›¨μ–΄λŠ” λ―Έλž˜μ— ν•„μš”ν•œ μš”μ†Œλ₯Ό μ˜ˆμƒν•˜κ³ , μ˜€λŠ˜λ‚  κ΅¬ν˜„μ‹œμ— ν¬ν•¨μ‹œν‚€λŠ” ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ— μ˜ν•΄μ„œ λ””μžμΈλœλ‹€. μ΄λŸ¬ν•œ μ’…λ₯˜μ˜ μ†Œν”„νŠΈμ›¨μ–΄λŠ”-μš°μ•„ν•˜κ²Œ λ³€ν™”ν•˜λŠ” μ†Œν”„νŠΈμ›¨μ–΄- program in the future tens(맀래의 ν”„λ‘œκ·Έλž¨:μ΄ν•˜ 영문 직접 μ‚¬μš©)을 κ°μ•ˆν•˜λŠ” μ‚¬λžŒλ“€μ΄ μž‘μ„±ν•œλ‹€.

program in future tenseλŠ”, λ³€ν™”μ˜ μˆ˜μš©ν•˜κ³ , μ€λΉ„ν•œλ‹€. λΌμ΄λΈŒλŸ¬μ— 좔가될 μƒˆλ‘œμš΄ ν•¨μˆ˜, μ•žμœΌλ‘œ 일어날 μƒˆλ‘œμš΄ μ˜€λ²„λ‘œλ”©(overloading)을 μ•Œκ³ , 잠재적으둜 λͺ¨ν˜Έμ„±μ„ κ°€μ§„ ν•¨μˆ˜λ“€μ˜ κ²°κ³Όλ₯Ό μ˜ˆμΈ‘ν•œλ‹€. μƒˆλ‘œμš΄ ν΄λž˜μŠ€κ°€ 상속 계측에 좔가될 것을 μ•Œκ³ , μ΄λŸ¬ν•œ κ°€λŠ₯성에 λŒ€ν•˜μ—¬ μ€λΉ„ν•œλ‹€. μƒˆλ‘œμš΄ μ–΄ν”Œλ¦¬μΌ€μ΄μ…˜μ—μ„œ μ½”λ“œκ°€ 쓰이고, κ·Έλž˜μ„œ μƒˆλ‘œμš΄ λͺ©μ μœΌλ‘œ ν•¨μˆ˜κ°€ 호좜되고, 그런 ν•¨μˆ˜λ“€μ΄ μ •ν™•νžˆ λ™μž‘μ„ μœ μ§€ν•œλ‹€. ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ΄ μœ μ§€ 보수λ₯Ό ν• λ•Œ, 일반적으둜 μ›λž˜μ˜ 개발자의 μ˜μ—­μ΄ μ•„λ‹Œ, μœ μ§€ 보수의 λͺ«μ„ μ•ˆλ‹€. 그러λ€λ‘œ, λ‹€λ₯Έ μ‚¬λžŒμ— μ˜ν•΄μ„œ μ†Œν”„νŠΈμ›¨μ–΄λŠ” 이해, μˆ˜μ •, λ°œμ „μ˜ κ΄€μ μ—μ„œ κ΅¬ν˜„ν•˜κ³  λ””μžμΈλœλ‹€.

이런 쒋은 μ†Œν”„νŠΈμ›¨μ–΄λ₯Ό λ§Œλ“€κΈ° μœ„ν•œ λ°©λ²•μœΌλ‘œ, μ£Όμ„μ΄λ‚˜, 기타 λ‹€λ₯Έ λ¬Έμ„œ λŒ€μ‹ μ— C++ 내뢀에 λ””μžμΈμœΌλ‘œ ꡬ속해 λ²„λ¦¬λŠ” 것이닀. 예λ₯Όλ“€μžλ©΄ λ§Œμ•½ ν΄λž˜μŠ€κ°€ κ²°μ½” λ‹€λ₯Έ 클래슀둜 μœ λ„λ˜μ§€λ₯Ό μ›μΉ˜ μ•Šμ„λ•Œ, λ‹¨μ‹œ 주석을 헀더 νŒŒμΌμ— λ„£λŠ” 것이 μ•„λ‹ˆλΌ, μœ λ„λ₯Ό λ°©μ§€ν•˜κΈ° μœ„ν•˜μ—¬ C++의 문법을 μ΄μš©ν•œ 기술둜 ꡬ속 μ‹œν‚¨λ‹€.;이에 λŒ€ν•œ 방법은 Item 26에 μ–ΈκΈ‰λ˜μ—ˆλ‹€. λ§Œμ•½ ν΄λž˜μŠ€κ°€ λͺ¨λ“  μΈμŠ€ν„΄μŠ€λ₯Ό Heapμ˜μ—­μ— μƒμ„±μ‹œν‚€κ³ μž ν• λ•Œ, ν΄λΌμ΄μ–ΈνŠΈμ—κ²Œ 말(λ¬Έμ„œ)둜 μ „λ‹¬ν•˜λŠ” 것이 μ•„λ‹ˆλΌ. Item 27κ³Ό 같은 μ ‘κ·ΌμœΌλ‘œ μ œν•œ μ‹œμΌœ 버릴 수 μžˆλ‹€. λ§Œμ•½ ν΄λž˜μŠ€μ— λŒ€ν•˜μ—¬ 볡사와 할당을 막을렀고 ν• λ•ŒλŠ”, 볡사 μƒμ„±μžμ™€ ν• λ‹Ή(assignment) μ—°μ‚°μžλ₯Ό 사역(private)으둜 λ§Œλ“€μ–΄ 버렀라. C++은 ν›Œλ₯­ν•œ 힘과, μœ μ—°μ„±, ν‘œν˜„μ„±μ„ μ œκ³΅ν•œλ‹€. μ΄λŸ¬ν•œ μ–Έμ–΄μ˜ νŠΉμ§•λ“€μ„ λ‹Ήμ‹ μ˜ ν”„λ‘œκ·Έλž˜λ°μ—μ„œ λ””μžμΈμ˜ 정책을 μœ„ν•΄μ„œ μ‚¬μš©ν•˜λΌ.


DeleteMe λͺ¨ν˜Έ

"λ³€ν™”ν•œλ‹€.", ν—˜λ‚œν•œ μ†Œν”„νŠΈμ›¨μ–΄μ˜ λ°œμ „μ— 잘 κ²¬λ””λŠ” 클래슀λ₯Ό μž‘μ„±ν•˜λΌ. (원문:Given that things will change, writeclasses that can withstand the rough-and-tumble world of software evolution.) "demand-paged"의 가상 ν•¨μˆ˜λ₯Ό ν”Όν•˜λΌ. λ‹€λ₯Έ 이가 λ§Œλ“€μ–΄ 놓지 μ•ŠμœΌλ©΄, λ„ˆλ„ λ§Œλ“€ 방법이 μ—†λŠ” 그런 경우λ₯Ό ν”Όν•˜λΌ.(λͺ¨ν˜Έ, 원문:Avoid "demand-paged" virtual functions, whereby you make no functions virtual unless somebody comes along and demands that you do it) λŒ€μ‹ μ— ν•¨μˆ˜μ˜ meaning을 κ²°μ •ν•˜κ³ , μœ λ„λœ ν΄λž˜μŠ€μ—μ„œ μƒˆλ‘­κ²Œ μ •μ˜ν•  것인지 νŒλ‹¨ν•˜λΌ. κ·Έλ ‡κ²Œ 되면, 가상(virtual)으둜 선언해라, μ–΄λ–€ 이라도 μž¬μ •μ˜ λͺ»ν• μ§€λΌλ„ 말이닀. κ·Έλ ‡μ§€ μ•Šλ‹€λ©΄, 비가상(nonvirtual)으둜 선언해라, 그리고 차후에 그것을 바꾸어라 μ™œλƒν•˜λ©΄ 그것은 λ‹€λ₯Έμ‚¬λžŒμ„ νŽΈν•˜κ²Œ ν•˜κΈ° λ•Œλ¬Έμ΄λ‹€.;전체 클래슀의 λͺ©μ μ—μ„œ λ³€ν™”λ₯Ό μœ μ§€ν•˜λŠ”μ§€ 확신을 해라.

λͺ¨λ“  ν΄λž˜μŠ€μ—μ„œ ν• λ‹Ή(assignment), 볡사λ₯Ό μž‘μ•„λΌ. "비둝 아무것도 ν•˜μ§€ μ•ŠλŠ” 것"이라도 말이닀. μ™œλƒν•˜λ©΄ 그것듀이 μ§€κΈˆ ν• μˆ˜ μ—†λŠ”κ±΄ λ―Έλž˜μ—λ„ ν• μˆ˜ μ—†λ‹€λŠ” μ˜λ―Έμ΄λ‹€. λ§Œμ•½ μ΄λŸ¬ν•œ ν•¨μˆ˜λ“€μ΄ κ΅¬ν˜„ν•˜κΈ°μ— μ–΄λ ΅κ²Œ ν•œλ‹€λ©΄, 그것을 private둜 μ„ μ–Έν•˜λΌ. λ―Έλž˜μ—λ„ λ™μž‘μ‹œν‚€κ²Œ ν•˜μ§€ μ•Šλ‹€λŠ” μ˜λ―Έλ‹€. μ»΄νŒŒμ–ΌλŸ¬κ°€ λ§Œλ“€μ–΄λ‚΄λŠ” ν•¨μˆ˜μ— λŒ€ν•œ λͺ¨ν˜Έν•œ ν˜ΈμΆœμ„ 할리가 μ—†λ‹€. (κΈ°λ³Έ ν• λ‹Ή μƒμ„±μžλ‚˜ κΈ°λ³Έ 볡사 μƒμ„±μžκ°€ μ’…μ’… λ°œμƒλ˜λŠ” κ²ƒμ²˜λŸΌ)

원리λ₯Ό κ΅¬ν˜„ν•˜κΈ° μœ„ν•΄ νŠΉμ΄ν•˜κ²Œ ν•˜μ§€ 마라.:μ—°μ‚°μžμ™€ ν•¨μˆ˜λ₯Ό μžμ—°μŠ€λŸ½κ³  λͺ…μ‹œμ μΈ λ¬Έλ²•μœΌλ‘œ μ œκ³΅ν•˜λΌ. built-in(κΈ°λ³Έ 자료) ν˜•μœΌλ‘œ κ΅¬ν˜„ν•˜λΌ:μ˜μ‹¬λ λ•ŒλŠ” int둜 ν•˜λΌ

어떀이가 무언가λ₯Ό ν• μˆ˜μžˆλ‹€λŠ”κ²ƒ μ•Œκ²Œλ˜λ©΄ 그듀을 그것을 할것이닀. 그듀은 μ˜ˆμ™Έλ₯Ό 던질 것이닀. 그듀은 κ·Έλ“€ μŠ€μŠ€λ‘œμ—κ²Œ 객체λ₯Ό ν• λ‹Ήν•  것이닀. 그듀은 값을 μ œκ³΅ν•˜κΈ°μ „μ— 객체λ₯Ό μ‚¬μš©ν•  것이닀. 그듀은 객체λ₯Ό μ œκ³΅ν•˜κ² μ§€λ§Œ, κ²°μ½” μ‚¬μš©ν•˜μ§€ μ•ŠλŠ”λ‹€. 그듀은 μ»λ‹€λž€ 값을 μ œκ³΅ν•  것이닀. 그듀은 μ•„μ£Ό μž‘μ€ 값을 μ œκ³΅ν•  것이닀. 그듀은 null 값을 μ œκ³΅ν•  것이닀. 일반적으둜 λ§Œμ•½ 컴파일이 되면 어떀이가 그것을 할것이닀. 결과적으둜 λ‹Ήμ‹ μ˜ 클래슀λ₯Ό μ •ν™•νžˆ μ‚¬μš©ν•˜λŠ”κ±΄ μ‰½κ²Œ, μ΄μƒν•˜κ²Œ μ‚¬μš©ν•˜λŠ”κ±΄ μ–΄λ ΅κ²Œ λ§Œλ“€μ–΄λΌ. ν΄λΌμ΄μ–ΈνŠΈκ°€ μ‹€μˆ˜λ₯Ό ν•˜λ„λ‘ 해라 그리고 λ‹Ήμ‹ μ˜ ν΄λž˜μŠ€λ“€μ΄ κ·ΈλŸ¬ν•œ μ—λŸ¬λ“€μ„ λ°©μ§€ν•˜κ³ , μ°Ύκ³ , μˆ˜μ •ν• μˆ˜ 있게 λ§Œλ“€μ–΄λΌ. (예λ₯Όλ“€μ–΄ Item 33 μ°Έκ³ )

이식성 μžˆλŠ” μ½”λ“œλ₯Ό λ§Œλ“€μ–΄λΌ. 이식성 μžˆλŠ” ν”„λ‘œκ·Έλž¨μ˜ μ œμž‘μ€ κ·Έλ ‡μ§€ μ•Šμ€ κ²½μš°λ³΄λ‹€ 맀우 μ–΄λ €μš΄κ²Œ μ•„λ‹ˆλ‹€. 그리고 λˆˆμ— 보일 만큼 μ„±λŠ₯λ©΄μ—μ„œ 이식성 μ—†λŠ” μ½”λ“œλ₯Ό κ³ μ§‘ν•΄μ•Ό ν•˜λŠ” κ²½μš°λŠ” ν¬κ·€ν•˜λ‹€.(Item 16μ°Έκ³ ) νŠΉμ •ν•œ ν•˜λ“œμ›¨μ–΄λ₯Ό μœ„ν•œ ν”„λ‘œκ·Έλž¨μ˜ λ””μžμΈμ—μ„œλ„, μ–Όλ§ˆ μ•ˆμžˆμ–΄ ν•˜λ“œμ›¨μ–΄ μ„±λŠ₯이 λ™μΌν•œ 수μ€μ˜ μ„±λŠ₯을 κ°€μ Έλ‹€ μ£Όλ€λ‘œ, 이식성 μžˆλ„λ‘ λ§Œλ“€μ–΄λΌ. 이식성 μžˆλŠ” μ½”λ“œμ˜ μž‘μ„±μ€ ν”Œλž«νΌ κ°„μ˜ λ³€ν™˜μ— 쉽고, λ‹Ήμ‹ μ˜ ν΄λΌλΌμ΄μ–ΈνŠΈ κΈ°λ°˜μ„ 곡고히 ν•˜κ³ , μ˜€ν”ˆ μ‹œμŠ€ν…œμ˜ 지원에 κ΄€ν•˜μ—¬ μ’‹λ‹€. λ§Œμ•½, ν•œ OSμ—μ„œ μ„±λŠ₯이 μ‹€νŒ¨ν•΄λ„, μ‰½κ²Œ λ³΅κ΅¬ν• μˆ˜ μžˆλ‹€.

λ‹Ήμ‹ μ˜ μ½”λ“œλ₯Ό λ³€ν™”κ°€ ν•„μš”ν• λ•Œ, κ·Έ 효과λ₯Ό μ§€μ—­ν™”(μ§€μ—­ν™”:localized) μ‹œν‚€λ„λ‘ λ””μžμΈ 해라. κ°€λŠ₯ν•œν•œ μΊ‘μŠν™” ν•˜μ—¬λΌ:ꡬ체적인 κ΅¬ν˜„μ€ private ν•˜λΌ. κ΄‘λ²”μœ„ν•˜κ²Œ μ μš©ν•΄μ•Ό 할곳이 μžˆλ‹€λ©΄ μ΄λ¦„μ—†λŠ”(unamed) namespaceλ‚˜, file-static객체 λ‚˜ ν•¨μˆ˜(Item 31μ°Έκ³ )λ₯Ό μ‚¬μš©ν•˜λΌ. 가상 기초 ν΄λž˜μŠ€κ°€ μ£Όλ„ν•˜λŠ” λ””μžμΈμ€ ν”Όν•˜λΌ. μ™œλƒν•˜λ©΄ κ·ΈλŸ¬ν•œ ν΄λž˜μŠ€λŠ” κ·Έλ“€λ‘œ λΆ€ν„° μœ λ„λœ λͺ¨λ“  ν΄λž˜μŠ€κ°€ μ΄ˆκΈ°ν™” ν•΄μ•Όλ§Œ ν•œλ‹€. - 그듀이 μ§μ ‘μ μœΌλ‘œ μœ λ„λ˜μ§€ μ•Šμ€ κ²½μš°λ„(Item 4μ°Έκ³ ) if-than-else을 κ°œλ‹¨μ‹μœΌλ‘œ μ‚¬μš©ν•œ RTTI 기반의 λ””μžμΈμ„ ν”Όν•˜λΌ.(Item 31μ°Έκ³ ) 항상 클래슀의 계측은 λ³€ν™”ν•œλ‹€. 각 μ½”λ“œλ“€μ€ μ—…λ°μ΄νŠΈ λ˜μ–΄μ•Όλ§Œ ν•œλ‹€. 그리고 λ§Œμ•½ ν•˜λ‚˜λ₯Ό 읽어 버린닀면, λ‹Ήμ‹ μ˜ 컴파일러둜 λΆ€ν„° μ•„λ¬΄λŸ° warningλ₯Ό λ°›μ„μˆ˜ 없을 것이닀.

이와 같은 λ‚΄μš©λ“€μ„ 아무리 λ°˜λ³΅ν•΄μ„œ λ§ν•˜κ³€ ν•˜μ§€λ§Œ, λŒ€λΆ€λΆ„μ˜ ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ€ ν˜„μž¬μ˜ μ‹œλ₯˜λ₯Ό κ·ΈλŒ€λ‘œ κ³ μ§‘ν•œλ‹€. ν›Œλ₯­ν•œ μ•ˆλͺ©μ˜ C++ μ „λ¬Έκ°€κ°€ λ§ν•˜λŠ” 좩고에 κ΄€ν•΄μ„œ 생각해라.

  • 당신은 B*κ°€ 가리킀고 μžˆλŠ” Dλ₯Ό μ œκ±°ν• λ•Œ 가상 파괴자λ₯Ό ν•„μš”λ‘œ ν•œλ‹€.

μ—¬κΈ°μ—μ„œ BλŠ” D의 기초 ν΄λž˜μŠ€μ΄λ‹€. λ‹€λ₯Έ 말둜 ν•˜μžλ©΄ 이 μž‘μ„±μžλŠ” λ§Œμ•½ λ‹€μŒκ³Ό 같은 κ²½μš°μ— BλŠ” 가상 파괴자(virtual destroctor)κ°€ ν•„μš” μ—†μ–΄ 보인닀.

~cpp 
class B { ... };	// 가상 νŒŒκ΄΄μžκ°€ μ—†λ‹€.
class D: public B { ... } 
    B *pb = new D;

κ·Έλ ‡μ§€λ§Œ λ‹€μŒκ³Ό 같은 ꡬ문이 더해지면, 생각이 바뀔것이닀.


~cpp 
delete pb;	// 자, 당신은 Bμ—μ„œ 가상 μƒμ„±μžκ°€ ν•„μš”ν•˜λ‹€. μ•ˆκ·ΈλŸ°κ°€?

κ·Έ μ˜λ―ΈλŠ” ν΄λΌμ΄μ–ΈνŠΈ μ½”λ“œμ— λŒ€ν•˜μ—¬ μ•½κ°„μ˜ λ³€ν™”κ°€ -deleteλ¬Έ-결과적으둜 클래슀 B의 μ •μ˜κΉŒμ§€ λ³€ν™”ν•΄μ•Ό ν•˜λŠ” ν•„μš”μ„±μ„ 보여μ€λ‹€. κ·ΈλŸ°ν•œ 상황이 λ°œμƒν•˜λ©΄, B의 ν΄λΌμ΄μ–ΈνŠΈλ“€μ€ λͺ¨λ‘ 재 컴파일 ν•΄μ•Ό ν•œλ‹€. μ•„κΉŒ, 이 ν•„μžμ˜ μΆ©κ³ λ₯Ό λ”°λ΄λ©΄, ν™•μž₯ μ½”λ“œμ— λŒ€ν•œ ν΄λΌμ΄μ–ΈνŠΈμ˜ λΌμ΄λΈŒλŸ¬λ¦¬λ„ 재 컴파일, 재 μ—°κ²°ν•΄μ•Ό ν•œλ‹€. μ΄λŠ” μ†Œν”„νŠΈμ›¨μ–΄ λ””μžμΈμ— 효과λ₯Ό λ―Έν‹΄λ‹€.

DeleteMe μ „μ²΄μ μœΌλ‘œ λͺ¨ν˜Έκ°€ μ•„λ‹ˆλ‹€, 뒀에 λ‚΄μš©μ„ 봐야 μ•žμ— λ‚΄μš©μ΄ 이해가 감.

같은 주제둜, 또 λ‹€λ₯Έ ν•„μžμ˜ 글을 보자.

  • λ§Œμ•½ public base classκ°€ 가상 파괴자λ₯Ό κ°€μ§€κ³  μžˆμ§€ μ•Šλ‹€λ©΄, μœ λ„λœ ν΄λž˜μŠ€λ‚˜, μœ λ„λœ 클래슀의 멀버듀이 파괴자λ₯Ό κ°€μ§€κ³  μžˆμ§€ μ•Šλ‹€.

λ‹€λ₯Έ 말둜 ν•˜λ©΄ μ΄λŸ°κ±°λ‹€.


~cpp 
class String {
public:
    ~string();
};
class B { ... }
κ·Έλ ‡μ§€λ§Œ μƒˆλ‘œμš΄ ν΄λž˜μŠ€κ°€ Bλ‘œλΆ€ν„° μœ λ„λ˜λ©΄ λ°”λ€Œμ–΄μ•Ό ν•œλ‹€.


~cpp 
class D: public B{
    string name;
};

λ‹€μ‹œ, B에 μž‘μ€ λ³€ν™”λŠ” μ•„λ§ˆ ν΄λΌμ΄μ–ΈνŠΈμ˜ 뢀가적인 재 컴파일과 재링크λ₯Ό μš”κ΅¬ν•œλ‹€. κ·Έλ ‡μ§€λ§Œ μ†Œν”„νŠΈμ›¨μ–΄μ˜ μž‘μ€ λ³€ν™”λŠ” μ‹œμŠ€ν…œμ— μž‘μ€ 좩격을 쀄것이닀. μ΄λŸ¬ν•œ λ””μžμΈμ€ ν…ŒμŠ€νŠΈλ‘œ μ‹€νŒ¨μ΄λ‹€.

같은 ν•„μžλŠ” μ΄λ ‡κ²Œ μ“΄λ‹€.

  • λ§Œμ•½ 닀쀑 상속 μƒνƒœμ—μ„œ μ–΄λ– ν•œ νŒŒκ΄΄μžκ°€ μžˆλ‹€λ©΄, λͺ¨λ“  κΈ°λ³Έ ν΄λž˜μŠ€κ°€ μ•„λ§ˆ 가상 파괴자(virtual destructor)κ°€ λ˜μ–΄μ•Ό 할것이닀.
μ΄λ ‡κ²Œ λ°˜λ³΅μ—μ„œ λ§ν•˜λŠ”κ±° 같이 ν˜„μž¬μ˜ μ‹œλ₯˜λ₯Ό μƒκ°ν•˜λŠ”κ±Έ μ£Όμ‹œν•˜λΌ. ν΄λΌμ΄μ–ΈνŠΈκ°€ μ§€κΈˆ λŠ˜μ–΄λ‚˜κ³  μžˆλŠ” μ˜κ²¬λ“€μ— λŒ€ν•˜μ—¬ μ–΄λ–»κ²Œ ν•΄μ•Ό ν•˜λŠ”κ°€? μ–΄λ–€ 클래슀 멀버가 μ§€κΈˆ 파괴자λ₯Ό κ°€μ§€κ³  μžˆλŠ”κ°€? 계측상에 μ–΄λ–€ ν΄λž˜ν¬κ°€ μ§€κΈˆ 파괴자λ₯Ό κ°€μ§€λŠ”κ°€?

미래의 μ‹œλ₯˜λ‘œ μƒκ°ν•˜λŠ” 관점은 μ™„μ „νžˆ λ‹€λ΄λ‹€. μ§€κΈˆ μ–΄λ–»κ²Œ 클래슀λ₯Ό μ‚¬μš©ν•˜λŠλƒλ₯Ό λ¬»λŠ”κ²ƒ λŒ€μ‹ μ—, μ–΄λ–»κ²Œ 클래슀λ₯Ό λ””μžμΈ ν•˜λŠλƒλ₯Ό λ¬»λŠ”λ‹€. 미래 μ§€ν–₯적 μƒκ°μœΌλ‘œλŠ” μ΄λ ‡κ²Œ λ§ν•œλ‹€. λ§Œμ•½ 기초 클래슀둜 μ‚¬μš©λœ ν΄λž˜μŠ€κ°€ λ””μžμΈ λœλ‹€λ©΄ κ·Έ ν΄λž˜μŠ€λŠ” 가상 파괴자λ₯Ό κ°€μ Έμ•Ό ν•œλ‹€. κ·ΈλŸ¬ν•œ ν΄λž˜μŠ€λŠ” μ§€κΈˆκ³Ό 미래 λͺ¨λ‘ μ •ν™•νžˆ λ™μž‘ν•΄μ•Ό ν•œλ‹€. 그리고 κ·Έλ“€μ˜€ λΆ€ν„° ν΄λž˜μŠ€λ“€μ΄ νŒŒμƒλ λ•Œ λ‹€λ₯Έ 라이브러리의 ν΄λž˜μŠ€μ—κ²Œ 영ν–₯을 λΌμ³μ„œλŠ” μ•ˆλœλ‹€. ( μ΅œμ†Œν•œ, 파괴자둜 μΈν•œ λ…Όλž€ 만큼, 영ν–₯이 μ—†μ–΄μ•Ό ν•œλ‹€. 좔가적인 λ³€ν™”κ°€ ν΄λž˜μŠ€μ— ν•„μš”ν•˜λ©΄ λ‹€λ₯Έ ν΄λΌμ΄μ–ΈνŠΈλ“€μ˜€ μ•„λ§ˆ 영ν–₯을 받을 것이닀.)

μƒμ—…μš© 클래슀 라이브러리(C++ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬ μƒμ˜ string μŠ€νŽ™μ˜ λ‚ μ§œλ₯Ό μ•žλ‹ΉκΈ°λ €λŠ” νšŒμ‚¬)λŠ” 가상 파괴자λ₯Ό κ°€μ§€κ³  μžˆμ§€ μ•Šμ€ sting클래슀λ₯Ό ν¬ν•¨ν•œλ‹€. κ·Έ λ²€λ”μ˜ μ„€λͺ…은?

  • μš°λ¦¬λŠ” 가상 파괴자λ₯Ό λ§Œλ“€μ§€ μ•ŠλŠ”λ‹€. μ™œλƒν•˜λ©΄, Stringκ°€ vtbl을 κ°€μ§€κΈ°λ₯Ό μ›ν•˜μ§€ μ•ŠκΈ° λ•Œλ¬Έμ΄λ‹€. μš°λ¦¬λŠ” String*λ₯Ό κ°€μ§€κ²Œν•  μ˜λ„λŠ” μ—†λ‹€. κ·Έλž˜μ„œ μ΄λŠ” λ¬Έμ œκ°€ λ˜μ§€ μ•ŠλŠ”λ‹€. μš°λ¦¬λŠ” 이것이 μˆ˜λ°˜ν•˜λŠ” 어렀움에 λŒ€ν•˜μ—¬ μƒκ°ν•˜μ§€ μ•ŠλŠ”λ‹€.
이것이 ν˜„μž¬λ‚˜ 미래의 μ‹œλ₯˜λ₯Ό μƒκ°ν•˜λŠ” 것인가?

ν™•μ‹€νžˆ vtbl λ¬Έμ œλŠ” 합법적인 접근이닀. (Item 24μ°Έκ³ ) λŒ€λ‹€μˆ˜ String클래슀의 κ΅¬ν˜„μ—μ„œ 였직 ν•˜λ‚˜μ˜ char*λ₯Ό 각각의 String 객체가 κ°€μ§€κ³  μžˆλ‹€. κ·Έλž˜μ„œ 각 String객체에 μΆ”κ°€λ˜λŠ” vptr도 λ‘λ°°μ˜ 양을 μ°¨μ§€ν•œλ‹€. ν—ˆμš©ν•˜μ§€ μ•ŠμœΌλ €λŠ” μ΄μœ λŠ” μ΄ν•΄ν•˜κΈ° 쉽닀. String같은 클래슀λ₯Ό 무겁게 μ‚¬μš©ν•˜λ©΄ λˆˆμ— λ λŠ” μ„±λŠ₯ μ €ν•˜κ°€ μžˆλ‹€. μ•žμ„œ μ–ΈκΈ‰ν•œ 경우 ν΄λž˜μŠ€λ‹Ή μ„±λŠ₯ μ €ν•˜λŠ” μ•½ 20%정도λ₯Ό κ°€μ§€κ³  μ˜¨λ‹€. (Item 16μ°Έκ³ )

λ¬Έμžμ—΄ 객체에 λŒ€ν•œ λ©”λͺ¨λ¦¬μ˜ 할당은-문자의 값을 κ°€μ§€κ³  있기 μœ„ν•΄ ν•„μš”λ‘œν•˜λŠ” heapλ©”λͺ¨λ¦¬κΉŒμ§€ κ°μ•ˆν•΄μ„œ-일반적으둜 char*이 μ°¨μ§€ν•˜λŠ” 양에 λΉ„ν•˜μ—¬ 훨씬 크닀. μ΄λŸ¬ν•œ κ΄€μ μ—μ„œ, vtpr에 μ˜ν•œ μ˜€λ²„ν—€λ“œ(overhead)λŠ” λ―Έλ―Έν•˜λ‹€. κ·ΈλŸΌμ—λ„ λΆˆκ΅¬ν•˜κ³ , 그것은 ν• λ§Œν•œ(합법적인,μ˜¬λ°”λ₯Έ) 고민이닀. (ν™•μ‹€νžˆ ISO/ANSI ν¬μ€ λ‹¨μ²΄μ—μ„œλŠ” κ·ΈλŸ¬ν•œ κ΄€μ μœΌλ‘œ μƒκ°ν•œλ‹€. κ·Έλž˜μ„œ ν‘œμ€ strnig ν˜•μ€ λΉ„ 가상 파괴자(nonvirtual destructor) 이닀.)

μ–΄λ–€ 것이 더 λ§Žμ€ 문제λ₯Ό μΌμœΌν‚€λŠ” κ²ƒμœΌλ‘œ, λ°΄λ”λ“€μ˜ μ£Όλͺ©μ„ λ°›κ³  μžˆμ„κΉŒ? "μš°λ¦¬λŠ” String*을 μ‚¬μš©ν•˜λŠ” λͺ©μ μ„ κ°€μ§€μ§€ μ•ŠλŠ”λ‹€. κ·Έλž˜μ„œ μ΄λŠ” 별 λ¬Έμ œκ°€ λ˜μ§€ μ•ŠλŠ”λ‹€." 그건 μ•„λ§ˆ 사싀일 것이닀. ν•˜μ§€λ§Œ κ·Έλ“€μ˜ Stringν΄λž˜μŠ€λŠ” μˆ˜λ§Žμ€ κ°œλ°œμžλ“€μ΄ μ‚¬μš©κ°€λŠ₯ν•œ 것이닀. μˆ˜λ§Žμ€ κ°œλ°œμžλ“€μ΄ C++의 수μ€μ΄ μ œκ°κ°μ΄λ‹€. μ΄λŸ¬ν•œ κ°œλ°œμžλ“€μ΄ Stringμƒμ—μ„œμ˜ 비가상 파괴자(no virtual destructor)λ₯Ό μ΄ν•΄ν• κΉŒ? 그듀이 비가상 파괴자λ₯Ό κ°€μ§„ Stringλ•Œλ¬Έμ— String으둜 μœ λ„λœ μƒˆλ‘œμš΄ ν΄λž˜μŠ€κ°€ λͺ¨ν—˜ λΉ„μŠ·ν•œ 것을 μ•Œκ³  μžˆμ„κΉŒ? 이런 벀더듀은 κ·Έλ“€μ˜ ν΄λΌμ΄μ–ΈνŠΈλ“€μ΄ 가상 νŒŒκ΄΄μžκ°€ μ—†λŠ” μƒνƒœμ—μ„œ String*λ₯Ό ν†΅ν•˜μ—¬ μ‚­μ œκ°€ μ˜¬λ°”λ΄κ²Œ μž‘λ™ν•˜μ§€ μ•Šκ³ , RTTI와 String에 λŒ€ν•œ μ°Έμ‘°κ°€ μ•„λ§ˆ λΆ€μ •ν™•ν•œ 정보λ₯Ό λ°˜ν™˜ν•œλ‹€λŠ”κ±Έ ν™•μ‹ μ‹œν‚¬κΉŒ? 이 ν΄λž˜μŠ€κ°€ μ •ν™•νžˆ μ“°κΈ° μ‰¬μš΄ 클래슀일까? λΆ€μ •ν™•ν•˜κ²Œ μ“°κΈ° μ–΄λ €μš΄ 클래슀일까?

이 λ²€λ”λŠ” λ¬Όλ‘  Stringν΄λž˜μŠ€μ— κ΄€ν•œ μœ λ„ν•΄μ„œλŠ” μ•ˆλ˜λ„λ‘ λ””μžμΈ 된 λ¬Έμ„œλ“€μ„ μ œκ³΅ν•  것이닀. ν•˜μ§€λ§Œ, ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ΄ λ¬Έμ„œλ₯Ό λ³΄λŠ” 도쀑에 κ·Έ 뢀뢄을 놓쳀닀면 μ–΄λ–»κ²Œ ν•˜κ² λŠ”κ°€?

λŒ€μ•ˆμœΌλ‘œ C++을 μ‚¬μš©ν• λ•Œ μœ λ„λ₯Ό μ œν•œν•΄ λ²„λ¦¬λŠ” 것이닀. Item 26μ—μ„œ μ–΄λ–»κ²Œ 객체λ₯Ό heap에 λ§Œλ“€κ±°κ³  auto_ptr객체둜 heap객체λ₯Ό μ‘°μ •ν•˜λŠ” 방법에 κ΄€ν•΄μ„œ μ–ΈκΈ‰ν•˜μ˜€λ‹€. String을 μœ„ν•œ μΈν„°νŽ˜μ΄μŠ€ 생성은 μ•„λ§ˆ λ…νŠΉν•˜κ³  λΆˆνŽΈν•œ λ‹€μŒκ³Ό 같은 문법 을 μš”κ΅¬ν•œλ‹€.


~cpp 
auto_ptr<String> ps(String::makeString("Future tense C++"));
...	// 이제 ν•΄λ‹Ή κ°μ²΄λŠ” ν¬μΈν„°μ²˜λŸΌ 닀룬닀. ν•˜μ§€λ§Œ deleteλ₯Ό λΆ€λ΄μ§€ 말아야 ν•œλ‹€.

을 이것 λŒ€μ‹ μ—


~cpp 
String s("Future tense C++");

ν•˜μ§€λ§Œ μ •ν™•ν•˜μ§€ μ•Šκ²Œ λ™μž‘ν•˜λŠ” μœ λ„λœ 클래슀의 μ‚¬μš©μ„ μ–΅μ œν•˜λŠ” 것은 λ¬Έλ²•μ μœΌλ‘œ μƒλ‹Ήνžˆ λΆˆνŽΈν•¨μ„ λ‚³λŠ”λ‹€. (Stringμ—μ„œ 이런 λ¬Έλ²•μ μœΌλ‘œ λΆˆνŽΈν•œ 면이 그리 κ°•μ‘°λ˜μ§€ μ•Šλ‹€. κ·Έλ ‡μ§€λ§Œ λ‹€λ₯Έ ν΄λž˜μŠ€μ—μ„œ μ΄λŸ¬ν•œ 문법적인 λΆˆνŽΈν•¨μ„ λ”°μ§€λŠ” 면이 μ€‘μš”ν•˜λ‹€.)

λ¬Όλ‘ , ν•„μš”ν•˜λ‹€λ©΄ ν˜„μž¬ κ°μ•ˆν•˜λŠ” μƒκ°μœΌλ‘œ μ ‘κ·Όν•œλ‹€. 당신이 κ°œλ°œμ€‘μΈ μ†Œν”„νŠΈμ›¨μ–΄λŠ” ν˜„μž¬μ˜ μ»΄νŒŒμΌλŸ¬μ—μ„œ λ™μž‘ν•΄μ•Όλ§Œ ν•œλ‹€.;당신은 μ΅œμ‹ μ˜ μ–Έμ–΄κ°€ ν•΄λ‹Ή κΈ°λŠ₯을 κ΅¬ν˜„ν• λ•ŒκΉŒμ§€ 기닀리지 λͺ»ν•œλ‹€. λ‹Ήμ‹ μ˜ ν˜„μž¬ κ°€μ§€κ³  μžˆλŠ” μ–Έμ–΄μ—μ„œ λ™μž‘ν•΄μ•Ό ν•˜κ³ . κ·Έλž˜μ„œ λ‹Ήμ‹ μ˜ ν΄λΌμ΄μ–ΈνŠΈμ—μ„œ μ‚¬μš© κ°€λŠ₯ν•΄μ•Ό ν•œλ‹€.;λ‹Ήμ‹ μ˜ κ³ κ°μ—κ²Œ κ·Έλ“€μ˜ μ‹œμŠ€ν…œμ„ μ—…κ·Έλ ˆμ΄λ“œ ν•˜κ±°λ‚˜, μˆ˜ν–‰ ν™˜κ²½μ„(operating environment) λ°”κΎΈκ²Œ ν•˜μ§€λŠ” λͺ»ν• κ²ƒμ΄λ‹€. 그건은 μ§€κΈˆ μˆ˜ν–‰ν•¨μ„ 보증해야 ν•œλ‹€.;μ€λ” μž‘μ€, μ€λ” λΉ λ₯Έ ν”„λ‘œκ·Έλž¨μ— λŒ€ν•œ 약속은 라이프 사이클을 쀄이고, κ³ κ°μ—κ²Œ κΈ°λŒ€κ°μ„ 뢀풀릴 것이닀. 그리고 당신이 λ§Œλ“œλŠ” ν”„λ‘œκ·Έλž¨μ€ κ³§ μž‘λ™ν•΄μ•Όλ§Œ ν•œλ‹€. μ΄λŠ” μ’…μ’… "μ΅œμ‹ μ˜ κ³Όκ±°"λ₯Ό λ§Œλ“€μ–΄ 버린닀. μ΄λŠ” μ€‘μš”ν•œ 속박이닀. 당신은 이λ₯Ό λ¬΄μ‹œν• μˆ˜ μ—†λ‹€.

  • μ–΄λ–€ 뢀뢄이 ν˜„μž¬μ‚¬μš©ν• μˆ˜ 없더라도, μ™„μ „ν•œ 클래슀λ₯Ό μ œκ³΅ν•˜λΌ. μƒˆλ‘œμš΄ μš”κ΅¬κ°€ λ‹Ήμ‹ μ˜ 클래슀λ₯Ό λ§Œλ“€κ²Œ ν• λ•Œ, 당신은 μƒˆλ‘œμš΄ 클래슀λ₯Ό μˆ˜μ •ν•˜κ±°λ‚˜, 과거둜 λŒμ•„κ°ˆ 일이 없을꺼닀.
  • λ‹Ήμ‹ μ˜ μΈν„°νŽ˜μ΄μŠ€μ—κ²Œ 일반적인 κΈ°λŠ₯을 μ œκ³΅ν•˜κ³ , μ—λŸ¬λ₯Ό λ°©μ§€ν•˜λ„λ‘ λ””μžμΈ 해라. λΆ€μ •ν™•ν•˜κ²Œ μ‚¬μš©ν•˜κΈ° μ–΄λ ΅κ²Œ ν•˜κ³ , μ •ν™•ν•˜κ²Œ μ‚¬μš©ν•˜κΈ° μ‰½κ²Œ λ§Œλ“€μ–΄λΌ. 예λ₯Ό λ“€μ–΄μ„œ ν΄λž˜μŠ€μ— λŒ€ν•œ λ³΅μ‚¬λ‚˜ 할당에 λŒ€ν•œ μ—°μ‚°μžλ₯Ό μ—†μ• μ„œ, 볡사, 할당을 λͺ»ν•˜κ²Œ ν•˜λΌ. 뢀뢄적인 할당에 λŒ€ν•˜μ—¬ μ˜™μ•„ν•˜λΌ. (Item 33μ°Έκ³ )
  • λ§Œμ•½, λ‹Ήμ‹ μ˜ μ½”λ“œλ₯Ό κ΅¬ν˜„ (generalize:μΌλ°˜ν™”) ν•˜κΈ° μœ„ν•΄μ„œ 큰 μ œν•œμ‚¬ν•­μ΄ μ—†λ‹€λ©΄, κ΅¬ν˜„(generalize:μΌλ°˜ν™”) 해라. 예λ₯Όλ“€μ–΄μ„œ, 당신이 tree 검색 μ•Œκ³ λ¦¬μ¦˜μ„ μž‘μ„±ν•˜λŠ” 쀑이라면, 사이클이 μ—†λŠ” κ·Έλ ˆν”„μ— λŒ€ν•΄ 적용 μ‹œν‚¬μˆ˜ μžˆλŠ” μΌλ°˜ν™”μ— λŒ€ν•œ ꢁ리λ₯Ό 해라.

미래λ₯Ό μƒκ°ν•˜λŠ” 것은 λ‹Ήμ‹ μ˜ μ½”λ“œμ— λŒ€ν•œ 재 μ‚¬μš©μ„±μ„ 늘리고, μœ μ§€λ³΄μˆ˜λ₯Ό μ‰½κ²Œν•˜λ©°, μ†Œν”„νŠΈμ›¨μ–΄λ₯Ό κ²¬κ³ ν•˜κ²Œ λ§Œλ“ λ‹€. 그리고 λ³€ν™”ν•˜λŠ” ν™˜κ²½μ— μš°μ•„ν•˜κ²Œ λŒ€μ²˜ν•  것이 ν™•μ‹€ν•˜λ‹€. λ―Έλž˜μ— λŒ€ν•œ λŒ€μ²˜λŠ” λ°˜λ“œμ‹œ ν˜„μž¬μ˜ 생각과 κ· ν˜•μ„ μ΄λ£¨μ–΄μ•Όλ§Œ ν•œλ‹€. λ§Žμ€ ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ΄ ν˜„μž¬ μ΄μ™Έμ—λŠ” 생각을 ν•˜μ§€ μ•ŠλŠ”λ‹€. ν•˜μ§€λ§Œ, κ·Έλž˜μ„œ 그듀은 κ΅¬ν˜„κ³Ό λ””μžμΈμ— κΈ΄ μ‹œκ°μ„ 포기해야 ν•œλ‹€. λ‹€λ΄κ²Œ ν•˜μ—¬λΌ. 거뢀해라. 미래λ₯Ό μƒκ°ν•˜λŠ” ν”„λ‘œκ·Έλž¨μ„ λ§Œλ“€μ–΄λΌ.

2. Item 33: Make non-leaf classes abstract.

  • Item 33: μœ λ„λœ ν΄λž˜μŠ€κ°€ μ—†λŠ” μƒνƒœμ˜ 클래슀둜 좔상화 ν•˜λΌ.
당신이 λ™λ¬Όμ˜ 역할을 ν•˜λŠ” μ†Œν”„νŠΈμ›¨μ–΄ ν”„λ‘œμ νŠΈλ₯Ό μ§„ν–‰ν•œλ‹€κ³  가정해라. 이 μ†Œν”„νŠΈμ›¨μ–΄μ—μ„œλŠ” λŒ€λΆ€λΆ„μ˜ 동물듀이 κ°™κ²Œ 취급될 수 μžˆλ‹€. κ·Έλ ‡μ§€λ§Œ 두 μ’…λ₯˜μ˜ 동물듀 -lizard(λ„λ§ˆλ±€) 와 chicken(λ‹­)- 은 νŠΉλ³„ν•œ 핸듀링(handling)을 μ›ν•œλ‹€. κ·ΈλŸ¬ν•œ κ²½μš°μ—, λͺ…λ°±ν•œ 방법은 λ‹€μŒκ³Ό 같이 관계λ₯Ό λ§Œλ“€μ–΄ λ²„λ¦¬λŠ” 것이닀.


Animal ν΄λž˜μŠ€λŠ” μ£Όμ–΄μ§„ λͺ¨λ“  생λͺ…체듀이 κ³΅μœ ν•˜κ³  μžˆλŠ” 뢀뢄이닀. 그리고 Lizardκ³Ό Chicken ν΄λž˜μŠ€λŠ” Animalμ—μ„œ λ„λ§ˆλ±€κ³Ό λ‹­λ§ŒμœΌλ‘œ νŠΉν™”λœ ν΄λž˜μŠ€μ΄λ‹€.

μ—¬κΈ° 이듀 ν΄λž˜μŠ€λ“€μ˜ λŒ€κ°•μ˜ λͺ¨μŠ΅μ„ κ·Έλ¦°λ‹€.


~cpp 
 class Animal {
public:
	Animal& operator=(const Animal& rhs);
	...
};

class Lizard: public Animal {
public:
	Lizard& operator=(const Lizard& rhs);
	...
};

class Chicken: public Animal {
public:
	Chicken& operator=(const Chicken& rhs);
	...
};

λ³΄λ‹€μ‹œν”Ό 였직 ν• λ‹Ή(assignment) μ—°μ‚°μžλ§Œ 보인닀. κ·Έλ ‡μ§€λ§Œ 이걸둜 μœ μ§€ν•˜λŠ” 것은 μΆ©λΆ„ν•˜λ‹€. λ‹€μŒ μ½”λ“œλ₯Ό 생각해 보자.


~cpp 
    Lizard liz1;
    Lizard liz2;
    Animal *pAnimal1 = &liz1;
    Animal *pAnimal2 = &liz2;
    ...
    *pAnimal1 = *pAnimal2;
μ—¬κΈ°μ—λŠ” λ‘κ°€μ§€μ˜ λ¬Έμ œκ°€ μžˆλ‹€. 첫번째둜 λ§ˆμ§€λ§‰ 쀄에 μžˆλŠ” ν• λ‹Ή μ—°μ‚°μžλŠ” Animal 클래슀의 것을 λΆ€λ΄λŠ”λ°, 객체 ν˜•μ΄ Lizadν˜•μ΄λΌλ„ Animal 클래슀의 μ—°μ‚°μžλ‘œ μ§„ν–‰λœλ‹€. 결과적으둜, 였직 liz1의 Animal λΆ€λΆ„λ§Œμ΄ μˆ˜μ •λœλ‹€. 이것은 뢀뢄적인 ν• λ‹Ή(assignment)이닀. liz1에 Animal λ©€λ²„μ˜ 할당은 li2λ‘œλΆ€ν„° 얻은 값을 κ°€μ§„λ‹€. κ·Έλ ‡μ§€λ§Œ liz1의 Lizard λΆ€λΆ„μ˜ λ°μ΄ν„°λŠ” λ³€ν™”ν•˜μ§€ μ•ŠλŠ”λ‹€.

λ‘λ²ˆμ§Έ λ¬Έμ œλŠ” μ§„μ§œ ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ΄ 이와 같은 μ½”λ“œλ₯Ό μ“΄λ‹€λŠ” 것이닀. νŠΉλ³„νžˆ C++둜 μ „ν–₯ν•œ Cν”„λ‘œκ·Έλž˜λ¨Έλ“€μ— κ²½ν—˜μ—μ„œ 보면, 포인터λ₯Ό ν†΅ν•œ 객체의 할당은 그리 ν”ν•˜μ§€ μ•Šμ€κ²ƒλ„ μ•„λ‹ˆλ‹€. κ·ΈλŸ¬ν•œ κ²½μš°λŠ” 이성적인 μƒκ°μœΌλ‘œ μ·¨ν•œ 할당같이 보인닀. Item 32의 촛점쀑, 상속 관계 μƒμ—μ„œ 우리의 ν΄λž˜μŠ€λŠ” μ •ν™•νžˆ μ‚¬μš©ν•˜κΈ° 쉽고, λΆ€μ •ν™•ν•˜κ²Œ μ‚¬μš©ν•˜κΈ° μ–΄λ ΅κ²Œ ν•΄μ•Ό ν•œλ‹€κ³  μ–ΈκΈ‰ν–ˆλ‹€.

λ¬Έμ œμ— λŒ€ν•œ ν•œκ°€μ§€ μ ‘κ·ΌμœΌλ‘œ ν• λ‹Ή(assignment)μ—°μ‚°μžλ₯Ό 가상(virtual)둜 μ„ μ–Έν•˜λŠ” 방법이 μžˆλ‹€. λ§Œμ•½ Animal::operator= κ°€ 가상(virtual)이면, μœ„μ˜ κ²½μš°μ— ν• λ‹Ή μ—°μ‚°μžλŠ” μ •ν™•ν•œ Lizard ν• λ‹Ή μ—°μ‚°μžλ₯Ό ν˜ΈμΆœν•˜λ €κ³  μ‹œλ„ν•  것이닀. κ·Έλ ‡μ§€λ§Œ λ§Œμ•½ μš°λ¦¬κ°€ κ°€μƒμœΌλ‘œ ν• λ‹Ή μ—°μ‚°μžλ₯Ό μ„ μ–Έν–ˆμ„λ•Œ λ‹€μŒμ„ 봐라.


~cpp 
class Animal {
public:
    virtual Animal& operator=(const Animal& rhs);
    ...
};
class Lizard: public Animal {
public:
    virtual Lizard& operator=(const Animal& rhs);
    ...
};
class Chicken: public Animal {
public:
    virtual Chicken& operator= (const Animal& rhs);
    ...
};

언어상에 μ΅œκ·Όμ— 변화와 κ΄€κ³„μžˆλŠ” 의무둜 μš°λ¦¬λŠ” ν• λ‹Ή μ—°μ‚°μžμ— λŒ€ν•œ λ°˜ν™˜κ°’μ˜ μ΅œμ ν™”λ₯Ό μ§„ν–‰ν• μˆ˜ μžˆλ‹€. κ·Έλž˜μ„œ 각 λ°˜ν™˜ 참쑰에 μ •ν™•ν•œ 클래슀둜 ꡐ체 ν• μˆ˜ μžˆλ‹€ ν•˜μ§€λ§Œ C++의 κ·œμΉ™μ€ λͺ¨λ“  클래슀 내뢀에, 가상 ν•¨μˆ˜μ— λŒ€ν•˜μ—¬ λ™μΌν•œ parameter ν˜•μ„ κ·œμ • μ§€μ„μˆ˜ μžˆλ‹€. μ΄κ²ƒμ˜ μ˜λ―ΈλŠ” Lizard와 Chicken에 λŒ€ν•œ ν• λ‹Ή μ—°μ‚°μžκ°€ λ°˜λ“œμ‹œ ν• λ‹Ήμ‹œ right-hand 뢀뢄에 Animal의 μ–΄λ– ν•œ(any) ν•œμ’…λ₯˜μ˜ 객체에 λŒ€ν•œ μ€λΉ„λ₯Ό ν•΄μ•Όλ§Œ ν•œλ‹€λŠ” 것이닀. μ΄λŠ” μš°λ¦¬μ—κ²Œ λ‹€μŒκ³Ό 같은 μ½”λ“œκ°€ ν•©λ²•μž„μ„ μ˜λ―Έν•˜λŠ” 것이닀.


~cpp 
Lizard liz;
Chicken chick;

Animal *pAnimal1 = & liz;
Animal *pAnimal2 = & chick;
...
*pAnimal1 = *pAnimal2;  // chicken을 lizard에 ν• λ‹Ήν•œλ‹¨ 말이닀.!

이것은 mix-type의 할당이닀.:LizardλŠ” 였λ₯Έμͺ½μ˜ Chicken의 μ™Όμͺ½μ— μžˆλŠ” μž…μž₯이닀. Mixed-type 할당은 C++μ—μ„œ ν‰λ²”ν•œ λ¬Έμ œλŠ” μ•„λ‹ˆλ‹€. μ™œλƒν•˜λ©΄ μ–Έμ–΄μ˜ strong typing은 보톡 그것이 κ·œμ •μ—μ„œ μ–΄κΈ‹λ‚˜κ²Œ ν•˜κΈ° λ•Œλ¬Έμ΄λ‹€. ν•˜μ§€λ§Œ, animal의 ν• λ‹Ή μ—°μ‚°μžλ₯Ό κ°€μƒμœΌλ‘œ ν•˜λŠ” 것에 μ˜ν•΄, λ‹«ν˜€μ§„ Mix-type μ—°μ‚°μžμ˜ 문이 μ—΄λ € 버린닀.

이것은 μ–΄λ €μš΄ 면이닀. μš°λ¦¬λŠ” same-type ν• λ‹Ήλ§Œ ν¬μΈν„°λ‘œ ν—ˆμš©ν•˜κ²Œ λ§Œλ“€μ–΄μ•Ό 할것이닀. 그에 λ°˜ν•˜μ—¬ 같은 포인터λ₯Ό ν†΅ν•œ Mix-type 할당은 κ±°λΆ€λ˜λ„λ‘ λ§Œλ“€μ–΄μ•Ό ν•œλ‹€. λ‹€λ₯Έ 말둜 ν•˜μžλ©΄ μš°λ¦¬λŠ” 이런건 ν†΅κ³Όμ§€λ§Œ


~cpp 
Animal *pAnimal1 = &liz1;
Animal *pAnimal2 = &liz2;
...
*pAnimal1 = *pAnimal2;      // 톡과λ₯Ό μ›ν•΄μš”! 같은 ν˜•μ΄λ€λ‘œ

κ·Έλ ‡μ§€λ§Œ

~cpp 
Animal *pAnimal1 = &liz;
Animal *pAnimal2 = &chick;
...
*pAnimal1 = *pAnimal2;      // μ•ˆλ˜κΈΈ μ›ν•΄μš”~

μ΄λŸ¬ν•œ κ²½μš°μ— ν˜•μ„ κ°€λ¦¬λŠ” 것은 였직 μ‹€ν–‰ μ‹œκ°„ 쀑에 ν• μˆ˜ μžˆλ‹€. μ™œλƒν•˜λ©΄ μ–΄λ–€λ•ŒλŠ”, *pAnimal2λ₯Ό *pAnimal1에 μœ νš¨ν•œ ν• λ‹Ήμž„μ„ μ•Œμ•„ λ‚΄μ•Όν•˜κ³ , μ–΄λ–€λ•ŒλŠ” μ•„λ‹Œκ±Έ 증λͺ…ν•΄μ•Ό ν•˜κΈ° λ•Œλ¬Έμ΄λ‹€. κ·Έλž˜μ„œ μš°λ¦¬λŠ” ν˜• 기반(type-based)의 μ‹€ν–‰ μ‹œκ°„ μ—λŸ¬μ˜ 거친 μ„Έκ³„λ‘œ λ“€μ–΄κ°€κ²Œ λœλ‹€. νŠΉλ³„ν•˜κ²Œ, λ§Œμ•½ mixed-type 할당을 λ§Œλ‚˜λ©΄, operator= 내뢀에 μ—λŸ¬ ν•˜λ‚˜λ₯Ό λ°œμƒν•˜λŠ” 것이 ν•„μš”ν•˜λ‹€. κ·Έλ ‡μ§€λ§Œ λ§Œμ•½ type이 κ°™μœΌλ©΄ μš°λ¦¬λŠ” 일반적인 생각에 λ”°λΌμ„œ 할당을 μˆ˜ν–‰ν•˜κΈ°λ₯Ό μ›ν•œλ‹€.

우린 dynamic_cast(Item 2μ°Έκ³ )λ₯Ό μ΄λŸ¬ν•œ 행동에 μ μš©ν•΄μ„œ μ‚¬μš©ν• μˆ˜ μžˆλ‹€. μ—¬κΈ° Lizard의 ν• λ‹Ή μ—°μ‚°μžμ— λŒ€ν•œ 방법이 μžˆλ‹€.


~cpp 
Lizard& Lizard::operator=(const Animal& rhs)
{
    // lizardκ°€ μ§„μ§œ rhsκ°€ λ§žλŠ”κ°€?
    const Lizard& rhs_liz = dynamic_cast<const Lizard&>(rhs);

    *this에 rhs_liz의 일반적인 ν• λ‹Ήκ³Όμ • μˆ˜ν–‰μ„ ν•œλ‹€.
}

μ΄λŸ¬ν•œ ν•¨μˆ˜λŠ” *thisκ°€ 였직 rhsκ°€ LizardμΌλ•Œλ§Œ 할당을 ν—ˆμš©ν•œλ‹€. λ§Œμ•½ 이것이 ν†΅κ³Όλ˜μ§€ λͺ»ν•œλ‹€λ©΄, bad_cast μ˜ˆμ™Έκ°€ dynamic_castμ—μ„œ λ°œμƒλ˜μ–΄μ„œ μ „λ‹¬λ˜μ–΄ μ§„λ‹€. (μ •ν™•νžˆ ν‘œμ€ C++ λΌμ΄λΈŒλŸ¬λ¦¬μ— μžˆλŠ” std::bad_cast ν˜•μ˜ 객체가 λ‚ μ•„κ°„λ‹€. 이름 곡간이 std에 κ΄€ν•œκ²ƒμ€ ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬λ₯Ό μ‚΄ν”Όκ³  Item 35에도 μ„€λͺ…λ˜μ–΄ μžˆλ‹€.)

μ˜ˆμ™Έ κ΄€ν•œ μ£Όμ˜κ°€ ν•„μš” μ—†λŠ” λ³΄ν†΅μ˜ κ²½μš°μ—, 이 ν•¨μˆ˜λŠ” λ³΅μž‘ν•˜κ³ , λΉ„μš© 뢀담이 ν•„μš”ν•  κ²ƒμœΌλ‘œ 보인닀.


~cpp 
Lizard liz1, liz2;
...
liz1 = liz2;    // dynamic_castκ°€ ν•„μš”λ‘œ ν•˜μ§€ μ•Šλ‹€. 이건 λ°˜λ“œμ‹œ μ˜³λ‹€.

μš°λ¦¬λŠ” Lizard에 μ€λ” μ λ‹Ήν•œ ν• λ‹Ή μ—°μ‚°μžλ₯Ό λ”ν•΄μ„œ dynamic_cast둜 인해 λ°œν–‰ν•˜λŠ” λΉ„μš©κ³Ό λ³΅μž‘μ„±μ„ μ œκ°€ ν• μˆ˜ μžˆλ‹€.


~cpp 
class Lizard: public Animal {
public:
    virtual Lizard& operator=(const Animal& rhs);
    Lizard& operator=(const Lizard& rhs);           // λ”ν•œ λΆ€λΆ„
    ...
};

Lizard liz1, liz2;
...
liz1 = liz2;                    // const Lizard&λ₯Ό 인자둜 ν•˜λŠ” operator= 호좜

Animal *pAnimal1 = &liz1;
Animal *pAnimal2 = &liz2;
...
*pAnimal1 = *pAnimal2;      // const Ainmal&인자둜 κ°€μ§€λŠ” operator= μ—°μ‚°μž 호좜

const Animal&을 인자둜 ν•˜λŠ” μ—°μ‚°μžμ˜ κ΅¬ν˜„μ€ κ΅¬ν˜„μ€ κ°„λ‹¨ν•œλ‹€.


~cpp 
Lizard& Lizard::operator=(const Animal& rhs)
{
    return operator=(dynamic_cast<const Lizard&>(rhs));
}

이 ν•¨μˆ˜λŠ” rhsλ₯Ό Lizard둜 ν˜•λ³€ν™˜ μ‹œν‚¨λ‹€. λ§Œμ•½ ν˜•λ³€ν™˜μ΄ μ„±κ³΅λœλ‹€λ©΄ ν• λ‹Ή μ—°μ‚°μžκ°€ μ„±κ³΅μ μœΌλ‘œ 호좜 될것이닀. λ°˜λŒ€λΌλ©΄ μ–ΈκΈ‰ν–ˆλ˜ bad_cast μ˜ˆμ™Έκ°€ λ°œμƒλœλ‹€.

μ†”μ§νžˆ, dynamic_castλ₯Ό μ‚¬μš©ν•΄μ„œ μ‹€ν–‰ μ‹œκ°„μ— κ²€μ‚¬ν•˜λŠ”κ±΄ μ€ μ§œμ¦λ‚œλ‹€. ν•œκ°€μ§€, λͺ‡λͺ‡ μ»΄νŒŒμΌλŸ¬λŠ” 아직 dynamic_cast에 λŒ€ν•œ 지원이 λΆ€μ‘±ν•΄μ„œ, 이λ₯Ό μ‚¬μš©ν•˜λ©΄, μ΄λ‘ μ μœΌλ‘œλŠ” 이식성이 보μž₯λ˜μ§€λ§Œ μ‹€μ œλ‘œλŠ” κ·Έλ ‡μ§€ μ•Šλ‹€. 더 μ€‘μš”ν•˜κ²Œ Lizard와 Chicken의 ν΄λΌμ΄μ–ΈνŠΈλ“€μ€ bad_cast μ˜ˆμ™Έμ— λŒ€ν•œ μ€λΉ„와, 할당을 μˆ˜ν–‰ν• λ•Œμ˜ 각 μ½”λ”©μ‹œμ— λ―Όκ°ν•˜κ²Œ μ²˜λ¦¬ν•˜μ§€ λͺ»ν•œλ‹€. λ‚΄ κ²½ν—˜μ— λΉ„μΆ”μ–΄ λ³Όλ•Œ λ§Žμ€ ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ΄ 그런 방법을 μ·¨ν•˜μ§€ μ•Šκ³  μžˆλ‹€. λ§Œμ•½ 그듀이 ν•˜μ§€ μ•ŠλŠ”λ‹€λ©΄, 할당이 μΌμ–΄λ‚˜λŠ” μˆ˜λ§Žμ€ κ³³μ—μ„œ μ •ν™•ν•˜μ§€ μ•Šμ€ μ²˜λ¦¬μƒνƒœλ‘œ, λͺ…λ£Œμ„±μ„ 보μž₯ λ°›μ„μˆ˜ μ—†λ‹€.

가상 ν• λ‹Ή μ—°μ‚°μžλ₯Ό μ΄μš©ν•˜λŠ” 것 μ—­μ‹œ λΆˆμΆ©λΆ„ν•œ μƒνƒœκ°€ μ£Όμ–΄μ§„λ‹€. 그것은 ν΄λΌμ΄μ–ΈνŠΈκ°€ λ¬Έμ œμžˆλŠ” 할당을 ν•˜λŠ” 것을 λ°©μ§€ν•˜λŠ” 방법을 찾도둝 λ…Έλ ₯ν•˜λŠ”λ° νž˜μ„μ“°κ²Œ λ§Œλ“ λ‹€. λ§Œμ•½ κ·ΈλŸ¬ν•œ 할당이 컴파일 쀑에 κ±°λΆ€λœλ‹€λ©΄, μš°λ¦¬λŠ” 잘λͺ»μ΄ 일어날 것에 λŒ€ν•΄ κ±±μ •ν•  ν•„μš”κ°€ μ—†κ²Œλœλ‹€.

κ°€μž₯ μ‰¬μš΄ 방법은 Animal λ‚΄λΆ€μ˜ operator=λ₯Ό 사역(private)둜 λ¬Άμ–΄μ„œ ν• λ‹Ή 자체λ₯Ό ν•˜μ§€ λͺ»ν•˜κ²Œ λ§Œλ“€μ–΄ λ²„λ¦¬λŠ” 것이닀. 그런 방법은 λ„λ§ˆλ±€μ΄ λ„λ§ˆλ²°μ—κ²Œ, 닭이 λ‹­μ—κ²Œλ§Œ 할당을 ν• μˆ˜ μžˆμ§€λ§Œ, 뢀뢄적이고 Mix-type 할당을 λ°©μ§€ν•œλ‹€.


~cpp 
class Animal {
private:
    Animal& operator=(const Animal& rhs);       // 사역(private)이닀.
    ...
};

class Lizard: public Animal {
public:
    Lizard& operator=(const Lizard& rhs);
    ...
};

class Chicken: public Animal {
public:
    Chicken& operator=(const Chicken& rhs);
    ...
};

Lizard liz1, liz2;
...
liz1 = liz2;                    // μ˜³λ°”λ΄λ‹€.

Chicken chick1, chick2;
...
chick1 = chick2;                // μ—­μ‹œ μ˜³λ°”λ΄λ‹€.

Animal *pAnimal1 = &liz1;
Animal *pAnimal2 = &chick1;
...
*pAnimal1 = *pAnimal2;          // μ—λŸ¬! Animal::operator=κ°€ 사역이라 μ—λŸ¬λ‚œλ‹€.
λΆˆν–‰νžˆ Animal은 concrete ν΄λž˜μŠ€μ΄λ‹€.(가상이 μ•„λ‹ˆλž€ μ†Œλ¦¬) 그리고 μ΄λŸ¬ν•œ 접근은 Animal 객체 간에 할당을 λͺ»ν•˜λŠ” 것을 μ˜λ―Έν•œλ‹€.

~cpp 
Animal animal1, animal2;
...
animal1 = animal2;      // μ—λŸ¬! Animal::operator=κ°€ 사역(private)이닀.
κ²Œλ‹€κ°€ Lizard와 Chicken에 κ΅¬ν˜„λœ ν• λ‹Ή μ—°μ‚°μžλ„ μ •ν™•νžˆ κ΅¬ν˜„λ˜κΈ° λΆˆκ°€λŠ₯ν•˜λ‹€. μ™œλƒν•˜λ©΄, μœ λ„λœ ν΄λž˜μŠ€μ—μ„œ ν• λ‹Ή μ—°μ‚°μžλŠ” κ·Έλ“€μ˜ 기초 클래슀의 ν• λ‹Ή μ—°μ‚°μžμ˜ ν˜ΈμΆœμ„ μ±…μž„μ§„λ‹€.

~cpp 
Lizard& Lizard::operator=(const Lizard& rhs)
{
    if (this == &rhs) return *this;

    Animal::operator=(rhs);     // μ—λŸ¬! 사역(private) 인자의 ν•¨μˆ˜λ₯Ό ν˜ΈμΆœν•˜λŠ” μ‹œλ„λ₯Ό ν•œλ‹€.
                                // ν•˜μ§€λ§Œ Lizard::operator=λŠ” λ°˜λ“œμ‹œ 이 ν•¨μˆ˜λ₯Ό Animal λΆ€λΆ„
                                // 의 할당을 μœ„ν•΄ ν˜ΈμΆœν•΄μ•Ό ν•œλ‹€.
    ...
}    
μ΄λŸ¬ν•œ 문제λ₯Ό Animal::operator=λ₯Ό 보호(protected)μ˜μ—­μœΌλ‘œ μ„€μ •ν•΄μ„œ ν•΄κ²°ν• μˆ˜ μžˆλ‹€. ν•˜μ§€λ§Œ Animal 포인터λ₯Ό ν†΅ν•˜μ—¬ Lizard와 Chicken객체의 뢀뢄적인 할당을 λ§‰λŠ” 것에 λΉ„ν•˜μ—¬, Animal 객체 κ°„μ˜ ν• λ‹Ή λ¬Έμ œλŠ” λ‚œμ œμ΄λ‹€. 좔상 ν΄λž˜μŠ€λ‘œμ„œ Animal 은 μ΄ˆκΈ°ν™” ν• μˆ˜ μ—†λ‹€. κ·Έλž˜μ„œ Animal κ°„μ˜ 할당은 ν—ˆμš©λ  ν•„μš”κ°€ μ—†λ‹€. λ¬Όλ‘  μƒˆλ‘œμš΄ 문제λ₯Ό μˆ˜λ°˜ν•œλ‹€. μ™œλƒν•˜λ©΄ 우리의 기본적인 λ””μžμΈμ—μ„œ 이 μ‹œμŠ€ν…œμ—μ„œλŠ” Animal을 κ°μ²΄λ‘œμ„œ ν•„μš”κ°€ μžˆμ–΄μ„œ μ§€μ›ν•œ 것 이기 λ•Œλ¬Έμ΄λ‹€. μ΄λŸ¬ν•œ μ‰¬μš΄ 방법은 μ–΄λ €μš΄ 뢀뢄이 λ‘˜λŸ¬μ‹Έκ³  μžˆλŠ” ν˜•κ΅­μ΄λ‹€. λŒ€μ‹ μ— Animal 을 좔상화 μ‹œν‚€λŠ” 클래슀λ₯Ό μƒˆλ‘œ λ§Œλ“€μ–΄ λ²„λ¦¬λŠ” 건 μ–΄λ–¨κΉŒ? AbstractAnimal 같이 말이닀. λŒ€μ‹ μ— 이제 이듀을 Animal, Lizard, Chicken 객체가 상속을 λ°›κ³  κ°μ²΄λ‘œμ„œ ν™œμš© λ˜λŠ” 것이닀. κ·Έλ ‡κ²Œ 되면 μš°λ¦¬λŠ” AbstractAnimal μ΄λΌλŠ” 좔상 ν΄λž˜μŠ€μ—μ„œ Concrete 클래슀λ₯Ό μœ λ„ν•œλ‹€. μ΄λŸ¬ν•œ 계측도λ₯Ό μ€λΉ„ν•˜λ©΄ λ‹€μŒκ³Ό κ°™λ‹€.


그리고 λ‹€μŒκ³Ό 같이 μ •μ˜ λœλ‹€.

~cpp 
class AbstractAnimal {
protected:
    AbstractAnimal& operator=(const AbstractAnimal& rhs);
public:
    virtual ~AbstractAnimal() = 0;        // 이에 κ΄€ν•΄μ„œλŠ” μ„€λͺ…에 μžμ„Ένžˆ
    ...
};

class Animal: public AbstractAnimal {
public:
    Animal& operator=(const Animal& rhs);
    ...
};

class Lizard: public AbstractAnimal {
public:
    Lizard& operator=(const Lizard& rhs);
    ...
};

class Chicken: public AbstractAnimal {
public:
    Chicken& operator=(const Chicken& rhs);
    ...
};

이 λ””μžμΈμ€ 당신이 ν•„μš”ν•œ λͺ¨λ“ κ²ƒμ„ μ œκ³΅ν•œλ‹€. λ™μ’…μ˜ 할당에 κ΄€ν•΄μ„œ 동물, λ„λ§ˆλ±€, λ‹­μ˜ ν• λ‹Ή 연산을 ν—ˆμš©ν•œλ‹€.;뢀뢄적인 ν• λ‹Ήκ³Ό νƒ€μ’…κ°„μ˜ 할당을 κΈˆμ§€ν•œλ‹€λŠ” 것;그리고 μœ λ„λœ 클래슀의 할당은 μ•„λ§ˆ κΈ°λ³Έ 클레슀 λ‚΄μ˜ ν• λ‹Ή μ—°μ‚°μžκ°€ 맑을 것이닀. κ²Œλ‹€κ°€ Animal, Lizard, Chicken클래슀의 역할이 기둝된 μ½”λ“œλ“€μ„ μˆ˜μ •μ„ ν•„μš”λ‘œ ν•˜μ§€ μ•ŠλŠ”λ‹€. μ™œλƒν•˜λ©΄, 이듀 ν΄λž˜μŠ€λŠ” μ†Œκ³„λœ AbstractAnimal 클래슀둜 κΈ°μ΄μ˜ 역할듀을 λŒ€μ‹  λ°›μ„μˆ˜ μžˆλ‹€. λ¬Όλ‘ , κ·ΈλŸ¬ν•œ μ½”λ“œλ“€μ€ 재 컴파일이 λ˜μ–΄μ•Ό ν•œλ‹€. κ·Έλ ‡μ§€λ§Œ μ»΄νŒŒμΌλŸ¬κ°€ ν• λ‹Ήμ˜ λͺ…μ‹œμ„±μ„ 보μž₯ν•΄ μ£Όμ–΄μ„œ 보μž₯λ˜λŠ” λ³΄μ•ˆμ„±μ— λΉ„ν•˜μ—¬ μž‘μ€ λΉ„μš©μ΄λ‹€.

λͺ¨λ“  일에 λŒ€ν•˜μ—¬ AbstractTnimal은 λ°˜λ“œμ‹œ 좔상적이어야 ν•˜λ‚˜? 그것은 λ°˜λ“œμ‹œ μ΅œμ†Œ ν•˜λ‚˜μ˜ 순수 가상 ν•¨μˆ˜λ₯Ό κ°€μ§€κ³  μžˆμ–΄μ•Ό ν•œλ‹€. λŒ€λΆ€λΆ„μ˜ κ²½μš°μ— μ•Œλ§žλŠ” ν•¨μˆ˜λ₯Ό κ³ λ΄κΈ°μ—λŠ” 별 λ¬Έμ œκ°€ μ—†λ‹€. κ·Έλ ‡μ§€λ§Œ ν¬κ·€ν•œ κ²½μš°μ— 당신은 μ•„λ§ˆ AbstractAnimal 같은 클래슀λ₯Ό λ§Œλ“€μ–΄μ•Ό ν•˜λŠ” 상황에 직면할지도 λͺ¨λ₯Έλ‹€. κ·ΈλŸ¬ν•œ κ²½μš°μ—, μ λ‹Ήν•œ 방법은 순수 가상 ν•¨μˆ˜λ‘œ 파괴자λ₯Ό λ§Œλ“€μ–΄ λ²„λ¦¬λŠ” 것이닀.;μœ„μ—μ„œ λ³΄λŠ”κ²ƒκ³Ό 같이 말이닀.포인터λ₯Ό ν†΅ν•œ λ‹€ν˜•μ„±μ„ μ§€μ›ν•˜κΈ° μœ„ν•˜μ—¬ κΈ°λ³Έ ν΄λž˜μŠ€λŠ” 가상 파괴자λ₯Ό μ–΄λ–€ λ°©λ²•μœΌλ‘œλ“  ν•„μš”λ‘œ ν•œλ‹€. κ·Έλž˜μ„œ 순수 κ°€μƒν•¨μˆ˜λ₯Ό λ§Œλ“€κΈ° μœ„ν•œ λΉ„μš©λ§Œμ΄ ν•΄λ‹Ή 클래슀 μ •μ˜λΆ€ λ°”κΉ₯μ—μ„œ μ΄λ£¨μ–΄μ§ˆ κ΅¬ν˜„μ—μ„œ μ§€λΆˆλœλ‹€. (에λ₯Όλ“€μ–΄μ„œ p195λ₯Ό 보아라)

(순수 가상 ν•¨μˆ˜μ— λŒ€ν•œ κ΅¬ν˜„μ˜ κ°œλ…μ΄ 당신을 ν˜Όλž€μŠ€λŸ½κ²Œ ν•œλ‹€λ©΄, 그거에 신경을 끊으면 λœλ‹€. 순수 가상 ν•¨μˆ˜μ˜ 선언은 κ΅¬ν˜„μ΄ μ—†λŠ”κ²ƒμ„ 의미 ν•˜μ§€λ§Œμ€ μ•Šλ‹€. 그것은 μ˜λ―Έν•œλ‹€.
  • ν˜„μž¬μ˜ 클래슀λ₯Ό 좔상화 ν•œλ‹€. 그리고
  • ν˜„μž¬ ν΄λž˜μŠ€μ—μ„œ μœ λ„λœ μ–΄λ– ν•œ concrete ν΄λž˜μŠ€λΌλ„ λ°˜λ“œμ‹œ "보톡" 가상 ν•¨μˆ˜λ‘œ ν•¨μˆ˜λ₯Ό μ„ μ–Έν•΄μ•Ό ν•œλ‹€. (λ‹€μ‹œ 말해 "=0"을 μ œμ™Έν•˜κ³ )
λ§žλ‹€, λŒ€λΆ€λΆ„μ˜ 순수 가상 ν•¨μˆ˜λŠ” κ²°μ½” κ΅¬ν˜„λ˜μ§€ μ•ŠλŠ”λ‹€. κ·Έλ ‡μ§€λ§Œ 순수 가상 νŒŒκ΄΄μžλŠ” νŠΉλ³„ν•œ κ²½μš°μ΄λ‹€. 그듀은 λ°˜λ“œμ‹œ κ΅¬ν˜„λ˜μ–΄μ•Ό ν•œλ‹€. μ™œλƒν•˜λ©΄ 그듀은 μœ λ„λœ ν΄λž˜μŠ€λ“€μ΄ νŒŒκ΄΄λ λ•Œ λ§ˆλ‹€ 뢈리기 λ•Œλ¬Έμ΄λ‹€. κ²Œλ‹€κ°€ 그듀은 μ’…μ’… μœ μš©ν•œ μž‘λ™μ„ ν•˜λŠ”λ°, μžμ›μ˜ ν•΄μ œ 같은거(Item 9μ°Έκ³ )λ‚˜ 둜그 λ©”μ„Έμ§€λ₯Ό λ‚¨κΈ°λŠ”κ²ƒ λ”°μœ„ 말이닀. 순수 가상 ν•¨μˆ˜μ˜ κ΅¬ν˜„μ€ 일반적으둜 μ•„λ§ˆ νŠΉλ³„ν•˜μ§€ μ•Šμ€ κ²½μš°μ΄λ‹€. ν•˜μ§€λ§Œ 순수 가상 νŒŒκ΄΄μžλŠ” κ·Έλ ‡μ§€ ν•˜λ‹€ 그것은 λͺ…령에 가깝닀.)

당신은 μ•„λ§ˆλ„ 데이터 멀버λ₯Ό κ°€μ§€λŠ” Animal 클래슀 같이, Concrete 기초 클래슀λ₯Ό 기반으둜 μ „μ²΄ν•˜κ³  기초 클래슀의 포인터λ₯Ό ν†΅ν•΄μ„œ 할당에 λŒ€ν•œ λ…Όμ˜λΌλŠ”κ±Έ μ£Όλͺ©ν•  것이닀. κ·Έλ ‡λ‹€λ©΄, λ§Œμ•½ μ•„λ¬΄λŸ° 데이터가 μ—†λ‹€λ©΄, μ˜λ„μ— λΆ€ν•©ν•˜λŠ”, λ¬Έμ œκ°€ μ•ˆλ κ²ƒμ΄ μ—†κ³ , μ€λ” 생각해 보면, 그것은 μžλ£Œκ°€ μ—†λŠ” concrete ν΄λž˜μŠ€κ°€ λ‘λ²ˆ 상속 λ˜μ–΄λ„ μ•ˆμ „ν• κΊΌλΌκ³  μ˜κ²¬μ„ νŽΌμ§€ λͺ¨λ₯Έλ‹€.

두가지 κ²½μš°μ— ν•œκ°€μ§€λŠ” λ‹Ήμ‹ μ˜ 데이터가 μ—†λŠ” concrete둜 μ μš©ν•œλ‹€.:이건 λ―Έλž˜μ— 데이터λ₯Ό κ°€μ§ˆμ§€λ„, μ•ˆκ°€μ§ˆμ§€λ„ λͺ¨λ₯Έλ‹€. λ§Œμ•½ λ―Έλž˜μ— 데이터λ₯Ό κ°€μ§„λ‹€λ©΄, 당신이 ν•˜λŠ” λͺ¨λ“  것은 데이터 멀버가 μΆ”κ°€λ„λ¦¬λ•ŒκΉŒμ§€ 문제λ₯Ό 미루어 λ‘λŠ” 것이닀. 이런 경우 당신은 잠깐의 νŽΈν•¨κ³Ό 였랜 μ‹œκ°„μ˜ κ³ λ‡Œλ₯Ό λ§žλ°”κΎΈλŠ” 것이닀. (Item 32μ°Έκ³ ) λŒ€μ•ˆμœΌλ‘œ, λ§Œμ•½ 기초 ν΄λž˜μŠ€κ°€ 정말 μ–΄λ– ν•œ 데이터도 κ°€μ§€κ³  μžˆμ§€ μ•Šλ‹€λ©΄, μ²˜μŒμ— 좔상화 ν΄λž˜μŠ€μ™€ μ•„μ£Ό λΉ„μŠ·ν•œ 이야기가 λœλ‹€. concrete κΈ°λ³Έ ν΄λž˜μŠ€λŠ” 데이터 없이 μ‚¬μš©λ˜λŠ”κ±΄ 무엇인가?

AbstractAnimal 같은 좔상 κΈ°λ³Έ 클래슀λ₯Ό Animal 같은 concrete κΈ°λ³Έ 클래슀둜의 κ΅μ²΄λŠ” operator= 의 λ™μž‘μ„ 도 μ‰½κ²Œ μ΄ν•΄ν• μˆ˜ μžˆλŠ” μž₯점을 κ°€μ Έλ‹€ μ€λ‹€. λ˜ν•œ 당신이 배열을 λ‹€ν˜•ν•˜κ²Œ λ‹€λ£¨λŠ” 기회 μ—­μ‹œ 쀄여μ€λ‹€.(λ°°μ—΄κ³Ό ν΄λž˜μŠ€μ— λŒ€ν•œ κ΄€κ³„λŠ” Item 3을 μ°Έκ³ ν•˜λΌ.) κ·Έλ ‡μ§€λ§Œ, 기술적으둜 κ°€μž₯ λ‘λ“œλŸ¬μ§€λŠ” 이점은 λ””μžμΈ λ ˆλ²¨μ—μ„œ λ‚˜νƒ€λ‚œλ‹€. μ™œλƒν•˜λ©΄ 당신은 μœ μš©ν•œ μΆ”μƒμ˜ μ΄μ œλ₯Ό λͺ…μ‹œμ μœΌλ‘œ 인지 ν• μˆ˜ 있기 λ•Œλ¬Έμ΄λ‹€. 그것은 μœ μš©ν•œ κ°œλ…μ˜ μ΄μž¬λ₯Ό μ˜μ‹ν•˜μ§€ μ•Šμ„μ§€λΌλ„, λ‹Ήμ‹ μœΌλ‘œ ν•˜μ—¬κΈˆ μƒˆλ‘œμš΄ μœ μš©ν•œ κ°œλ…μ„ μœ„ν•œ 좔상 클래슀 μƒμ„±ν•˜κ²Œ ν•œλ‹€.

λ§Œμ•½ 당신이 C1,C2 λ‘κ°œμ˜ concrete 클래슀λ₯Ό κ°€μ§€κ³  있고, C2λŠ” C1을 public 상속 ν–ˆμ„λ•Œ 당신은 μ•„λ§ˆλ„ 두 클래슀의 관계λ₯Ό AλΌλŠ” μƒˆλ‘œμš΄ 클래슀λ₯Ό μƒμ„±ν•΄μ„œ, λ‹€μ‹œ ꡬ쑰λ₯Ό μž¬νŽΈν•˜λŠ” 과정을 뢀담없이 ν• μˆ˜ μžˆλ‹€.


μ΄λŸ¬ν•œ λ³€ν™˜ κ³Όμ •μ—μ„œ 처음의 값은 좔상 좔상 클래슀 A λ₯Ό ν™•μΈν•˜κ²Œ λ§Œλ“ λ‹€. C1κ³Ό C2λŠ” μ•„λ§ˆ 보톡 λͺ‡κ°€μ§€λ₯Ό κ°€μ§€κ³  μžˆλ‹€.:그것은 그듀이 public 상속이 λ˜λŠ” μ΄μœ μ΄λ‹€. 이 λ³€ν™˜μœΌλ‘œ 당신은 λ°˜λ“œμ‹œ κ·Έ κ°€μ§€κ³ μžˆλŠ” 어떻것을 확인해야 ν•œλ‹€. κ²Œλ‹€κ°€ C++μ—μ„œ 클래슀둜 λͺ¨ν˜Έν•œ 뢀뢄에 λŒ€ν•˜μ—¬ λͺ…ν™•ν•˜κ²Œ ν•΄μ£Όμ–΄μ•Ό ν•œλ‹€. 그것은 보톡 좔상화(abstraction)κ°€ 좔ꡬ해야 ν•˜λŠ” 것이고 잘 μ •μ˜λœ 멀버 ν•¨μˆ˜μ™€ ν™•μ‹€ν•œ λ¬Έλ²•μœΌλ‘œ κ΅¬ν˜„λœλ‹€.

이 λͺ¨λ“ κ²ƒμ΄ μ–΄λ–€ 잘λͺ»λœ μƒκ°μœΌλ‘œ μΈλ„ν•œλ‹€. κ²°κ΅­, λͺ¨λ“  ν΄λž˜μŠ€λŠ” μ–΄λ– ν•œ μ’…λ₯˜μ˜ 좔상화λ₯Ό ν‘œν˜„ν•œλ‹€. κ·Έλž˜μ„œ μš°λ¦¬λŠ” 계측 κ΄€κ³„μ—μ„œ λͺ¨λ“  κ°œλ…μ„ μœ„ν•΄μ„œ λ‘κ°€μ§€μ˜ 클래슀λ₯Ό μƒμ„±ν• μˆ˜κ°€ μ—†κ²Œ λ˜μ§€ μ•Šμ„κ°€? ν•˜λ‚˜λŠ” μΆ”μƒν™”λ‘œ(좔상화λ₯Ό ν‘œν˜„ν•˜λŠ” λΆ€λΆ„ μž‘μ„±) ν•˜λ‚˜λŠ” concrete둜(객체 생성 λΆ€λΆ„ μž‘μ„±)? μ•„λ‹ˆλ‹€. λ§Œμ•½ 당신이 κ·Έλ ‡κ²Œ ν•˜λ©΄ 당신은 ꡉμž₯히 λ§Žμ€ 클래슀둜 계측 관계λ₯Ό λ§Œλ“€ 것이닀. 그리고 μ»΄νŒŒμΌμ—λ„ λ§Žμ€ λΉ„μš©μ„ μ†Œμš”ν•œλ‹€. 그것은 객체 μ§€ν–₯ λ””μžμΈμ˜ 잘λͺ»λœ λͺ©ν‘œμ΄λ‹€.

κ·Έ λͺ©ν‘œλŠ” μœ μš©ν•œ 좔상화와 좔상화λ₯Ό 좔상 클래슀둜 μ΄μž¬ν•˜κ²Œ κ°•μ œν•΄ 버리 도둝 κ΅¬λΆ„ν•œλ‹€. κ·Έλ ‡μ§€λ§Œ 당신은 μ–΄λ–»κ²Œ μœ μš©ν•œ 좔상화λ₯Ό λΆ„κ°„ 할것인가? λˆ„κ°€ κ·Έ 좔상화가 λ―Έλž˜μ—λ„ μœ μš©ν•œμ§€ μ•Œλ €μ£ΌλŠ”κ°€? λˆ„κ°€ μ–΄λ””λ‘œ λΆ€ν„° μƒμ†λ˜λŠ”μ§€ μ˜ˆμƒν• μˆ˜ μžˆλŠ”κ°€?

자, λ‚˜λŠ” μ–΄λ–»κ²Œ λ―Έλž˜μ— 상속 관계에 λŒ€ν•œ μ‚¬μš©μ„ μ˜ˆμΈ‘ν• μˆ˜ μ—†λ‹€. κ·ΈλŸ¬λ‚˜ λ‚˜λŠ” 이거 ν•˜λ‚˜λŠ” μ•Œκ³  μžˆλ‹€.:ν•˜λ‚˜μ˜ λͺ©μ μ—μ„œ 좔상화에 λŒ€ν•œ ν•„μš”λŠ” λΉ„μŠ·ν•  κ²ƒμ΄λΌλŠ”κ²ƒ, κ·ΈλŸ¬λ‚˜ 더 λ§Žμ€ λͺ©μ μœΌλ‘œ 좔상화에 λŒ€ν•œ ν•„μš”μ„±μ€ 보톡 μ€‘μš”ν•˜λ‹€. 즉, μœ μš©ν•œ μΆ”μƒν™”λŠ” ν•˜λ‚˜ μ΄μƒμ˜ μš©λ„(λͺ©μ )μ—μ„œ ν•„μš”μ„±μ΄ μžˆλ‹€. 그것은 κ·Έλ ‡λ‚˜ 좔상화가 그듀에 λͺ©μ μ— λΆ€ν•©ν•˜λŠ” ν΄λž˜μŠ€μ™€ μ˜¬λ°”λ΄κ²Œ μ“°μΈλ‹€λŠ” 것과, μœ λ„λœ ν΄λž˜μŠ€μ—μ„œλ„ λ˜ν•œ μœ μš©ν•˜λ‹€λŠ” κ±Έ μ˜λ―Έν•œλ‹€. (μž‘μ„±μžμ£Ό:μ˜μ—­)

이것은 μ •ν™•ν•˜κ²Œ concrete κΈ°λ³Έ ν΄λž˜μŠ€κ°€ μœ μš©ν•œ 좔상 κΈ°λ³Έ 클래슀둜 λ³€ν™˜λ˜λŠ” μ΄μœ κ°€ λœλ‹€.:그것은 였직 μ΄μž¬ν•˜λŠ” concrete ν΄λž˜μŠ€κ°€ κΈ°λ³Έ 클래슀 κ°™μ„λ•Œ, λ‹€μ‹œ λ§ν•˜λ©΄ ν΄λž˜μŠ€κ°€ μƒˆλ‘œμš΄ λͺ©μ μœΌλ‘œ μž¬μ‚¬μš© λ λ•Œ, μƒˆλ‘œμš΄ 좔상 클래슀의 λ„μž…μ„ κ°•μš”ν•œλ‹€. κ·ΈλŸ¬ν•œ μΆ”μƒν™”λŠ” μœ μš©ν•˜λ‹€. μ™œλƒν•˜λ©΄ κ·Έλ“€ μžμ‹ μ΄ λ³΄μ΄λŠ” 것과 같이 κ΅¬ν˜„λ  ν•„μš”μ„±μ„ κ°€μ§€κ³  있기 λ•Œλ¬Έμ΄λ‹€.

μ²˜μŒμ— μš”κ΅¬λ˜λŠ” κ°œλ…μ€, μš°λ¦¬λŠ” 좔상 클래슀(κ°œλ…μ„ μœ„ν•œ)와 concrete 클래슀(객체가 κ°œλ…μ— λ°˜μ‘ν•˜κΈ° μœ„ν•œ) μ–‘μͺ½λ‹€ μ •λ‹Ήν™” μ‹œν‚¬μˆ˜ μ—†λ‹€. ν•˜μ§€λ§Œ λ‘λ²ˆμ§Έλ‘œ ν•„μš”ν•œ κ°œλ…μ€, μš°λ¦¬κ°€ 이 두 클래슀의 생성을 μ •λ‹Ήν™” ν• μˆ˜ μžˆλ‹€. λ‚΄κ°€ κ°„λ‹¨ν•˜κ²Œ μ–ΈκΈ‰ν•œ λ³€ν™˜μ€ μ΄λŸ¬ν•œ κ³Όμ •(process)λ₯Ό 곡정화(mechanize) ν•˜λŠ” 것이닀. 그리고 비둝 λ””μžμ΄λ„ˆμ™€ ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ΄ μœ μš©ν•œ κ°œλ…μ„ 항상 μ˜μ‹μ„ κ°€μ§€κ³  μƒκ°ν•˜μ§€ μ•Šμ„μ§€λΌλ„, κ·Έλ“€μ—κ²Œ μƒκ°ν•˜λŠ” μœ μš©ν•œ 좔상화 과정을 λͺ…μ‹œμ μœΌλ‘œ 보이도둝 κ°•μ œν•œλ‹€.

λ―ΏμŒμ§ν•œ 예제λ₯Ό 생각해 보자. 당신이 λ„€νŠΈμ› μƒμ—μ„œ μ–΄λ–€ ν”„λ‘œν† μ½œμ„ μ΄μš©ν•΄μ„œ 정보λ₯Ό νŒ¨ν‚· λ‹¨μœ„λ‘œ λ‚˜λˆ„μ–΄ 컴퓨터 사이에 μ΄λ™μ‹œν‚€λŠ” μ–΄ν”Œλ¦¬μΌ€μ΄μ…˜μ„ μž‘μ„±ν•œλ‹€κ³  ν•˜μž.(λͺ¨ν˜Έ κ·Έλž˜μ„œ μƒλž΅:by breaking it into packets) packet을 ν‘œν˜„ν•˜λŠ” ν΄λž˜μŠ€λ‚˜ ν΄λž˜μŠ€λ“€μ— κ΄€ν•˜μ—¬ 생각해야 할것이닀. κ·ΈλŸ¬ν•œ ν΄λž˜μŠ€λ“€μ€ 이 μ–΄ν”Œλ¦¬μΌ€μ΄μ…˜μ„ λŒ€ν•˜μ—¬ μž˜μ•Œκ³  μžˆμ–΄μ•Ό ν•œλ‹€κ³  μ „μ œ 할것이닀.

일단, 였직 ν•œμ’…λ₯˜μ˜ ν”„λ‘œν† μ½œμ„ ν†΅ν•˜μ—¬ 였직 ν•œμ’…λ₯˜μ˜ νŒ¨ν‚·λ§Œμ„ μ „μ†‘ν•œλ‹€κ³  κ°€μ •ν•˜μž. μ•„λ§ˆλ„ λ‹€λ₯Έ ν”„λ‘œν† μ½œκ³Ό νŒ¨ν‚·μ˜ μ΄μž¬λ₯Ό μ•Œκ³  μžˆμ„ 것이닀. κ·Έλ ‡μ§€λ§Œ 당신은 그듀을 μ§€μ›ν•˜μ§€ μ•Šκ³ , λ―Έλž˜μ—λ„ 이듀을 지원할 κ³„νšμ΄ 없을 것이닀. 당신은 νŒ¨ν‚·μ— λŒ€ν•œ 좔상 클래슀(νŒ¨ν‚·μ„ ν‘œν˜„ν•˜λŠ” κ°œλ…μ„ μœ„ν•œ)λ₯Ό μ‚¬μš©ν•  νŒ¨ν‚·μ˜ concrete ν΄λž˜μŠ€μ™€ 같이 λ§Œλ“€κ²ƒμΈκ°€? λ§Œμ•½ κ·Έλ ‡κ²Œ ν•œλ‹€λ©΄ 당신이 νŒ¨ν‚·μ˜ κΈ°λ³Έ 클래슀의 λ³€ν™” 없이 차후에 μƒˆλ‘œμš΄ νŒ¨ν‚· ν˜•νƒœλ₯Ό μΆ”κ°€ν•˜λŠ” 것을 λ°”λž„μˆ˜ μžˆλ‹€. 그것은 μƒˆλ‘œμš΄ ν˜•νƒœμ˜ νŒ¨ν‚·μ΄ μΆ”κ°€λ κ²½μš° νŒ¨ν‚·κ³Ό κ΄€λ ¨ν•˜μ—¬ μž¬μ»΄νŒŒμΌν•  수고λ₯Ό λœμ–΄ 쀄것이닀. κ·Έλ ‡μ§€λ§Œ 그런 λ””μžμΈμ€ λ‘κ°œμ˜ 클래슀λ₯Ό μš”κ΅¬ν•œλ‹€. 그리고 μ§€κΈˆ λ‹Ήμ‹ μ—κ²ŒλŠ” ν•˜λ‚˜λ§Œμ΄ ν•„μš”ν•˜λ‹€.(당신이 μ‚¬μš©ν•˜λŠ” νŒ¨ν‚·λ§Œμ„ ν‘œν˜„ν•˜λŠ” 클래슀) 없을지도 λͺ¨λ΄λŠ” 미래λ₯Ό μœ„ν•œ ν™•μž₯을 μœ„ν•΄μ„œ λ‹Ήμ‹ μ˜ λ””μžμΈμ„ λ³΅μž‘ν•˜κ²Œ ν•˜λŠ” 것을 ν•΄μ•Ό ν• κΉŒ?

μ—¬κΈ°μ—λŠ” μ •ν™•ν•œ 닡을 λ‚΄λ¦΄μˆ˜ μ—†λ‹€. κ·Έλ ‡μ§€λ§Œ κ²½ν—˜μƒμœΌλ‘œ 그것은 μš°λ¦¬κ°€ μ™„μ „νžˆ μ΄ν•΄ν•˜κΈ° νž˜λ“  κ°œλ…μ„ 잘 κ΅¬ν˜„ν•œ ν›Œλ₯­ν•œ 클래슀의 λ””μžμΈμ—λŠ” κ²°μ½” κ°€κΉŒμ›Œ 질수 없을 κ²ƒμœΌλ‘œ 보인닀. λ§Œμ•½ 당신이 νŒ¨ν‚·μ„ μœ„ν•΄μ„œ 좔상 클래슀λ₯Ό λ§Œλ“€μ—ˆλ‹€λ©΄, 였직 단일 νŒ¨ν‚· ν˜•νƒœλ‘œ μ œν•œν•˜λŠ” λ””μžμΈ 이후에 μ–΄λ–»κ²Œ μ˜³λ°”λ₯Έ λ””μžμΈμ„ ν• μˆ˜ μžˆκ² λŠ”κ°€? κΈ°μ–΅ν•΄ 봐라, λ§Œμ•½ 당신이 좔상 클래슀둜 λ””μžμΈν•΄μ„œ λ―Έλž˜μ— 이λ₯Ό μƒμ†ν•œ ν΄λž˜μŠ€λ“€λ‘œ λ””μžμΈμƒ 별 λ³€ν™” 없이 μ œμž‘λ μˆ˜ μžˆλ‹€λŠ” λ©΄, 이런 좔상 ν΄λž˜μŠ€κ°€ μ£ΌλŠ” μž₯점을 μ–»λŠ”λ‹€. (λ§Œμ•½ λ³€ν™”κ°€ ν•„μš”ν•˜λ‹€λ©΄ λͺ¨λ“  ν΄λΌμ΄μ–ΈνŠΈμ—κ²Œ 재 μ»΄νŒŒμΌμ„ μš”κ΅¬ν•΄μ•Ό ν•œλ‹€. 그리고 아무것도 μ–»μ§€ λͺ»ν•œλ‹€.)

당신이 ν•˜λ €λŠ” ν›Œλ₯­ν•œ 좔상 νŒ¨ν‚· 클래슀 λ””μžμΈμ€ 당신이 λ‹€μ–‘ν•œ λͺ©μ μ— μˆ˜λ§Žμ€ λ‹€λ₯Έ νŒ¨ν‚·μ„ ν›Œλ₯­ν•˜κ²Œ λ§Œλ“€μ–΄ 보지 μ•Šκ³ μ„œλŠ” ν• μˆ˜ μ—†λ‹€. 이번 κ²½μš°μ—μ„œ 이런 μ œν•œλœ κ²½ν—˜μ„ μ œμ‹œν•˜λŠ” 것은 λ‚˜μ˜ μΆ©κ³ κ°€ νŒ¨ν‚·μ— λŒ€ν•œ μ •μ˜κ°€ μ•„λ‹ˆλΌ, μΆ”ν›„ 였직 concrete νŒ¨ν‚· 클래슀둜 λΆ€ν„° μƒμ†μ˜ ν•„μš”μ„±μ΄ μžˆμ„λ•Œμ—, νŒ¨ν‚·μ˜ μΆ”κ°€λ₯Ό μš©μ΄ν•˜κ²Œ ν•˜κΈ° μœ„ν•œ 것이닀.

λ‚΄κ°€ 여기에 μ œμ‹œν•œ λ³€ν™˜μ€ 좔상 클래슀의 ν•„μš”μ„±μ„ ν™•μΈν•˜κΈ° μœ„ν•œ ν•˜λ‚˜μ˜ 방법이지 μœ μΌν•œ 방법은 μ•„λ‹ˆλ‹€. 좔상 클래슀의 지원이 μš”κ΅¬λ˜λŠ” μˆ˜λ§Žμ€ κ²½μš°λ“€μ΄ μžˆλ‹€.;객체 μ§€ν–₯에 뢄석은 책듀을 λ§Œλ“€ 만큼 λ‹€μ–‘ν•˜λ‹€. 좔상 ν΄λž˜μŠ€μ— κ΄€ν•œ μ†Œκ°œλŠ” 이 경우 만이 μ•„λ‹ˆλΌ μžμ‹  슀슀둜 λ‹€λ₯Έ concrete ν΄λž˜μŠ€μ— λŒ€ν•œ 상속 관계λ₯Ό μ„€κ³„ν•˜λ©΄μ„œ 깨달아라. κ·Έλ ‡μ§€λ§Œ, 보톡 λ‘κ°œμ˜ concrete 클래슀 public μƒμ†μœΌλ‘œ μ—°κ²° μ§€μ–΄ λ†“λŠ”κ²ƒμ€ μƒˆλ‘œμš΄ 좔상 클래슀의 ν•„μš”μ„±μ„ μ˜λ―Έν•œλ‹€.

μ’…μ’… λ‹€μŒμ˜ 문제둜, 심사 μˆ™κ³ ν•΄μ„œ λ§Œλ“€μ–΄λ…Ό ν‰ν™”λ‘œμš΄ 이둠을 κ°€ν˜Ήν•œ ν˜„μ‹€μ΄ λ§μΉœλ‹€. μ„œλ“œ νŒŒν‹° C++ λΌμ΄λΈŒλŸ¬λ¦¬λŠ” ν­νŒ”μ μœΌλ‘œ μ¦κ°€ν•˜κ³ , 당신은 μ½μ„μˆ˜ 밖에 μ—†λŠ” 라이브러리 μƒμ˜ concrete클래슀둜 λΆ€ν„° 상속받은 concrete 클래슀의 생성을 μ›ν• λ•Œ μ–΄λ–»κ²Œ 할것인가?

당신은 μƒˆλ‘œμš΄ 좔상 클래슀λ₯Ό λ„£κΈ°μœ„ν•΄, 라이브러리λ₯Ό μˆ˜μ •ν• μˆ˜ μ—†λ‹€. κ·Έλž˜μ„œ λ‹Ήμ‹ μ˜ 선택은 μ œν•œκ³Ό λ³„λ‘œ λ§€λ ₯적이지 μ•ŠλŠ” 방법일 것이닀.

  • λ‹Ήμ‹ μ˜ concrete 클래슀λ₯Ό μ΄μž¬ν•˜κ³  μžˆλŠ” concrete 클래슀둜 λΆ€ν„° μœ λ„ν•˜λΌ 그리고 할당에 κ΄€λ ¨ν•œ(assignment-related) λ¬Έμ œλ“€μΈ, 이 Item의 μ‹œμž‘ 뢀뢄에 λŒ€ν•˜μ—¬ μ‹œν—˜ν•΄ 봐라. λ˜ν•œ Item 3에 μ–ΈκΈ‰λœ 배열에 κ΄€ν•œ λ¬Έμ œκ°€ μžˆλŠ”μ§€λ„ 점검해 λ΄μ•Όλ§Œ ν•œλ‹€.
  • 당신이 ν•„μš”λ‘œ ν•˜λŠ” 것에 κ°€μž₯ κ°€κΉŒμš΄ 좔상 클래슀λ₯Ό 상속 계측 높은 λΆ€λΆ„μ—μ„œ 찾아봐라, 그리고 λ‚˜μ„œ κ·Έ ν΄λž˜μŠ€μ—μ„œ μƒμ†ν•˜λΌ. λ¬Όλ‘  μ •ν™•ν•˜μ§€ μ•Šμ€ 클래슀 일지도 λͺ¨λ₯Έλ‹€. 그렇더라도, μ•„λ§ˆ 당신은 ν™•μž₯ν•˜κ³ μž ν•˜λŠ” κΈ°λŠ₯을 κ°€μ§€λŠ” concrete 클래슀의 κ΅¬ν˜„μ˜ λ…Έλ ₯ ν•΄μ•Ό 할것이닀.
  • λ‹Ήμ‹ μ˜ μƒˆλ‘œμš΄ 클래슀λ₯Ό 당신이 상속 λ°›κ³ μž ν•˜λŠ”κ²ƒκ³Ό λΉ„μŠ·ν•œ 클래슀 라이브리의 ν•œλΆ€λΆ„μ— κ΅¬ν˜„ν•΄λΌ. 예λ₯Ό λ“€μ–΄μ„œ 당신이 데이터 λ©€λ²„λ‘œμ„œ 라이브러리 클래슀의 객체λ₯Ό κ°€μ§€κ³  μ‹Άμ„λ•Œ, λ‹Ήμ‹ μ˜ μƒˆλ‘œμš΄ ν΄λž˜μŠ€μ— 라이브러리 클래슀의 μΈν„°νŽ˜μ΄μŠ€λ₯Ό μž¬μ •μ˜ 해라.
    ~cpp 
    class Window {              // 이것은 클래슀 라이브러리
    public:
        virtual void resize(int newWidth, int newHeight);
        virtual void repaint() const;
    
        int width() const;
        int height() const;
    };
    
    class SpecialWindow {       // 이것은 Window둜 λΆ€ν„° μƒμ†λ˜κΈ° μ›ν•˜λŠ” 클래슀
    public:
        ...
    
        // λΉ„ 가상 ν•¨μˆ˜λŠ” λ„˜κΈ°λŠ” κ²ƒμœΌλ‘œ κ΅¬ν˜„ν•œλ‹€.
        int width() const { return w.width(); }
        int height() const { return w.height(); }
    
        // "상속 받은" 가상 ν•¨μˆ˜μ˜ μƒˆλ‘œμš΄ κ΅¬ν˜„
        virtual void resize(int newWidth, int newHeight);
        virtual void repaint() const;
    
    private:
        Window w;
    };
    
    μ΄λŸ¬ν•œ μ „λž΅μ€ 당신이 의μ΄ν•˜κ³  μžˆλŠ” 라이브러리 λ²€λ”μ˜ ν΄λž˜μŠ€κ°€ μ—…λ°μ΄νŠΈ λ λ•Œ λ§ˆλ‹€ λ‹Ήμ‹ μ˜ 클래슀λ₯Ό μ—…λ°μ΄νŠΈλ₯Ό ν•  μ€λΉ„κ°€ λ˜μ–΄ μžˆλŠ”κ±Έ μš”κ΅¬ν•œλ‹€. λ˜ν•œ 라이브러리 ν΄λž˜μŠ€μƒμ—μ„œ 가상 ν•¨μˆ˜μ˜ μž¬μ •μ˜ λŠ₯λ ₯을 제거λ₯Ό μš”κ΅¬ν•˜κΈ°λ„ ν•œλ‹€. μ™œλƒν•˜λ©΄ 당신은 상속 λ°›κΈ° μ „κΉŒμ§€ 가상 ν•¨μˆ˜λ₯Ό μž¬μ •μ˜ ν• μˆ˜κ°€ μ—†λ‹€.

  • 당신이 κ°€μ§„ 것을 μ΄μš©ν•΄ λ§Œλ“€μ–΄λΌ. λΌμ΄λΈŒλŸ¬λ¦¬μ—μ„œ concrete 클래슀의 μ‚¬μš©ν•˜κ³ , λ‹Ήμ‹ μ˜ μ†Œν”„νŠΈμ›¨μ–΄μ—μ„œ μˆ˜μ •ν•˜λΌ 그러면 , κ·Έ ν΄λž˜μŠ€λŠ” μΆ©λΆ„ν•˜λ‹€. 당신이 ν΄λž˜μŠ€μ— λ”ν•˜κ³ μž ν•˜λŠ” κΈ°λŠ₯을 μ œκ³΅ν•˜λŠ” non-member ν•¨μˆ˜λ₯Ό μž‘μ„±ν•˜λΌ. ν•˜μ§€λ§Œ ν• μˆ˜ μ—†λ‹€. 그와 같이 ν•˜λ©΄ μ†Œν”„νŠΈμ›¨μ–΄μ˜ κ²°κ³ΌλŠ” λͺ…λ£Œν•˜μ§€ λͺ»ν•˜κ³ , νš¨μœ¨μ μ΄μ§€ λͺ»ν•˜κ³ , μœ μ§€ λ³΄μŠ€ν•˜κΈ° νž˜λ“€κ³ , ν™•μž₯ν•˜κΈ° νž˜λ“€λ‹€. ν•˜μ§€λ§Œ μ΅œμ†Œν•œ 그런 일을 ν• μˆ˜ 있게 ν•˜λΌ.

μ΄λŸ¬ν•œ 선택은 νŠΉλ³„νžˆ λ§€λ ₯μ μ΄μ§€λŠ” μ•Šλ‹€ μ™œλƒν•˜λ©΄ 당신은 μ–΄λ–€ 곡학적 νŒλ‹¨μ— μ μš©ν•΄μ•Ό ν•˜κ³ , μ΅œλŒ€ν•œ λͺ¨ν˜Έν•˜μ§€ μ•Šλ„λ‘ ν•˜λŠ” 독을 선택해야 ν•œλ‹€. 그리 μž¬λ―ΈμžˆλŠ”κ±΄ μ•„λ‹ˆλ‹€. κ·ΈλŸ¬λ‚˜ 삢은 λ•Œλ‘œ 그와 κ°™λ‹€. 미래의 λ‹Ήμ‹  μžμ‹ μ„ μœ„ν•΄μ„œ 더 μ‰½κ²Œ λ§Œλ“€μ–΄λΌ, 당신이 μ›ν•˜λŠ” λ””μžμΈμ˜ 라이브러리의 λ²€λ”λ“€μ—κ²Œ λΆˆν‰ν•΄λΌ.


아직 일반적인 κ·œμΉ™μ΄ 남아 μžˆλ‹€.:non-leaf ν΄λž˜μŠ€κ°€ 좔상화 λ˜μ–΄μ•Ό ν•œλ‹€. 당신은 μ•„λ§ˆλ„ μ™ΈλΆ€μ˜ 라이브러리λ₯Ό μ‚¬μš©ν• λ•Œ, λ¬Άμ–΄ μ€„λ§Œν•œ κ·œμΉ™μ΄ ν•„μš”ν•  것이닀. ν•˜μ§€λ§Œ μš°λ¦¬κ°€ 닀루어야 ν•˜λŠ” μ½”λ“œμ—μ„œ, μ™ΈλΆ€ λΌμ΄λΈŒλŸ¬λ¦¬μ™€ κ°€κΉŒμ›Œ μ§„λ‹€λŠ” 것은 μ‹ λ’°μ„±, 내ꡬ성, 이해λ ₯, ν™•μž₯μ„±μ—μ„œ 것과 λ–¨μ–΄μ§€λŠ” 것을 μ•ΌκΈ°ν•œλ‹€.

3. Item 34: Understand how to combine C++ and C in the same program

  • Item 34: 같은 ν”„λ‘œκ·Έλž¨μ—μ„œ C++와 Cλ₯Ό ν˜Όν•©ν•˜λŠ” 법 이해해라.

λ§Žμ€ λ©΄μ—μ„œ, C++와 Cμ—μ„œ μ»΄ν¬λ„ŒνŠΈλ₯Ό λ§Œλ“€λ•Œ, λ„€κ°€ ν•˜λŠ” 걱정은 C μ»΄νŒŒμΌλŸ¬κ°€ 였브젝트 νŒŒμΌμ„ μ„œνˆ¬λ΄κ²Œ 처리 ν• λ•Œμ˜ κ±±μ •κ³Ό κ°™λ‹€. λ‹€λ₯Έ μ»΄νŒŒμΌλŸ¬λ“€μ΄ κ΅¬ν˜„μ— 의μ΄μ μΈ μš”μ†Œλ“€μ— λŒ€ν•˜μ—¬ λ™μΌν•˜μ§€ μ•ŠμœΌλ©΄, 그런 νŒŒμΌλ“€μ„ ν˜Όν•©ν•΄μ„œ μ“Έ 방법이 μ—†λ‹€. (κ΅¬ν˜„ μ˜μ΄ μš”μ†Œ:int, double의 크기, 인자λ₯Ό λ„˜κΈ°κ³  λ°›λŠ” 방법, ν˜ΈμΆœμžμ™€ ν˜ΈμΆœκ°„μ— 톡신 ) μ΄λŸ¬ν•œ 개발 ν™˜κ²½μ—μ„œ μ»΄νŒŒμΌλŸ¬λ“€μ„ μ„žμ–΄μ„œ μ‚¬μš©ν•˜λŠ” 것에(mixed-compiler) κ΄€ν•œ μ‹€μ§ˆμ μ€ 관점은 μ–Έμ–΄μ˜ ν‘œμ€μ— λŒ€ν•œ λ…Έλ ₯에 μ˜ν•΄μ„œ μ•„λ§ˆ μ™„μ „νžˆ λ¬΄μ‹œ λœλ‹€. κ·Έλž˜μ„œ 컴파일러 A와 컴파일러 B의 였브젝트 νŒŒμΌμ„ μ•ˆμ „ν•˜κ²Œ μ„žμ–΄μ„œ μ“Έμˆ˜ μžˆλŠ” μ‹ λ’°μ„± μžˆλŠ” μœ μΌν•œ 방법은, 컴파일러 A,B의 벀더듀이 κ·Έλ“€μ˜ μ•Œλ§žλŠ” output에 λŒ€ν•œ product의 정보λ₯Ό ν™•μ‹€νžˆ μ•„λŠ” 것이닀. 이것은 C++와 Cλ₯Ό μ΄μš©ν•˜λŠ” ν”„λ‘œκ·Έλž¨, 그런 λͺ¨λ“  ν”„λ‘œκ·Έλž¨μ— λŒ€ν•˜μ—¬ 사싀이닀. κ·Έλž˜μ„œ 당신이 C++κ³Ό Cλ₯Ό 같은 ν”„λ‘œκ·Έλž¨μ—μ„œ μ„žμ–΄μ„œ μ“°κΈ° μ „μ—λŠ” C++와 Cμ»΄νŒŒμΌλŸ¬κ°€ μ•Œλ§žλŠ” 였브젝트 νŒŒμΌμ„ λ§Œλ“€μ–΄ λ‚΄μ•Όλ§Œ ν•œλ‹€.

μ—¬κΈ°μ—μ„œ μš°λ¦¬κ°€ 생각해볼 관점은 총 λ„€κ°€μ§€κ°€ ν•„μš”ν•˜λ‹€.:name mangling, initialization of statics, dynamic memory allocation, and data structure compatibility.

3.1. Name mangling : 이름 μ‘°μ •

당신도 μ•Œλ‹€ μ‹œν”Ό, name mangling(이름 μ‘°μ •:이후 name mangling둜 씀) λ‹Ήμ‹ μ˜ C++ μ»΄νŒŒμΌλŸ¬κ°€ λ‹Ήμ‹ μ˜ ν”„λ‘œκ·Έλž¨μƒμ—μ„œ 각 ν•¨μˆ˜μ— μœ μΌν•œ 이름을 λΆ€μ—¬ν•˜λŠ” μž‘μ—…μ΄λ‹€. Cμ—μ„œ μ΄λŸ¬ν•œ μž‘μ—…μ€ ν•„μš”κ°€ μ—†μ—ˆλ‹€. μ™œλƒν•˜λ©΄, 당신은 ν•¨μˆ˜ 이름을 μ˜€λ²„λ‘œλ“œ(overload)ν• μˆ˜κ°€ μ—†μ—ˆκΈ° λ•Œλ¬Έμ΄λ‹€. κ·Έλ ‡μ§€λ§Œ C++ ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ€ μ΅œμ†Œν•œ λͺ‡κ°œ ν•¨μˆ˜μ— 같은 이름을 μ“΄λ‹€.(예λ₯Όλ“€μ–΄μ„œ, iostream 라이브러리λ₯Ό μƒκ°ν•΄λ³΄μž. μ—¬κΈ°μ—λŠ” λͺ‡κ°€μ§€ λ²„μ „μ΄λ‚˜ operator<< 와 operator>>κ°€ μžˆλ‹€. ) μ˜€λ²„λ‘œλ”©(overloading)은 λŒ€λΆ€λΆ„μ˜ 링μ»λ“€μ—κ²Œ λΆˆνŽΈν•œ μ΄μž¬μ΄λ‹€. μ™œλƒν•˜λ©΄ 링μ»λ“€μ€ 일반적으둜 같은 μ΄λ¦„μœΌλ‘œ 된 λ‹€μ–‘ν•œ ν•¨μˆ˜λ“€μ— λŒ€ν•˜μ—¬ μ–΄λ‘μš΄ μ‹œκ°μ„ κ°€μ§„λ‹€. name magling은 링μ»λ“€μ˜ μ§„μ‹€μ„±μ˜ μŠΉμΈμ΄λ‹€.;νŠΉλ³„νžˆ 링μ»λ“€μ΄ 보톡 λͺ¨λ“  ν•¨μˆ˜ 이름에 λŒ€ν•˜μ—¬ μœ μΌν•˜λ‹€λŠ” 사싀에 λŒ€ν•˜μ—¬

C++의 ν…Œνˆ¬λ¦¬μ— 머물러 μžˆλ‹€λ©΄, name mangling은 λ‹Ήμ‹ κ³Ό 그리 관계 μžˆλŠ” 것 κ°™μ§€ μ•Šλ‹€. λ§Œμ•½ 당신이 μ»΄νŒŒμΌλŸ¬κ°€ xyzzy라고 maglingν•œ drawLineμ΄λΌλŠ” ν•¨μˆ˜λ₯Ό κ°€μ§€κ³  μžˆλ‹€λ©΄ 당신은 항상 drawLine이라고 μ‚¬μš©ν•˜κ³ , 였브젝트 νŒŒμΌμ—μ„œ xyzzy라고 κ΅μ²΄λ˜μ–΄ μ“°λŠ”κ²ƒμ—λŠ” 주의λ₯Ό 기울일 ν•„μš”κ°€ μ—†λ‹€.

ν•˜μ§€λ§Œ C λΌμ΄λΈŒλŸ¬λ¦¬μ—μ„œ drawLine이라면 이야기가 달라진닀. 그런 κ²½μš°μ— λ‹Ήμ‹ μ˜ C++μ†ŒμŠ€ νŒŒμΌμ€ μ•„λ§ˆλ„ 이것과 같이 μ„ μ–Έλœ 헀더 νŒŒμΌμ„ κ°€μ Έμ•Ό 할것이닀.

~cpp 
    void drawLine(int x1, int y1, int x2, int y2);
그리고 λ‹Ήμ‹ μ˜ μ½”λ“œλŠ” 일반적으둜 μ‚¬μš©ν•˜λŠ” κ²ƒμ²˜λŸΌ drawLine을 ν˜ΈμΆœν•˜λŠ” μ½”λ“€λ΄ κ°€μ§„λ‹€. κ·ΈλŸ¬ν•œ 각 ν˜ΈμΆœλ§ˆλ‹€ λ‹Ήμ‹ μ˜ μ»΄νŒŒμΌλŸ¬κ°€ mangle을 ν•œ ν•¨μˆ˜ 이름을 호좜 뢀뢄에 λ„£λŠ”λ‹€. κ·Έλž˜μ„œ 이둠 μ½”λ“œλ₯Ό μ“°λ©΄,

~cpp 
drawLine(a, b, c, b);  // mangle μ²˜λ¦¬κ°€ μ•ˆλœ μƒνƒœ
λ‹Ήμ‹ μ˜ 였브젝트 νŒŒμΌμ€ λ‹€μŒκ³Ό 같은 λͺ¨μŠ΅μ˜ ν•¨μˆ˜ ν˜ΈμΆœμ„ κ°€μ§„λ‹€.

~cpp 
xyzzy(a, b, c, d);  // mangleν•œ ν›„μ˜ ν•¨μˆ˜ 이름
κ·Έλ ‡μ§€λ§Œ λ§Œμ•½ drawLineκ°€ Cν•¨μˆ˜λΌλ©΄, drawLine ν•¨μˆ˜λ₯Ό ν˜ΈμΆœν• λ•Œ drawLine으둜 ν¬ν•¨ν•˜λŠ” 컴파일러된 λ²„μ „μœΌλ‘œ 였브젝트( ν˜Ήμ€ 동적 링크 라이브러리 λ“±) νŒŒμΌμ— ν¬ν•¨λ˜μ–΄ μžˆλ‹€.;name mangle이 λ˜μ§€ μ•Šμ€ 체둜 λ˜μ–΄ μžˆλ‹€. 당신이 이 λ‘˜μ„ λͺ¨λ‘ μ„žμ–΄μ„œ ν”„λ‘œκ·Έλž¨ ν•˜λ €κ³  λ…Έλ ₯ν•˜λ©΄, μ—λŸ¬κ°€ 날것이닀. μ™œλƒν•˜λ©΄ 링μ»λŠ” xyzzy의 ν˜ΈμΆœλ˜λŠ” ν•¨μˆ˜λ₯Ό μ°Ύκ³ , 그에 κ΄€ν•œ ν•¨μˆ˜κ°€ μ—†κΈ° λ•Œλ¬Έμ΄λ‹€.

이런 문제λ₯Ό ν•΄κ²°ν•˜κΈ° μœ„ν•˜μ—¬, C++ μ»΄νŒŒμΌλŸ¬μ—κ²Œ ν•΄λ‹Ή ν•¨μˆ˜μ— name mangle을 μˆ˜ν–‰ν•˜μ§€ μ•Šλ„λ‘ μ•Œλ €μ•Ό ν•  방법이 ν•„μš”ν•˜λ‹€. Cλ“ , assempler, FORTRAN, Lisp, Forthλ‚˜ λ‹ˆκ°€ κ°€μ§„ 무슨 언어간에, λ‹€λ₯Έ μ–Έμ–΄μ—μ„œ μž‘μ„±λ˜μ–΄μ§„ name mangle 처리된 ν•¨μˆ˜λ₯Ό μ›ν• μˆ˜ μ—†λ‹€.(예, 이 언어듀에 COBOL도 λ“€μ–΄κ°€κ² μ§€λ§Œ 당신이 μ“°λŠ”κ°€?) 결곑, λ§Œμ•½ Cν•¨μˆ˜μΈ drawLine을 ν˜ΈμΆœν•˜λ©΄ 그것은 μ§„μ§œλ‘œ drawLine을 ν˜ΈμΆœν•˜κ³ , λ‹Ήμ‹ μ˜ 였브젝트 μ½”λ“œμ—­μ‹œ κ·Έ 이름 κ·ΈλŒ€λ‘œ 변화없이 μ‚¬μš©ν•œλ‹€.

μ΄λŸ¬ν•œ name mangle을 막기 μœ„ν•˜μ—¬, C++의 μ—μ„œλŠ” extern "C"λ₯Ό 직접 μ‚¬μš©ν•œλ‹€.

~cpp 
// name mangleν•˜μ§€ μ•ŠλŠ” 처리
extern "C"
void drawLine(int x1, int y1, int x2, int y2);
extern "C" extern "Pascal", extern "FORTRAN"

extern "C"λ₯Ό μ“°λŠ”κ²ƒμ„ λ‹Ήμ—°μ‹œ μƒκ°ν•˜λŠ” 함정에 λΉ μ§€μ§€ 마라, extern "Pascal" μ΄λ‚˜ extern "FROTRAN" 만이 μ“°μ΄λŠ” κ²½μš°λ„ μžˆλ‹€.ν•˜μ§€λ§Œ μ΅œμ†Œν•œ ν‘œμ€μ€ μ•„λ‹ˆλ‹€. κ°€μž₯ 쒋은 방법인 extern "C"λŠ” Cμ—μ„œ μž‘μ„±λœ ν•¨μˆ˜λ“€κ³Ό 관계 μžˆλ‹€λŠ” 것을 ν™•μ‹ ν•˜λŠ”κ±΄ μ•„λ‹ˆμ§€λ§Œ, λ§Œμ•½ Cμ—μ„œ μž‘μ„±λœ κ²ƒμ²˜λŸΌ ν•΄λ‹Ή ν•¨μˆ˜λ₯Ό ν˜ΈμΆœν•  수 μžˆλ‹€λŠ” μ˜λ―Έμ΄λ‹€. (기술적으둜 extern "C" λŠ” Cμ™€μ˜ 연결을 κ°€μ§„ ν•¨μˆ˜λ₯Ό μ˜λ―Έν•˜μ§€λ§Œ, κΌ­ κ·ΈλŸ°κ²ƒ λ§Œμ€ μ•„λ‹ˆλ‹€. κ·Έλ ‡μ§€λ§Œ name mangle을 λ°©μ§€ ν•œλ‹€λŠ” 것 λ§Œμ€ ν™•μ‹€ν•˜λ‹€.)

예λ₯Όλ“€μ–΄μ„œ λ§Œμ•½ 당신은 λ„ˆλ¬΄λ‚˜ λΆˆν–‰ν•˜κ²Œλ„ μ–΄μ…ˆλΈ”λŸ¬μ—μ„œ μž‘μ„±ν•œ ν•¨μˆ˜μ™€ 같은 경우라면 당신은 μ—­μ‹œ extern "C" λ₯Ό μ„ μ–Έν• μˆ˜ μžˆλ‹€.:

~cpp 
// 이 ν•¨μˆ˜λŠ” μ–΄μ…ˆλΈ”λŸ¬μ— μžˆλ‹€. ν•¨μˆ˜λ₯Ό name mangleν•˜μ§€ μ•ŠλŠ”λ‹€.
extern "C" void twiddleBit(unsigned char bits);

당신은 C++의 ν•¨μˆ˜λ₯Ό μ„ μ–Έν• λ•Œμ‘°μ°¨ extern "C"λ₯Ό μ‚¬μš©ν• μˆ˜ μžˆλ‹€. 이것은 C++μ—μ„œ 라이브러리λ₯Ό μž‘μ„±ν• λ•Œ λ‹€λ₯Έ ν”„λ‘œκ·Έλž˜λ° 언어듀에 λŒ€ν•œ 지원을 ν•˜κ³  μ‹Άμ„λ•Œ μœ μš©ν•˜λ‹€. C++ν•¨μˆ˜μ— λŒ€ν•˜μ—¬ name mangle을 κΈˆμ§€ν•΄μ„œ λ‹Ήμ‹ μ˜ ν΄λΌμ΄μ–ΈνŠΈλ“€μ΄ 당신이 mangle을 μ μš©ν•œ ν•¨μˆ˜ λŒ€μ‹ μ—, μžμ—°μŠ€λŸ½κ²Œ λͺ…μ‹œμ μœΌλ‘œ μ‚¬μš©ν• μˆ˜ μžˆλ‹€.

~cpp 
// C++ 을 λ”°λ΄λŠ” ν•¨μˆ˜λŠ” C++의 μ™ΈλΆ€μ—μ„œ 쓰이도둝 μ„€κ³„λ˜μ—ˆλ‹€.
extern "C" void simulate (int iterations);
μ’…μ’… 당신은 name mangleλ₯Ό μ›ν•˜μ§€ μ•Šμ€ ν•¨μˆ˜λ₯Ό 많이 κ°€μ§€κ³  μžˆμ„ 것인데, 이 λͺ¨λ“ κ²ƒ μ•žμ— λͺ¨λ‘ extern "C" λ₯Ό λΆ™μ΄κΈ°μ—λŠ” κ·€μ°λ‹€. λ‹€ν–‰μŠ€λŸ½κ²Œλ„ 이에 λŒ€ν•œ 지원 μ—­μ‹œ λ‹€μŒκ³Ό 같은 λͺ¨μŠ΅μœΌλ‘œ ν‘œν˜„ν• μˆ˜ μžˆλ‹€.

~cpp 
extern "C" {    // 이 μ˜μ—­μ˜ ν•¨μˆ˜λŠ” λͺ¨λ‘ name mangleκ°€ μ μš©λ˜μ§€ μ•ŠλŠ”λ‹€.
    void drawLine(int x1, int y1, int x2, int y2);
    void twiddleBits(unsigned char bits);
    void simulate(int iterations);
  ...
}
extern "C"의 μ΄λŸ¬ν•œ μ‚¬μš©μ€ C++κ³Ό Cλ₯Ό μ‚¬μš©ν•΄μ•Όλ§Œ ν•˜λŠ” ν—€λ”νŒŒμΌμ˜ μœ μ§€λ³΄μˆ˜λ₯Ό κ°„νŽΈν•˜κ²Œ ν•΄μ€λ‹€. C++둜 컴파일 ν• λ•ŒλŠ” extern "C"λ₯Ό ν—ˆμš©ν•˜κ³ , C둜 ν•  λ•ŒλŠ” ν—ˆμš©ν•˜μ§€ μ•Šκ³  컴파일 ν•˜λ©΄ λœλ‹€. μ΄λŸ¬ν•œ preprocessor에 λŒ€ν•œ μ‹¬λ²Œ(symbol)은 __cplusplus κ°€ C++ 컴파일 νƒ€μž„μ— μ •μ˜λ˜μ–΄ μžˆλŠ” 것을 μ΄μš©ν•΄μ„œ λ‹€μŒκ³Ό 같이 κ΅¬μ„±ν• μˆ˜ μžˆλ‹€.

~cpp 
#ifdef __cplusplus
extern "C" {
#endif
    void drawLine(int x1, int y1, int x2, int y2);
    void twiddleBits(unsigned char bits);
    void simulate(int iterations);
  ...
#ifdef __cplusplus
}
#endif

그런 방법에 μ΄μš©ν•˜λŠ”κ±΄, "ν‘œμ€" 적인 name mangle μ•Œκ³ λ¦¬μ¦˜μ΄λž€ μ—†λ‹€. λ‹€λ₯Έ μ»΄νŒŒμΌλŸ¬λŠ” λ‹€λ₯Έ λ°©λ²•μœΌλ‘œ name mangle 을 λ§‰λŠ” 방법을 μ œκ³΅ν•œλ‹€. μ΄λŠ” 쒋은 것이닀. λ§Œμ•½μ— λͺ¨λ“  μ»΄νŒŒμΌλŸ¬κ°€ 같은 λ°©λ²•μœΌλ‘œ name mangle을 μˆ˜ν–‰ ν•˜λ©΄, 당신은 μ•„λ§ˆλ„ 그듀이 λ§Œλ“€μ–΄ λ‚΄λŠ” μ•Œλ§žμ€ μ½”λ“œμ— λŒ€ν•œ 생각에 μ•ˆμ‹¬ν•΄ ν• μ§€ λͺ¨λ₯Έλ‹€. λ§Œμ•½ 당신이 μ •ν™•ν•˜μ§€ μ•Šμ€ C++ 컴파일러둜 λΆ€ν„° μƒμ„±λœ 객체λ₯Ό ν˜Όμš©ν•˜λ©΄ 링크쀑에 μ—λŸ¬λ₯Ό λ°œμƒν• μˆ˜ μžˆλŠ” 쒋은 기회λ₯Ό λ§žμ΄ν• κ²ƒμ΄λ‹€. μ™œλƒν•˜λ©΄, mangle처리된 이름을 μ°Ύμ„μˆ˜ μ—†κΈ° λ•Œλ¬Έμ΄λ‹€. 이것은 λ‹Ήμ‹ μ—κ²Œ μ•Œλ§žμŒμ„ λ”°μ§€λŠ” λ˜λ‹€λ₯Έ 문제λ₯Ό μ˜λ―Έν•˜κ³ , 또 도쒋은 해결책을 μ°Ύμ•„μ•Ό 함을 μ˜λ―Έν•œλ‹€.


3.2. Initialization of statics : static 인자의 μ΄ˆκΈ°ν™”


일단 name mangle에 κ΄€ν•œ λ‚΄μš©μ„ μ΅ν˜”λ‹€λ©΄, C++μ½”λ“œμ—μ„œ main 이전과 이후에 λ§Žμ€ μ½”λ“œλ“€μ΄ μˆ˜ν–‰λœλ‹€λŠ” 사싀에 κ΄€ν•΄μ„œ 생각해볼 ν•„μš”κ°€ μžˆλ‹€. νŠΉλ³„νžˆ, μ „μ—­ 이름 곡간, 파일 μ˜μ—­μƒμ˜ 정적(static) 클래슀 κ°μ²΄λŠ” 보톡 main 보닀 λ¨Όμ € μ‹€ν–‰λœλ‹€. 이 과정이 static initialization 이라고 μ•Œλ €μ Έ μžˆλ‹€. μ΄λŠ” ν”„λ‘œκ·Έλž¨μ˜ μ‹€ν–‰μ‹œμ  간에 C와 C++ ν”„λ‘œκ·Έλž¨μ— λŒ€ν•œ λ°©λ²•μœΌλ‘œ μ™„μ „νžˆ λ‹€λ₯Έ λ°©ν–₯을 μ·¨ν•œλ‹€. λΉ„μŠ·ν•˜κ²Œ, static initialization으둜 λ§Œλ“€μ–΄μ§„ κ°μ²΄λŠ” λ°˜λ“œμ‹œ κ·Έλ“€μ˜ 파괴자λ₯Ό static destruct λ™μ•ˆμ— λΆˆλŸ¬μ£Όμ–΄μ•Ό ν•œλ‹€.;κ·ΈλŸ¬ν•œ 과정은 일반적으둜 main 이후에 μ§„ν–‰λœλ‹€.

main이 μˆ˜ν–‰λ˜κΈ° 전에 객체가 μƒμ„±λ˜μ•Ό ν•˜λŠ” ν•„μš”μ„±μ΄ μžˆμ§€λ§Œ, main이 κ°€μž₯ 처음 λΆˆλ €μ•Ό ν•˜λŠ”κ²ƒμœΌλ‘œ κ°€μ •λ˜λŠ” λ”œλ ˆλ§ˆμ˜ 해결을 μœ„ν•΄μ„œ, λ§Žμ€ 컴파일러 듀이 νŠΉλ³„ν•œ μ»΄νŒŒμΌλŸ¬κ°€ μž‘μ„±ν•˜λŠ” ν•¨μˆ˜λ₯Ό main의 μ‹œμž‘λ‹¨μ— λ„£λŠ”λ‹€. 그리고 이 νŠΉλ³„ν•œ ν•œμˆ˜λŠ” static initialization 을 ν•œλ‹€. λΉ„μŠ·ν•˜κ²Œ μ»΄νŒŒμ–ΌλŸ¬λŠ” μ’…μ’… main의 끝에 νŠΉλ³„ν•œ ν•¨μˆ˜λ₯Ό λ„£μ–΄μ„œ static 객체의 μ‚­μ œλ₯Ό μˆ˜ν–‰ν•œλ‹€. main 에 λŒ€ν•΄ μž‘μ„±λ˜λŠ” μ½”λ“œλŠ” μ’…μ’… main 이 μ—ƒκ²Œ μž‘μ„±λ˜λŠ” κ²ƒμ²˜λŸΌ 보인닀.


~cpp 
int main(int argc, char *argv[])
{
    performStaticInitialization();         // main이 λ„£λŠ”λ‹€κ³  κ°€μ •ν•˜λŠ” ν•¨μˆ˜

    μ—¬κΈ°λŠ” λ©”μΈμ˜ μ½”λ“œλ“€μ„ μˆ˜ν–‰;

    performStaticDestruction();            // main이 λ„£λŠ”λ‹€κ³  κ°€μ •ν•˜λŠ” ν•¨μˆ˜
}

μ΄λ ‡κ²Œ 의미 κ·ΈλŒ€λ‘œλŠ” μ•„λ‹ˆλ‹€. performStaticInitialization κ³Ό performStaticDestruction 은 보톡 훨씬 λ‚œν•΄ν•œ 이름이고, 그듀은 inline 으둜 우리의 객체 νŒŒμΌμ—μ„œ μ–΄λ– ν•œ ν•¨μˆ˜λ‘œ μ•Œμ•„λ³Όμˆ˜ 있게 μž‘μ„±λ˜μ–΄ μžˆλ‹€. μ€‘μš”ν•œ 점은 이것이닀.:λ§Œμ•½ C++ μ»΄νŒŒμΌλŸ¬κ°€ 정적(static) 객체의 μ΄ˆκΈ°ν™”(initialization)와 파괴(destruction)λ₯Ό μ΄λŸ¬ν•œ λ°©λ²•μœΌλ‘œ μ μš©ν•˜λ©΄, C++μ—μ„œ main이 μž‘μ„±λ˜μ§€ μ•Šμ•˜λ‹€λ©΄, μ΄ˆκΈ°ν™”μ™€ νŒŒκ΄΄κ°€ μˆ˜ν–‰λ˜μ§€ μ•Šμ„ 것이닀. 정적 μ΄ˆκΈ°ν™”, νŒŒκ΄΄μ— λŒ€ν•œ μ΄λŸ¬ν•œ 접근이 일반적이기 λ•Œλ¬Έμ—, λ§Œμ•½ C++μ—μ„œ μ†Œν”„νŠΈμ›¨μ–΄ μ‹œμŠ€ν…œμ˜ μ–΄λ–€ 뢀뢄을 μž‘μ„±ν• λ•Œ main을 μž‘μ„±ν•˜λ„λ‘ λ…Έλ ₯ν•΄μ•Ό 할것이닀.

λ•Œλ•Œλ‘œ C에 main μž‘μ„±μ΄ 더 κ°€μΉ˜ μžˆλ‹€κ³  보인닀. - λŒ€λ‹€μˆ˜ ν”„λ‘œκ·Έλž¨μ΄ C이고, C++이 단지 라이브러리 지원 이라면 이라고 말해라. κ·Έλ ‡κΈ°λŠ” ν•˜μ§€λ§Œ, C++ λΌμ΄λΈŒλŸ¬λ¦¬λŠ” 정적(static) 객체(object)λ₯Ό ν¬ν•¨ν•˜λŠ” 것이 μ’‹λ‹€.(쒋은 κΈ°λŠ₯이 λ§Žλ‹€λŠ” 의미) (λ§Œμ•½ μ§€κΈˆ 없닀해도 λ―Έλž˜μ— μ–΄μ©Œλ©΄ μžˆμ„μ§€ λͺ¨λ΄μ§€ μ•ŠλŠ”κ°€? Item 32μ°Έκ³ ) κ·Έλž˜μ„œ κ°€λŠ₯ν•˜λ‹€λ©΄ C++μ—μ„œ main을 μž‘μ„±μ€ 쒋은 생각이닀. 그것은 λ‹Ήμ‹ μ˜ Cμ½”λ“œλ₯Ό μ œμž‘μ„± ν•˜λŠ”κ²ƒμ„ μ˜λ―Έν•˜μ§€λŠ” μ•ŠλŠ”λ‹€. 단지 Cμ—μ„œ μ“΄ main을 realMain으둜 μ΄λ¦„λ§Œ λ°”κΎΈκ³ , main의 C++λ²„μ „μ—μ„œλŠ” realMain을 ν˜ΈμΆœν•œλ‹€.:

~cpp 
extern "C"                                
int realMain(int argc, char *argv[]);     // C μ—μ„œ κ΅¬ν˜„λœ ν•¨μˆ˜

int main(int argc, char *argv[])          // C++μ—μ„œ μ΄λ ‡κ²Œ μž‘μ„±
{
    return realMain(argc, argv);
}
μ΄λ ‡κ²Œ ν•œλ‹€λ©΄, mainμœ„μ— 주석을 μ£ΌλŠ”κ²ƒμ΄ 쒋은 생각일 것이닀.

λ§Œμ•½ C++μ—μ„œ main을 μž‘μ„±ν• μˆ˜ μ—†λ‹€λ©΄ λ¬Έμ œκ°€ λœλ‹€. μ™œλƒν•˜λ©΄, 정적(static) 객체 ν˜ΈμΆœμ„ μœ„ν•œ μƒμ„±μž, νŒŒκ΄΄μžμ— λŒ€ν•˜μ—¬ 이식성에 확신을 μ€„μˆ˜ μ—†κΈ° λ•Œλ¬Έμ΄λ‹€. 이것은 λͺ¨λ“ κ²ƒμ„ μžƒλŠ”λ‹€λŠ” μ˜λ―ΈλŠ” μ•„λ‹ˆλ‹€. 단지 μ€λ” 할일이 λ§Žμ•„ μ§„λ‹€λŠ” 것을 μ˜λ―Έν•œλ‹€. 컴파일러 밴더듀은 μ΄λŸ¬ν•œ 문제λ₯Ό 잘 μ•Œκ³  μžˆλ‹€. κ·Έλž˜μ„œ 거의 λŒ€λΆ€λΆ„μ˜ 벀더듀은 static initialization, destruction을 μœ„ν•΄μ„œ λͺ‡κ°€μ§€μ˜ 언어와 κ΄€κ³„μ—†λŠ” κΈ°μˆ μ„ μ œκ³΅ν•œλ‹€. 이에 κ΄€ν•œ μ •λ³΄λŠ” λ‹Ήμ‹ μ˜ 컴파일러의 λ¬Έμ„œλ₯Ό μ°Έμ‘°ν•˜κ±°λ‚˜, λ²€λ”λ“€μ—κ²Œ λ¬Έμ˜ν•΄λΌ

3.3. Dynamic memory allocation : 동적 λ©”λͺ¨λ¦¬ ν• λ‹Ή


동적 λ©”λͺ¨λ¦¬ ν• λ‹Ή(dynamic memory allocation:μ΄ν•˜ 동적 λ©”λͺ¨λ¦¬ ν• λ‹Ή)에 κ΄€ν•œ λ¬Έμ œκ°€ μš°λ¦¬μ—κ²Œ μ£Όμ–΄μ§„λ‹€. 일반적인 κ·œμΉ™μ€ κ°„λ‹¨ν•˜λ‹€.:C++ μ—μ„œ new, delete λΆ€λΆ„ (Item 8μ°Έκ³ ) 그리고 C ν”„λ‘œκ·Έλž˜λ° μ—μ„œλŠ” malloc(그리고 κ·Έκ²ƒμ˜ λ³€μˆ˜λ“€) κ³Ό free이닀. malloc으둜 얻은건 free둜, new둜 얻은건 delete둜 ν•΄μž¬ν•˜λŠ”ν•œ λͺ¨λ“  것이 μ˜¬λ°”λ΄λ‹€. κ·Έλ ‡μ§€λ§Œ, new둜 ν• λ‹Ήλœ λ©”λͺ¨λ¦¬ μ˜μ—­μ„ κ°€λ¦¬ν‚€λŠ” 포인터λ₯Ό free둜 ν•΄μ œ μ‹œν‚€λŠ” ν˜ΈμΆœμ€ 예츑 λͺ»ν•˜λŠ” μˆ˜ν–‰μ„ κ°€μ§€κ³  μ˜¨λ‹€. λ§ˆμ°¬κ°€μ§€λ‘œ malloc둜 얻은 것을 delete둜 ν•΄μ œν•˜λŠ” 것도 μ˜ˆμΈ‘ν• μˆ˜ μ—†λ‹€. κ·Έλ ‡λ‹€λ©΄, 이λ₯Ό κΈ°μ–΅ν•˜κΈ° μœ„ν•œ 방법은 new와 delete, malloc와 freeλ₯Ό μ—„κ²©ν•˜κ²Œ ꡬ뢄해야 ν•˜λŠ” 것이닀.


λ•Œλ•Œλ‘œ, 이것은 λ§ν•˜κΈ°μ— μ‰¬μ›Œ 보인닀. C, C++ μ–‘μͺ½λ‹€ ν‘œμ€μ€ μ•„λ‹ˆμ§€λ§Œ κ·ΈλŸΌμ—λ„ κ΄‘λ²”μœ„ν•˜κ²Œ μ“°μ΄λŠ”, μ €κΈ‰μ˜ strdup ν•¨μˆ˜μ— κ΄€ν•˜μ—¬ 생각해 보자.

~cpp 
char * strdup(const char *ps);  // λ¬Έμžμ—΄μ˜ 사본을 λ°˜ν™˜ν•œλ‹€.
λ©”λͺ¨λ¦¬ leakλ₯Ό ν”Όν• λ €λ©΄, strdup λ‚΄λΆ€μ—μ„œ ν• λ‹Ήλœ λ©”λͺ¨λ¦¬λ₯Ό strdup의 ν˜ΈμΆœμžκ°€ ν•΄μ œν•΄ μ£Όμ–΄μ•Ό ν•œλ‹€. ν•˜μ§€λ§Œ λ©”λͺ¨λ¦¬λ₯Ό μ–΄λ–»κ²Œ ν•΄μ œ 할것인가? delete둜? free둜? λ§Œμ•½ strdupλ₯Ό 당신이 C λΌμ΄λΈŒλŸ¬λ¦¬μ—μ„œ λΆˆλ €λ‹€λ©΄, free둜, C++ λΌμ΄λΈŒλŸ¬λ¦¬μ—μ„œ λΆˆλ €λ‹€λ©΄ delete둜 ν•΄μ•Ό ν•œλ‹€. 무엇이 당신은 strdup ν˜ΈμΆœν›„μ— 무엇이 ν•„μš”ν•œκ°€, μ‹œμŠ€ν…œκ³Ό μ‹œμŠ€ν…œ 간에 뿐이 아닐, 컴파일러, μ»΄νŒŒμ–ΌλŸ¬ 간에도 이건 문제λ₯Ό μΌμœΌν‚¬μˆ˜ μžˆλ‹€. κ·ΈλŸ¬ν•œ μ΄μ‹μ„±μ˜ κ³ ν†΅μ˜ κ°μ†Œλ₯Ό μœ„ν•΄, ν‘œμ€ λΌμ΄λΈŒλ¦¬μ—μ„œ λΆˆλŸ¬μ•Ό ν•˜μ§€ 말아야할 ν•¨μˆ˜, λŒ€λ‹€μˆ˜ ν”Œλ ›νΌμ— μ’…μ†μ μœΌλ‘œ κ·€μ†λœ λͺ¨μŠ΅μ˜ ν•¨μˆ˜λ“€μ„ λΆ€λ΄μ§€ μ•Šλ„λ‘ λ…Έλ ₯ν•˜λΌ.

3.4. Data Structure Compatibility : 자료 ꡬ쑰의 ν˜Έν™˜μ„±(이식성)


μš°λ¦¬λŠ” C++와 Cν”„λ‘œκ·Έλž¨ 사이에 데이터 κ΅ν™˜μ— κ΄€ν•΄μ„œ 닀룬닀. C++의 κ°œλ…μ„ μ΄ν•΄ν•˜λŠ” C ν•¨μˆ˜λ₯Ό λ§Œλ“œλŠ”κ²ƒ λΆˆκ°€λŠ₯ ν•˜λ‹€. κ·Έλž˜μ„œ 이 두 μ–Έμ–΄κ°„μ˜ μ „λ‹¬μ˜ 수μ€μ€ Cκ°€ ν‘œν˜„ν• μˆ˜ μžˆλŠ” κ°œλ…μœΌλ‘œ ν•œμ •λœλ‹€. κ·Έλž˜μ„œ 객체의 전달 λ°©μ‹μ΄λ‚˜, 포인터λ₯Ό C μ—μ„œ μž‘μ„±λœ λ£¨ν‹΄μ˜ 멀버 ν•¨μˆ˜λ‘œ μ „λ‹¬ν•˜λŠ” 방법은 이식성이 λ–¨μ–΄μ§ˆκ²ƒμ€ λΆ„λͺ…ν•˜λ‹€. CλŠ” 일반적인 포인터 μ΄ν•΄ν•œλ‹€. κ·Έλž˜μ„œ λ‹Ήμ‹ μ˜ C++와 Cμ»΄νŒŒμΌλŸ¬κ°€ λ§Œλ“€μ–΄ λ‚΄λŠ”, λ‘κ°€μ§€μ˜ μ–Έμ–΄μ—μ„œ μ•Œλ§žλŠ” ν•¨μˆ˜λŠ” pointer와 객체λ₯Ό pointer와 non-member λ‚˜ static ν•¨μˆ˜λ₯Ό μ•ˆμ „ν•˜κ²Œ κ΅μ²΄ν• μˆ˜ μžˆλ‹€.μžμ—° 슀럽게, ꡬ쑰체와 built-inν˜•μ˜ λ³€μˆ˜λ“€ μ—­μ‹œ 자유둜이 C+++/C의 경계λ₯Ό λ„˜λ‚˜λ“ λ‹€.

C++μ—μ„œ ꡬ쑰체의 섀계 κ·œμΉ™μ΄ Cμ—μ„œμ˜ 그것과 μΌμΉ˜ν•˜κΈ° λ•Œλ¬Έμ— μ–‘ μ–Έμ–΄κ°€ 각자의 컴파일러둜 같은 κ·œμΉ™μœΌλ‘œ ꡬ쑰체가 μ„€κ³„λ˜μ–΄ μžˆλ‹€κ³  κ°€μ • ν• μˆ˜ μžˆλ‹€. κ·ΈλŸ¬ν•œ κ΅¬μ‘°μ²΄λŠ” μ•ˆμ „ν•˜κ²Œ C++κ³Ό C사이에 κ΅ν™˜λ μˆ˜ μžˆλ‹€. λ§Œμ•½ 당신이 비가상 ν•¨μˆ˜λ₯Ό C++ λ²„μ „μ˜ ꡬ쑰체에 μΆ”κ°€ ν–ˆλ‹€λ©΄, κ·Έκ²ƒμ˜ λ©”λͺ¨λ¦¬ λͺ¨μ–‘(layout)은 λ°”λ€Œμ§€ μ•ŠλŠ”λ‹€. κ·Έλž˜μ„œ 비가상 ν•¨μˆ˜λ₯Ό ν¬ν•¨ν•˜λŠ” ꡬ쑰체(ν˜Ήμ€ 클래슀)의 객체(object)λŠ” 였직 멀버 ν•¨μˆ˜κ°€ μ—†λŠ” ꡬ쑰체 C둜 μ΅œμ ν™” 될것이닀. 가상 ν•¨μˆ˜λ₯Ό λ”ν•˜λŠ” 것은 λ…Όν•  κ°€μΉ˜κ°€ μ—†λ‹€. μ™œλƒν•˜λ©΄ 가상 ν•¨μˆ˜λ₯Ό ν΄λž˜μŠ€μ— μΆ”κ°€ν•˜λŠ” 것은 λ©”λͺ¨λ¦¬μ˜ 배열에 λ‹€λ₯Έ λͺ¨μŠ΅μ„ 보인닀. (Item24μ°Έκ³ ) λ‹€λ₯Έ ꡬ쑰체(ν˜Ήμ€ 클래슀)둜 λΆ€ν„° 상속 받은 κ΅¬μ‘°μ²΄λŠ” 보톡 κ·Έκ²ƒμ˜ λ©”λͺ¨λ¦¬μƒ λͺ¨μŠ΅μ΄ 바뀐닀. κ·Έλž˜μ„œ κΈ°λ³Έ(base) ꡬ쑰체(ν˜Ήμ€ 클래슀)에 μ˜ν•œ ꡬ쑰체 μ—­μ‹œ Cν•¨μˆ˜μ˜ 지원이 λ―Έν‘ν•˜λ‹€.

자료 ꡬ쑰의 μž…μž₯은 μ΄λ ‡κ²Œ μš”μ•½λœλ‹€.:ꡬ쑰체의 μ •μ˜λ₯Ό C++와 Cμ—μ„œ μ „λΆ€ μ»΄νŒŒμΌλ˜λ„λ‘ λ§Œλ“€λ©΄, C++μ—μ„œ C둜의 ꡬ쑰체의 전달과, Cμ—μ„œ C++둜의 전달은 μ•ˆμ „ν•˜λ‹€. 비가상 멀버 ν•¨μˆ˜λ₯Ό C++ λ²„μ „μ˜ ꡬ쑰체에 λ”ν•˜λŠ” 것은, λ‹€λ₯Έ ν•œνŽΈμœΌλ‘œ C에 λ§žμΆ”λŠ” 것이기에 이것도 두 언어간에 쑰화에 영ν–₯을 λΌμΉ˜μ§€ μ•ˆν”γ„΄λ‹€. ν•˜μ§€λ§Œ ꡬ쑰체가 λͺ‡κ°€μ§€μ˜ 변화이 μ•ˆλ  것이닀.


3.5. Summary : μš”μ•½

λ§Œμ•½ 당신이 C++와 Cλ₯Ό 같은 ν”„λ‘œκ·Έλž¨μ—μ„œ μ„žμ–΄μ„œ μ“°κΈ°λ₯Ό μ›ν•œλ‹€λ©΄, κ°„λ‹¨ν•œ κ°€μ΄λ“œ 라인을을 λ”°λ₯Όκ²ƒμ„ κΈ°μ–΅ν•˜λΌ.

  • C++, Cμ»΄νŒŒμΌλŸ¬κ°€ μ‘°ν™”λ‘œμš΄ 였브젝트 νŒŒμΌμ„ μƒμ„±ν•˜λ„λ‘ ν•˜λΌ.
  • λ‘μ–Έμ–΄μ—μ„œ λͺ¨λ‘ extern "C" λ₯Ό μ‚¬μš©ν•΄μ„œ ν•¨μˆ˜λ₯Ό μ„ μ–Έν•˜λΌ
  • new둜 ν• λ‹Ή 받은 λ©”λͺ¨λ¦¬λŠ” 항상 delete둜 μ œκ±°ν•˜λΌ;malloc둜 ν• λ‹Ήν•œ λ©”λͺ¨λ¦¬λŠ” 항상 free둜 μ œκ±°ν•˜λΌ.
  • 두 μ–Έμ–΄μƒμ—μ„œ Cκ°€ μ»΄νŒŒμΌν• μˆ˜ μžˆλŠ” 데이터 ꡬ쑰의 μ „λ‹¬λ‘œ μ œν•œ λœλ‹€.:C++λ²„μ „μ˜ κ΅¬μ‘°μ²΄λŠ” μ•„λ§ˆλ„ 비가상 멀버 ν•¨μˆ˜λ§Œμ„ κ°€μ§€κ³  μžˆμ–΄μ•Ό ν•œλ‹€.

4. Item 35: Familiarize yourself with Β°the language standard.

  • Item 35: μ–Έμ–΄ ν‘œμ€μ— μΉœν•΄μ ΈλΌ.
좜반된 1990λ…„ 이후, The Annotated C++ Reference Manual은 ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ—κ²Œ C++에 μ •μ˜μ— μ°Έκ³ λ¬Έμ„œκ°€ λ˜μ–΄ μ™”λ‹€. ARMκΈ° λ‚˜μ˜¨ 이후에 λͺ‡λ…„κ°„ ISO/ANSI committe standardizing the language λŠ” 크고 μž‘κ²Œ λ³€ν•΄ μ™”λ‹€. 이제 C++의 μ°Έκ³  λ¬Έμ„œλ‘œ ARM은 더 이상 만쑱될수 μ—†λ‹€.

post-ARM 은 C++둜 쒋은 ν”„λ‘œκ·Έλž¨μ„ μž‘μ„± ν• μˆ˜ μžˆλŠλƒμ— 큰 영ν–₯을 μ€λ‹€. 결과적으둜 C++ ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ—κ²Œ ARM의 λ‚΄μš©κ³Ό λ‹€λ₯Έ ν‘œμ€ μ‚¬ν•­μ„ μ•„λŠ” 것은 ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ—κ²Œ 첫번째둜 μ€‘μš”ν•œ λ¬Έμ œκ°€ 될것이닀.

ISO/ANSI standard for C++ λŠ” μ»΄νŒŒμΌλŸ¬κ°€ κ΅¬ν˜„λ λ•Œ, λ²€λ”λ“€μ˜ 쑰언이고, 책을 μ€λΉ„ν• λ•Œ, μž‘κ°€λ“€μ΄ μ‹œν—˜ν•΄ λ³Ό 것이고, ν”„λ‘œκ·Έλž˜λ¨Έλ“€μ΄ C++에 κ΄€ν•œ μ •μ˜μ— μ§ˆλ¬Έμ— 닡이닀. ARM이 λ‚˜μ˜¨ 이후 C++에 κ°€μž₯ 큰 λ³€ν™”λ₯Ό μ•Œμ•„ 보자.
  • μƒˆλ‘œμš΄ κ°œλ…μ˜ μΆ”κ°€ : RTTI, namespace, bool, mutableκ³Ό explicit keyword, enum을 μœ„ν•œ μ˜€λ²Œλ“œ(overload) μ—°μ‚°μž λŠ₯λ ₯, 클래슀 μ •μ˜ λ‚΄λΆ€μ—μ„œ μ΄μš©ν•œ μ™„μ „ν•œ 정적 클래슀 멀버 μ΄ˆκΈ°ν™” 증λ ₯
  • ν…œν”Œλ¦Ώ(template)의 ν™•μž₯ :멀버 ν…œν”Œλ¦Ώμ΄ ν—ˆμš©. 이것은 νƒ¬ν”Œλ¦Ώμ˜ λͺ…μ‹œμ  ν‘œν˜„μ„ μœ„ν•œ ν‘œμ€ λ¬Έλ²•,ν•¨μˆ˜ ν…œν”Œλ¦Ώμ—μ„œ non-type μΈμžλ“€ ν—ˆμš© ν•˜λŠ”κ²ƒ, 클래슀 ν…œν”Œλ¦Ώμ΄ κ·Έλ“€ μžμ‹ μ˜ ν…œν”Œλ¦Ώμ„ 인자둜 λ°›μ„μˆ˜ μžˆλŠ”κ²ƒ 이 μžˆλ‹€.
  • μ˜ˆμ™Έ ν•Έλ“€λ§μ˜ μž¬μ •μ˜ : μ˜ˆμ™Έ μŠ€νŒ©μ€ ν˜„μž¬ 컴파일 쀑에 λ”μš±λ” μ—„κ²©ν•˜κ²Œ 검사 λœλ‹€. 그리고 μ˜ˆμΈ‘ν• μˆ˜ μ—†λŠ” ν•¨μˆ˜λŠ” μ•„λ§ˆλ„ bad_exception μ˜ˆμ™Έ 객체λ₯Ό λ˜μ§„λ‹€.
  • λ©”λͺ¨λ¦¬ ν• λ‹Ή λ£¨ν‹΄μ˜ μˆ˜μ • : operator new[]와 operator delete[] κ°€ μΆ”κ°€, operator new/new[] λŠ” 이제 λ©”λͺ¨λΌκ°€ ν• λ‹Ή λ˜μ§€ μ•ŠμœΌλ©΄, μ˜ˆμ™Έλ₯Ό λ˜μ§€λ‹€. 그리고 이 바뀐 operator new/new[]λŠ” μ‹€νŒ¨ν•  κ²½μš°μ— 0 을 λ°˜ν™˜ν•œλ‹€.
  • μƒˆλ‘œμš΄ μΌ€μŠ€νŒ… μ—°μ‚°μžμ˜ μΆ”κ°€ : static_cast, dynamic_cast, const_cast, reinterpret_cast
  • μ–Έμ–΄ κ·œμΉ™μ˜ κ°œμ„  : 가상 ν•¨μˆ˜μ˜ κ°œμ„ μœΌλ‘œ 이제 더이상 μž¬μ •μ˜ν•œ ν•¨μˆ˜μ™€ μ •ν™•νžˆ μΌμΉ˜ν•˜λŠ” ν˜•μ˜ λ°˜ν™˜μΈμžλ₯Ό κ°€μ§€μ§€ μ•ŠλŠ”λ‹€. 그리고 μž„μ‹œ 객체의 생λͺ…주기도 μ •ν™•ν•˜κ²Œ μ •μ˜λ˜μ—ˆλ‹€.
The Design and Evolution of C++에 거의 λͺ¨λ“  λ³€ν™”κ°€ μ–ΈκΈ‰λ˜μ–΄ μžˆλ‹€. ν˜„μž¬ C++ μ°Έκ³ μ„œ(1994λ…„ 이후에 쓰여진것듀)도 이 λ‚΄μš©μ„ ν¬ν•¨ν•˜κ³  μžˆμ„ 것이닀. (λ§Œμ•½ 당신이 μ°Ύμ§€ λͺ»ν•˜λ©΄ κ·Έκ±° 버렀라) 덧뢙여 More Effective C++(이책이닀.)λŠ” μ΄λŸ¬ν•œ μƒˆλ‘œμš΄ 뢀뢄에 κ΄€ν•œ λŒ€λΆ€λΆ„μ˜ μ‚¬μš© 방법이 μ–ΈκΈ‰λ˜μ–΄ μžˆλ‹€. λ§Œμ•½ 당신이 이것에 리슀트λ₯Ό μ•Œκ³  μ‹Άλ‹€λ©΄, 이 μ±…μ˜ 인덱슀λ₯Ό μ‚΄νŽ΄λ³΄μ•„λΌ.

ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬μ— μΌμ–΄λ‚˜λŠ” 것듀에 λŒ€ν•œκ²ƒμ—μ„œ C++의 μ •ν™•ν•œ κ·œμ •μ˜ λ³€ν™”κ°€ μžˆλ‹€. κ°œλ‹€κ°€ ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬μ˜ κ°œμ„ μ€ μ–Έμ–΄μ˜ ν‘œμ€ λ§ŒνΌμ΄λ‚˜ μ•Œλ €μ§€μ§€ μ•ŠλŠ”λ‹€. 예λ₯Ό λ“€μ–΄μ„œ The Design and Evolution of C++ 거의 ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬μ— κ΄€ν•œ 언급이 거의 μ—†λ‹€. κ·Έ μ±…μ˜ λΌμ΄λΈŒλŸ¬λ¦¬μ— κ³Όν•œ λ…Όμ˜λΌλ©΄ λ•Œλ•Œλ‘œ μžˆλŠ” λ°μ΄ν„°μ˜ 좜λ ₯이닀. μ™œλƒν•˜λ©΄, λΌμ΄λΈŒλŸ¬λ¦¬λŠ” 1994년에 μ‹€μ§ˆμ μœΌλ‘œ λ³€ν™”λ˜μ—ˆκΈ° λ•Œλ¬Έμ΄λ‹€.

ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬μ˜ λŠ₯λ ₯은 μ•„λž˜μ™€ 같은 일반적인 μΉ΄ν…Œκ³ λ¦¬μ— λŒ€ν•˜μ—¬

  • ν‘œμ€ C λΌμ΄λΈŒλŸ¬λ¦¬μ— λŒ€ν•œ 지원 C++ κ°€ κ·Έκ²ƒμ˜ 뿌리λ₯Ό κΈ°μ–΅ν•œλ‹€λ©΄, λ‘λ €μ›Œ 할것이 μ•„λ‹ˆλ‹€. λͺ‡λͺ‡ minor tweaksλŠ” C라이브러리의 C++ 버전을 C++의 더 μ—„κ²©ν•œ ν˜• 검사λ₯Ό λ„μž…ν•˜μžκ³  μ œμ•ˆν•œλ‹€. κ·Έλ ‡μ§€λ§Œ λͺ¨λ“  κ°œλ…μ΄λ‚˜, λͺ©μ μ„ μœ„ν•΄, C λΌμ΄λΈŒλŸ¬λ¦¬μ— κ΄€ν•˜μ—¬ 당신이 μ•Œμ•„μ•Ό ν•˜λŠ” 쒋와(ν˜Ήμ€ μ‹«μ–΄)ν•΄μ•Ό 할것은 C++μ—μ„œλ„ μ—­μ‹œ μœ μ§€λœλ‹€.
  • λ¬Έμžμ—΄μ— λŒ€ν•œ 지원. ν‘œμ€ C++ 라이브러리λ₯Ό μœ„ν•œ μ›Œν‚Ή 그룹의 μˆ˜μ„μΈ Mike Vilot은 μ΄λ ‡κ²Œ 이야기 ν–ˆλ‹€. "λ§Œμ•½ ν‘œμ€ string ν˜•μ΄ μ΄μ œν•˜μ§€ μ•ŠλŠ”λ‹€λ©΄ κΈΈκ±°λ¦¬μ—μ„œ ν”Όλ₯Ό 흘리게 될것이닀.!" (λͺ‡λͺ‡ μ‚¬λžŒμ€ 맀우 κ°μ •μ μ΄μ—ˆλ‹€.) μ§„μ •ν•˜λΌ. - ν‘œμ€ C++ λΌμ΄λΈŒλŸ¬λ¦¬λŠ” λ¬Έμžμ—΄μ„ κ°€μ§€κ³  μžˆλ‹€.
  • μ§€μ—­ν™”(localization)에 λŒ€ν•œ 지원. λ‹€λ₯Έ λ¬Έν™”μ—μ„œλŠ” λ‹€λ₯Έ κΈ€μžλ₯Ό μ¨μ•Όν•˜κ³ , 화면에 ν‘œν˜„λ˜λŠ” λ‚ μ§œ, μ‹œκ°„, λ¬Έμžμ—΄ μ •λ ¬, λˆμ„ μ„ΈλŠ” λ‹¨μœ„ etc κ·Έ λ¬Έν™”μ˜ νŽΈμ˜μ— 따라야 ν•œλ‹€. ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬μ— μ˜ν•œ μ§€μ—­ν™”(localization)은 각 문화적 차이에 μ ν•©ν•˜λ„λ‘ ν”„λ‘œκ·Έλž¨μ˜ κ°œλ°œμ„ ν•œλ‹€.
  • I/O에 λŒ€ν•œ 지원. iostream λΌμ΄λΈŒλŸ¬λ¦¬λŠ” C++ ν‘œμ€μ˜ ν•œ 뢀뢄을 μ°¨μ§€ν•œλ‹€. ν•˜μ§€λ§Œ μœ„μ›νšŒλŠ” κ·Έκ±Έ μ€ μ–΄μ„€ν”„κ²Œ λ§Œλ“€μ—ˆλ‹€. λͺ‡λͺ‡ ν΄λž˜μŠ€κ°€ 제거되고(ν•„μš” μ—†λŠ” iostreamκ³Ό fstream), λͺ‡λͺ‡ ν΄λž˜μŠ€κ°€ ꡐ체(string 기반의 stringstream은 char* 기반으둜) λ˜μ—ˆμ§€λ§Œ, ν‘œμ€ iostream 클래슀의 κΈ°λ³Έ λŠ₯λ ₯은 λͺ‡λ…„ λ™μ•ˆ μ΄μž¬ν•΄μ˜¨ (μ˜›λ‚ ) κ΅¬ν˜„μ˜ λͺ¨μŠ΅μ„ λ°˜μ˜ν•œλ‹€.
  • 수치 계산 μ–΄ν”Œλ¦¬ μΌ€μ΄μ…˜μ— λŒ€ν•œ 지원. λ³΅μž‘ν•œ 숫자, C++ ν…μŠ€νŠΈμ— 쀑심 예제둜 λ§ˆμ§€λ§‰μ— ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬μ— ν¬ν•¨λ˜μ—ˆλ‹€. λ”λΆˆμ–΄, λΌμ΄λΈŒλŸ¬λ¦¬λŠ” aliasing을 μ œν•œν•˜λŠ” νŠΉλ³„ν•œ λ°°μ—΄ 클래슀(valarray)κ°€ ν¬ν•¨λ˜μ–΄ μžˆλ‹€. λΌμ΄λΈŒλŸ¬λ¦¬λŠ” λ˜ν•œ λͺ‡κ°€μ§€μ˜ 일반적인 μœ μš©ν•œ 수치 κ³„μ‚°μ˜ ν•¨μˆ˜λ“€, 뢀뢄적 ν•©κ³Ό μΈμ ‘ν•˜λŠ” μ΄μ›ƒμ˜ 차이λ₯Ό ν¬ν•¨ν•˜λŠ” 것듀, 을 μ§€μ›ν•œλ‹€.
  • 일반적인 λͺ©μ μ˜ μ»¨ν…Œμ΄λ„ˆμ™€ μ•Œκ³ λ¦¬μ¦˜μ— λŒ€ν•œ 지원. ν‘œμ€ C++ λΌμ΄λΈŒλŸ¬λ¦¬μ— ν¬ν•¨λ˜μ–΄ μžˆλŠ” 클래슀, ν•¨μˆ˜ ν…œν”Œλ¦Ώμ€ Standard Template Library(STL)둜 μ•Œλ €μ Έ μžˆλ‹€. STL은 ν‘œμ€ C++ 라이브러리의 κ°€μž₯ 혁λͺ…적인 뢀뢄이닀. λ‚˜λŠ” 밑에 μ΄κ²ƒμ˜ νŠΉμ§•μ„ μš”μ•½ν•œλ‹€.

λ‚΄κ°€ STL을 μ–ΈκΈ‰ν•˜κΈ° 전에, λ‚˜λŠ” λ°˜λ“œμ‹œ 당신이 μ•ŒκΈ°μ— ν•„μš”ν•œ C++ 라이브러리의 λ‘κ°€μ§€μ˜ νŠΉμ§•μ„ 이야기 ν•΄μ•Όν•œλ‹€.

첫번째 라이브러리 μ•ˆμ˜ 거의 λͺ¨λ“ κ²ƒμ΄ template이닀. 이 μ±… λ‚΄μ—μ„œ λ‚˜λŠ” μ•„λ§ˆλ„ ν‘œμ€ string 클래슀λ₯Ό μ°Έκ³  ν–ˆλ‹€. κ·ΈλŸ¬λ‚˜ 사싀 그런 ν΄λž˜μŠ€κ°€ μ•„λ‹ˆλ‹€. λŒ€μ‹ μ— λ¬Έμžλ“€μ˜ μˆœμ„œλ₯Ό ν‘œν˜„ν•˜λŠ” basic_string 으둜 λΆˆλ¦¬λŠ” 클래슀 ν…œν”Œλ¦Ώμ΄κ³ , 이 ν…œν”Œλ¦Ώμ€ λ¬Έμžν˜•μœΌλ‘œ μˆœμ„œλ₯Ό λ§Œλ“ λ‹€. 이것은 λ¬Έμžμ—΄μ„ char, wide char, Unide char, 무엇이든 ν—ˆμš©ν•œλ‹€.

μš°λ¦¬κ°€ 일반적으둜 μƒκ°ν•˜λŠ” string ν΄λž˜μŠ€λŠ” basic_string<char>을 λͺ…μ‹œμ μœΌλ‘œ ν‘œν˜„ν•œ 것이닀. 이것을 μΌλ°˜ν™” μ‹œν‚€κΈ° μœ„ν•˜μ—¬ ν‘œμ€ λΌμ΄λΈŒλŸ¬λ¦¬μ—μ„œλŠ” λ‹€μŒκ³Ό 같이 μ •μ˜ν•˜κ³  μžˆλ‹€.

~cpp 
typedef basic_string<char> string;
basic_string ν…œν”Œλ¦Ώμ΄ μ„Έκ°€μ§€μ˜ λ…Όμ˜λ₯Ό κ°€μ§€κ³  μ•„μ„œ, 이 ν•œμ€„μ— μ‘°μ°¨ μžμ„Έν•˜κ²Œ 주석을 λ‹¬μˆ˜ μžˆλ‹€.;κ·Έλ ‡μ§€λ§Œ 무엇보닀 λ¨Όμ € 생각할것 μ²«λ²ˆμ§ΈλŠ” κΈ°λ³Έ 값이닀. μ§„μ§œ string ν˜•μ˜ 이해λ₯Ό μœ„ν•΄μ„œ λ°˜λ“œμ‹œ 이와 같은 상황에 μ§λ©΄ν•˜λŠ”λ°, λ°”λ‘œ basic_string에 λŒ€ν•œ 선언을 μˆ˜μ •ν• μˆ˜ μ—†λŠ”κ°€? 이닀.


~cpp 
template<class charT,
        class traits = string_char_traits<charT>,
        class Allocator = allocator>
    class basic_string;

string ν˜•μ˜ μ‚¬μš©μ„ μœ„ν•˜μ—¬ μœ„μ˜ 사항을 μ™„μ „νžˆ 이해할 ν•„μš”λŠ” μ—†λ‹€. μ™œλƒν•˜λ©΄ 단지 string은 Template Instantiation from Hell을 μœ„ν•œ typedef μ΄μ§€λ§Œ, 그것은 ν…œν”Œλ¦Ώμ΄ μ•„λ‹Œ ν΄λž˜μŠ€μ™€ 같이 λ™μž‘ν•œλ‹€. 단지, λ§Œμ•½ 당신이 λ¬Έμžμ—΄μ„ μ΄λ£¨λŠ” 문자 ν˜•μ˜ custmizeκ°€ ν•„μš”ν•˜λ‹€λ©΄.. ν˜Ήμ€ 당신이 λ¬Έμžμ—΄μ„ μœ„ν•œ λ©”λͺ¨λ¦¬ 할당에 λŒ€ν•œ 세뢀적인 쑰정을 μ›ν•œλ‹€λ©΄... basic_string ν…œν”Œλ¦Ώμ€ 이듀을 ν• κ²Œ ν•΄μ€„κ²ƒμ΄λΌλŠ” 생각을 λ§ˆμŒμ†μ— μƒˆκ²¨λ‘μ–΄λΌ.

string ν˜•μ˜ λ””μžμΈμ— 반영된 μ΄λŸ¬ν•œ 접근은-ν…œν”Œλ¦Ώμ˜ μΌλ°˜ν™”- ν‘œμ€ C++ 라이브러리λ₯Ό ν†΅ν•΄μ„œ λ°˜λ³΅λ˜μ–΄ μ§„λ‹€. IOStream? 그듀은 ν…œν”Œλ¦Ώμ΄λ‹€.; 인자(type parameter)λŠ” μŠ€νŠΈλ¦Όμ—μ„œ λ§Œλ“€μ–΄μ§€λŠ” λ¬Έμžν˜•μœΌλ‘œ μ •μ˜λ˜μ–΄ μžˆλ‹€. λ³΅μž‘ν•œ 숫자(Complex number)? μ—­μ‹œ ν…œν”Œλ¦Ώμ΄λ‹€.;인자(type parameter)λŠ” 숫자λ₯Ό μ–΄λ–»κ²Œ μ €μž₯ν• μ§€ μ •μ˜λ˜μ–΄ μžˆλ‹€. Valarray? ν…œν”Œλ¦Ώμ΄λ‹€.;인자(type parameter)λŠ” 각 배열에 μ΅œμ ν™”λœλ‹€. 그리고 STL은 거의 λͺ¨λ“  ν…œν”Œλ¦Ώμ˜ 볡합체이닀. λ§Œμ•½ 당신이 ν…œν”Œλ¦Ώμ— μ΅μˆ™ν•˜μ§€ μ•Šλ‹€λ©΄, μ§€κΈˆ ν•œλ°œμž‘ λ‚΄λ””λŽŒ 보아라.

ν‘œμ€ λΌμ΄λΈŒλŸ¬μ— κ΄€ν•˜μ—¬ λ‹€λ₯Έ 뢀뢄도 std 이름 κ³΅κ°„μ•ˆμ— λͺ¨λ“ κ²ƒμ΄ κ°€μƒμ μœΌλ‘œ ν¬ν•¨λ˜μ–΄ μžˆλ‹€. ν‘œμ€ λΌμ΄λΈŒλ¦¬μ—μ„œ λͺ…μ‹œμ μœΌλ‘œ κ·Έλ“€μ˜ 이름을 ν‘œν˜„ν•˜μ§€ μ•Šκ³  μ“°κΈ° μœ„ν•΄μ„œλŠ”, using으둜 직접 접근을 ν•˜κ±°λ‚˜ 미리 using선언을 톡해 μ ‘κ·Όν• μˆ˜ μžˆλ‹€. (DeleteMe λͺ¨ν˜Έ)λ‹€ν–‰μŠ€λŸ½κ²Œλ„ μ΄λŸ¬ν•œ λ¬Έλ²•μ˜ κ΄€λ¦¬λŠ” 당신이 #include λ₯Ό μ‚¬μš©ν• λ•Œλ§ˆλ‹€ μ•Œλ§žλŠ” 헀더에 μ μš©λœλ‹€.

Fortunately, this syntactic administrivia is automatically taken care of when you #include the appropriate headers.

4.1. The Standard Template Library : ν‘œμ€ ν…œν”Œλ¦Ώ 라이브러리


ν‘œμ€ C++ λΌμ΄λΈŒλŸ¬λ¦¬μ—μ„œ κ°€μž₯ 큰 λ‰΄μŠ€λŠ” Standard Template Library(ν‘œμ€ ν…œν”Œλ¦Ώ 라이브러리)인 STL이닀. (C++ λΌμ΄λΈŒλŸ¬λ¦¬μ—μ„œ 거의 λͺ¨λ“ κ²ƒμ΄ ν…œν”Œλ¦Ώμ΄ λœμ΄ν›„ κ·Έ 이름 STL은 이제 νŠΉλ³„ν•œκ²ƒμ΄ μ•„λ‹ˆλ‹€. κ·ΈλŸΌμ—λ„, 이것은 라이브러리의 μ•Œκ³ λ¦¬μ¦˜κ³Ό μ»¨ν…Œμ΄λ„ˆμ˜ λΆ€λΆ„μ˜ 이름이닀. κ·Έλž˜μ„œ 쓰기에 쒋은 이름이기도, λ‚˜μœ 이름이기도 ν•œλ‹€.)

STL은 λ§Žμ€ 쑰직-거의 λͺ¨λ“  C++라이브러리-에 영ν–₯을 λ―ΈμΉ˜λŠ” 것 κ°™λ‹€. κ·Έλž˜μ„œ κ·Έκ²ƒμ˜ 일반적인 κ°œλ…κ³Ό μΉœν•΄μ§€λŠ” 것은 맀우 μ€‘μš”ν•˜λ‹€. 그듀은 μ΄ν•΄ν•˜κΈ°λŠ” μ–΄λ ΅μ§€ μ•Šλ‹€. STL은 μ„Έκ°€μ§€μ˜ 기본적인 κ°œλ…μ— κΈ°λ°˜ν•˜κ³  μžˆλ‹€.: container, iterator, algorithm. ContainerλŠ” 객체의 λͺ¨μŒ(collection)이닀. IteratorλŠ” STL μ»¨ν…Œμ΄λ„ˆμ—μ„œ 당신이 built-in ν˜•μ˜ μΈμžλ“€μ„ ν¬μΈν„°λ‘œ μ‘°μ •ν•˜λŠ” κ²ƒμ²˜λŸΌ 객체λ₯Ό 가리킨닀. Algorithm은 STL container와 iteratorλ₯Ό μ‚¬μš©ν•΄μ„œ κ·Έλ“€μ˜ 일을 λ•λŠ”λ° μ‚¬μš©ν•˜λŠ” ν•¨μˆ˜μ΄λ‹€.
배열을 μœ„ν•œ C++(그리고 C)의 κ·œμΉ™μ„ κΈ°μ–΅ν•˜λŠ” 것이 STl을 μ „μ²΄μ μœΌλ‘œ λ°”λΌλ³΄λŠ”λ° κ°€μž₯ μ„ ν–‰λ˜μ–΄μ•Ό ν•  μž‘μ—…μ΄λ‹€. μš°λ¦¬κ°€ μ•Œμ•„μ•Ό 할것은 정말 였직 ν•˜λ‚˜μ˜ κ·œμΉ™μ΄λ‹€.:배열을 κ°€λ¦¬ν‚€λŠ” ν¬μΈν„°λŠ” ν•©λ²•μ μœΌλ‘œ λ°°μ—΄μƒμ˜ μ–΄λ– ν•œ μΈμžλ‚˜ λ°°μ—΄μ˜ 끝을 λ„˜μ–΄ μ–΄λ– ν•œ μΈμžλΌλ„ κ°€λ¦¬ν‚¬μˆ˜ μžˆλ‹€. λ§Œμ•½ 포인터가 λ°°μ—΄μ˜ 끝을 λ„˜μ€ 인자λ₯Ό 가리킨닀면, 그것은 배열을 κ°€λ¦¬ν‚€λŠ” λ‹€λ₯Έ 포인터와 비ꡐ λ˜μ–΄μ§€λŠ” μ…ˆμ΄λ‹€.; 결과적으둜 μ •μ˜λ˜μ§€ μ•Šμ€ dereferencing을 μˆ˜ν–‰ν•˜λŠ” 것이닀.

μœ„μ˜ κ·œμΉ™μ€, λ°°μ—΄μƒμ—μ„œ ν•˜λ‚˜μ˜ νŠΉλ³„ν•œ 값을 μ°ΎκΈ°μœ„ν•œ ν•¨μˆ˜μ˜ μž‘μ„±μ˜ κ·œμΉ™μ— 이점이 λœλ‹€. integer(μ •μˆ˜)의 배열에, μš°λ¦¬λŠ” 이와 같은 ν•¨μˆ˜λ₯Ό μž‘μ„±ν•˜μ˜€λ‹€.

~cpp 
int * find(int *begin, int *end, int value)
{
    while (begin != end && *begin != value) ++begin;
    return begin;
}
이 ν•¨μˆ˜λŠ” ν•΄λ‹Ή λͺ©ν‘œ μ‹œμ μ˜ μ‹œμž‘κ³Ό 끝 상에 ν•΄λ‹Ή 값이 μžˆλŠ”κ°€λ₯Ό μ°ΎλŠ”λ‹€. 그리고 배열상에 ν•΄λ‹Ή μ λ‹Ήν•œ 수λ₯Ό 처음 λ§Œλ‚˜λ©΄ λ°˜ν™˜ν•œλ‹€.; λ§Œμ•½ μ°Ύμ§€ λͺ»ν•˜λ©΄, endλ₯Ό λ°˜ν™˜ν•œλ‹€.

endλ₯Ό λ°˜ν™˜ν•˜λŠ” 것은 λ‹¨μˆœν•œ ν‰λ²”ν•œ λ°©λ²•μœΌλ‘œ 재미있게 보인닀. 0(null pointer)이 더 μ’‹μ§€ μ•Šμ„κΉŒ? ν™•μ‹€νžˆ null은 더 μžμ—°μŠ€λŸ½κ²Œ λ³΄μ΄κ² μ§€λ§Œ "더 μ’‹μ§€"λŠ” μ•Šλ‹€. μ°ΎλŠ” ν•¨μˆ˜λŠ” λ°˜λ“œμ‹œ 검색이 μ‹€νŒ¨ν•¨μ„ μ˜λ―Έν•˜λŠ” μ–΄λ– ν•œ λšœλ ·ν•œ 포인터 값을 λ°˜ν™˜ν•΄μ•Όλ§Œ ν•œλ‹€. 그런 λͺ©μ μœΌλ‘œ end ν¬μΈν„°λŠ” null만큼 μ’‹λ‹€. 거기에닀가 μš°λ¦¬κ°€ 이제 κ³§ 보게될, null 포인터 보닀 λ‹€λ₯Έ container ν˜•μœΌλ‘œ μΌλ°˜ν™” μ‹œν‚€λŠ” 것을 μ•Œμˆ˜ μžˆλ‹€.

μ†”μ°νžˆ 이것은 μ•„λ§ˆ 당신이 μ°ΎκΈ° ν•¨μˆ˜(find function)λ₯Ό μž‘μ„±ν•œ 방법이 μ•„λ‹ˆλ‹€. κ·Έλ ‡μ§€λ§Œ κ²°μ½” λ©μ²­ν•œ 것이 μ•„λ‹ˆκ³ , 그것은 맀우 ν›Œλ₯­νžˆ μΌλ°˜ν™” λœλ‹€. 당신이 이와 같은 κ°„λ‹¨ν•œ 예제λ₯Ό λ”°λ΄λ©΄, STLμ—μ„œ μ°Ύμ„μˆ˜ μžˆλŠ” λŒ€λ‹€μˆ˜μ˜ 생각듀을 κ°€μ§€κ³  μžˆλŠ”κ±°λ‹€.

당신은 μ°ΎκΈ° ν•¨μˆ˜(find function)λ₯Ό λ‹€μŒκ³Ό 같이 μ‚¬μš©ν• μˆ˜ μžˆλ‹€.

~cpp 
int values[50];
...

int *firstFive = find(  values,     // 숫자 5λ₯Ό
                        values+50,  // value[0] - value[49]
                        5);         // κΉŒμ§€ 검색

if (firstFive != values+50) {       // 검색이 μ„±κ³΅ν–ˆλ‚˜μš”?
    ...                             // λ„€
}
else {
    ...                             // μ•„λ‹ˆμš”. 검색에 μ‹€νŒ¨ ν–ˆλ‹€.
}

당신은 λ°°μ—΄μ˜ subrange 검색도 ν• μˆ˜ μžˆλ‹€.

~cpp 
int *firstFive = find(values,        // search the range
                      values+10,     // values[0] - values[9]
                      5);            // for the value 5

int age = 36;

...

int *firstValue = find(values+10,    // search the range
                       values+20,    // values[10] - values[19]
                       age);         // for the value in age

ν•΄λ‹Ή ν•¨μˆ˜λŠ” λ°°μ—΄μ˜ 적용이 int에 ν•œμ •λ˜μ–΄ μžˆμ–΄μ„œ 상속성이 μ—†λ‹€. κ·Έλž˜μ„œ 그것을 ν…œν”Œλ¦Ώ(template)으둜 λ§Œλ“€μ–΄ λ³Έλ‹€.


~cpp 
template<class T>
T * find(T *begin, T *end, const T& value)
{
    while (begin != end && *begin != value) ++begin;
    return begin;
}

ν…œν”Œλ¦ΏμœΌλ‘œμ˜ λ³€ν™˜μ—μ„œ κ°’μœΌλ‘œμ˜ 전달을 reference to const 둜 μ „λ‹¬λ‘œ λ³€ν™”μ‹œν‚¬ 방법이 μ—†μŒμ„ μ£Όλͺ©ν•΄λΌ. 각 κ°’μœΌλ‘œμ˜ 인자 전달은 μš°λ¦¬μ—κ²Œ 맀번 객체의 μƒμ„±κ³ΌνŒŒκ΄΄μ˜ λΉ„μš©μ„ μ§€λΆˆν•˜κ²Œ λ§Œλ“ λ‹€. μš°λ¦¬λŠ” pass-by-referenceλ₯Ό μ‚¬μš©ν•΄μ„œ, μ•„λ¬΄λŸ° 객체의 생성과 파괴λ₯Ό ν•˜μ§€ μ•Šλ„λ‘ λ§Œλ“€μ–΄μ„œ ν•΄λ‹Ή λΉ„μš©μ„ ν”Όν•΄μ•Ό ν•œλ‹€.

κ·Έλ ‡μ§€λ§Œ 이 ν…œν”Œλ¦Ώμ€ μ’‹λ‹€, κ°œλ‹€κ°€ μΌλ°˜ν™” κΉŒμ§€ ν• μˆ˜ μžˆλ‹€. μ‹œμž‘κ³Ό 끝에 μ—°μ‚°μžλ₯Ό 보아라. μ‚¬μš©λœ μ—°μ‚°μžλŠ” λ‹€λ΄λ‹€λŠ” 것, dereferencing, prefix증가(Item 6μ°Έκ³ ), 볡사(ν•¨μˆ˜μ˜ λ°˜ν™˜ 값을 μœ„ν•΄μ„œ? Item 9μ°Έκ³ )λ₯Ό μœ„ν•΄μ„œ μ“°μ˜€λ‹€. λͺ¨λ“  μ—°μ‚°μžλŠ” μš°λ¦¬κ°€ overloadν• μˆ˜ μžˆλ‹€. (DeleteMe λͺ¨ν˜Έ) κ·Έλž˜μ„œ μ™œ 포인터 μ‚¬μš©ν•˜μ—¬ μ°ΎκΈ°λ₯Ό μ œν•œν•˜λŠ”κ°€? μ™œ ν—ˆμš©ν•˜μ§€ μ•ŠλŠ”κ°€ 포인터 μΆ”κ°€μ—μ„œ μ΄λŸ¬ν•œ μ—°μ‚°μžλ₯Ό μ§€μ›ν•˜κΈ° μœ„ν•œ μ–΄λ–€ 객체도 ν—ˆμš©ν• μˆ˜ μ—†μ„κΉŒ? (hy not allow any object that supports these operations to be used in addition to pointers?) κ·Έλž˜μ„œ μ΄λ ‡κ²Œ ν•˜λŠ”κ²ƒμ€ 포인터 μ—°μ‚°μžμ˜ built-in 의미λ₯Ό μ°ΎκΈ°ν•¨μˆ˜(find function)을 자유둭게 할것이닀. 예λ₯Ό λ“€μ–΄μ„œ μš°λ¦¬λŠ” 리슀트 μ—μ„œ λ‹€μŒ 리슀트둜의 이동을 ν•΄μ£ΌλŠ” prefix increment μ—°μ‚°μžμ˜ linked list객체와 λΉ„μŠ·ν•œ pointerλ₯Ό μ •μ˜ν• μˆ˜ μžˆλ‹€.

이것이 STL iterator 뒀에 μˆ¨κ²¨μ§„ κ°œλ…μ΄λ‹€. IteratorλŠ” STL containerκ°€ μ‚¬μš©ν•˜κΈ° μœ„ν•˜μ—¬ pointer λΉ„μŠ·ν•˜κ²Œ μ„€κ³„λœ 객체이닀. 그듀은 Item 28의 슀마트 ν¬μΈν„°μ˜ μ‚¬μ΄Œκ²©μΈ μ…ˆμ΄λ‹€. κ·Έλ ‡μ§€λ§Œ 슀마트 ν¬μΈν„°λŠ” STL의 iteratorκ°€ ν•˜λŠ” 것에 λΉ„ν•˜μ—¬ μ‘°κΈˆλ” λͺ¨ν˜Έν•œ κ²½ν–₯이 μžˆλ‹€. κ·Έλ ‡μ§€λ§Œ 기술적 κ΄€μ μ—μ„œ 그듀은 같은 κΈ°μˆ μ„ μ΄μš©ν•΄μ„œ κ΅¬ν˜„λœλ‹€.

pointer λΉ„μŠ·ν•œ κ°μ²΄λ‘œμ„œ iterator, μš°λ¦¬λŠ” iteratorλ₯Ό μ΄μš©ν•œ κ²€μƒ‰μ—μ„œ 포인터λ₯Ό κ΅μ²΄ν• μˆ˜ μžˆλ‹€. κ·Έλž˜μ„œ λ‹€μŒκ³Ό 같이 μ½”λ“œλ₯Ό λ‹€μ‹œ μ“Έμˆ˜μžˆλ‹€.


~cpp 
template<class Iterator, class T>
Iterator find(Iterator begin, Iterator end, const T& value)
{
  while (begin != end && *begin != value) ++begin;
  return begin;
}

μΆ•ν•˜ν•œλ‹€! 당신은 Standard Template Library의 ν•œ 뢀뢄을 μž‘μ„±ν•œ 것이닀. STL은 container와 iteratorλ₯Ό μ΄μš©ν•˜λŠ” μ•Œκ³ λ¦¬μ¦˜ λ¬ΆμŒμ„ ν¬ν•¨ν•˜κ³  μžˆλ‹€. 그리고 findλŠ” 그듀쀑에 ν•˜λ‚˜μ΄λ‹€.

STLμ—μ„œ containerλŠ” bitset, vector, list, deque, queue, priority_queue, stack, set, map ν¬ν•¨ν•œλ‹€. 그리고 당신은 μ΄λŸ¬ν•œ μ–΄λ–€ container ν˜•μ„ find에 μ μš©ν• μˆ˜ μžˆλ‹€.


~cpp 
list<char> charList;        // char을 μˆ˜μš©ν•˜λŠ” 
                            // STL list객체λ₯Ό μƒμ„±ν•œλ‹€.                            
...

// char listμ—μ„œ 'x' κ°€ 처음 λ‚˜νƒ€λ‚˜λŠ” 뢀뢄을 μ°ΎλŠ”λ‹€.
list<char>::iterator it = find(charList.begin(),
                               charList.end(),
                               'x');

"μ™€μš°!" λ‚˜λŠ” λ‹Ήμ‹ μ˜ μšΈλΆ€μ§“μŒμ΄ λ“€λ¦¬λŠ”κ±Έ, "이것은 μœ„μ˜ λ°°μ—΄ μ˜ˆμ œμ™€ λ‹€λ₯Έκ²Œ ν•˜λ‚˜λ„ μ—†μž–μ•„μš”!" μ•„, κ·ΈλŸ¬λ‚˜ 그건:당신은 μ°ΎκΈ°μœ„ν•œ κ²ƒλ§Œμ„ μ•Œκ³  있기만 ν•˜λ©΄ λœλ‹€.

list 객체λ₯Ό μ°ΎκΈ° μœ„ν•œ ν˜ΈμΆœμ„ μœ„ν•΄μ„œ, 당신은 list의 κ°€μž₯ 처음 μΈμžμ™€ list와 κ°€μž₯ λ§ˆμ§€λ§‰μ˜ 인자λ₯Ό κ°€λ¦¬ν‚€λŠ” iteratorκ°€ ν•„μš”ν•˜λ‹€. 리크트 ν΄λž˜μŠ€μ— μ˜ν•œ λͺ‡κ°€μ§€μ˜ 도움 될 κΈ°λŠ₯듀을 μ œμ™Έν•˜κ³ , 이것은 μ–΄λ €μš΄ λ¬Έμ œμ΄λ‹€. μ™œλƒν•˜λ©΄ 당신은 listκ°€ μ–΄λ–»κ²Œ κ΅¬ν˜„λ˜μ—ˆλŠ” 가에 κ΄€ν•œ 정보가 μ—†κΈ° λ•Œλ¬Έμ΄λ‹€. λ‹€ν–‰ μŠ€λŸ½κ²Œλ‹€ 리슀크(list,λͺ¨λ“  STL의 containerλ“€κ³Ό 같이) μ‹œμž‘κ³Ό 끝을 μ œκ³΅ν•˜λŠ” 멀버 ν•¨μˆ˜λ‘œμ„œ ν•΄κ²°ν•œλ‹€. 이 멀버 ν•¨μˆ˜λŠ” 당신이 μ›ν•˜λŠ” iterator λ°˜ν™˜ν•˜κ³  μœ„μ˜ μ˜ˆμ œμ—μ„œ ν•΄λ‹Ή iterator 두가지λ₯Ό μ°Ύμ„μˆ˜ μžˆλ‹€.

μ°ΎκΈ°(find)κ°€ λλ‚¬μœΌλ©΄ 그것은 찾은 인자λ₯Ό κ°€λ¦¬ν‚€λŠ”, ν˜Ήμ€ charList.end()(μ°Ύμ§€ λͺ»ν•˜μ˜€μ„λ•Œ)의 iterator 객체λ₯Ό λ°˜ν™˜ν•œλ‹€. μ™œλƒν•˜λ©΄ 당신은 listκ°€ μ–΄λ–»κ²Œ κ΅¬ν˜„λ˜μ—ˆλŠ”κ°€μ— λŒ€ν•˜μ—¬ 아무것도 μ•Œμˆ˜ μ—†κΈ°λ•Œλ¬Έμ— μ—­μ‹œ κ΅¬ν˜„λœ listμ—μ„œ iteratorκ°€ μ–΄λ–»κ²Œ λ˜μ—ˆλŠ”μ§€ μ „ν˜€ μ•Œμˆ˜ μ—†λ‹€. 그런데 μ–΄λ–»κ²Œ μ°Ύκ³ μ„œ λ°˜ν™˜λ˜μ–΄μ§€λŠ” 객체의 ν˜•μ„ μ•Œμˆ˜ μžˆμ„κΉŒ? λ‹€μ‹œ, list ν΄λž˜μŠ€λŠ” λͺ¨λ“  STL container와 λ§ˆμ°¬κ°€μ§€λ‘œ μ œν•œ ν•΄μ œλ₯Ό ν•œλ‹€.: 그것은 ν˜• μ •μ˜, iterator, 즉 listλ‚΄λΆ€μ˜ iterator의 μ •μ˜λ₯Ό μ œκ³΅ν•œλ‹€. charList κ°€ char의 listκ°€ 된 μ΄ν›„λ‘œ iterator의 μ •μ˜λŠ” κ·ΈλŸ¬ν•œ list인 list<char>::iterator 내뢀에 있고, 그것은 μœ„μ˜ μ˜ˆμ œμ™€ 같이 쓰인닀. (각 STL container ν΄λž˜μŠ€λŠ” λ‘κ°€μ§€μ˜ iteraotrν˜•μΈ iterator 와 const_iteraotr λ₯Ό μ •μ˜ν•œλ‹€. μ „μžλŠ” 일반적인 pointer와 같이 λ™μž‘ν•˜κ³  ν›„μžλŠ” pointer-to-const와 같이 λ™μž‘ν•œλ‹€. )

λ‹€λ₯Έ STL continer듀을 μ΄μš©ν•΄μ„œ μ •ν™•νžˆ 같은 접근을 ν•΄λ³Έλ‹€. κ²Œλ‹€κ°€ C++ ν¬μΈν„°λŠ” STL iterator이닀. κ·Έλž˜μ„œ μ›λž˜ λ°°μ—΄ μ˜ˆμ œλŠ” STL find ν•¨μˆ˜λ„ μ—­μ‹œ μ΄μš©ν• μˆ˜ μžˆλ‹€.

~cpp 
int values[50];

...

int *firstFive =   find(values, values+50, 5);  // λ§žλ‹€. STL findλ₯Ό ν˜ΈμΆœν•œλ‹€.

STL, κ·Έκ²ƒμ˜ 쀑심(core)λŠ” 맀우 κ°„λ‹¨ν•˜λ‹€. 그것은 단지, λŒ€ν‘œ μ„ΈνŠΈ(set of convention)λ₯Ό(μΌλ°˜ν™” μ‹œμΌ°λ‹€λŠ” 의미) 덧뢙인 ν΄λž˜μŠ€μ™€ ν•¨μˆ˜ ν…œν”Œλ¦Ώμ˜ λͺ¨μŒμ΄λ‹€. STL collection ν΄λž˜μŠ€λŠ” 클래슀둜 μ •μ˜λ˜μ–΄μ§„ ν˜•μ˜ iterator 객체 beginκ³Ό end 같은 ν•¨μˆ˜λ₯Ό μ œκ³΅ν•œλ‹€. STL algorithm ν•¨μˆ˜λŠ” STL collectionμƒμ˜ iterator 객체λ₯Ό μ΄λ™μ‹œν‚¨λ‹€. STL iteratorλŠ” 포인터와 같이 λ™μž‘ν•œλ‹€. 그것은 μ •λ§λ‘œ λͺ¨λ“  것이 포인터 κ°™λ‹€. 큰 상속 관계도 μ—†κ³  가상 ν•¨μˆ˜λ„ μ—†κ³  κ·ΈλŸ¬ν•œ 것듀이 μ—†λ‹€. 단지 λͺ‡κ°œμ˜ ν΄λž˜μŠ€μ™€ ν•¨μˆ˜ ν…œν”Œλ¦Ώκ³Ό 이듀을 μœ„ν•œ μž‘μ„±λœ λͺ¨λ“  것이닀.

또 λ‹€λ₯Έ 면을 λ§ν•œλ‹€.: STL은 ν™•μž₯성이 μžˆλ‹€. 당신은 λ‹Ήμ‹ μ˜ collection, algorithms, iteratorλ₯Ό STL에 μΆ”κ°€ν• μˆ˜ μžˆλ‹€. 당신이 STL ν˜‘μ˜λ₯Ό λ”°λ΄λŠ” 이상 ν‘œμ€ STL collection은 μ•„λ§ˆλ„ λ‹Ήμ‹ μ˜ algorithmκ³Ό λ‹Ήμ‹ μ˜ collection은 STL의 algorithmsκ³Ό 함깨 λ™μž‘ν•  것이닀. λ¬Όλ‘  λ‹Ήμ‹ μ˜ ν…œν”Œλ¦Ώμ€ ν‘œμ€ C++ 라이브러리의 ν•œλΆ€λΆ„μ΄ μ•„λ‹ˆλ‹€. κ·Έλ ‡μ§€λ§Œ 그듀은 같은 μ›λ¦¬λ‘œ λ§Œλ“€μ–΄ μ§ˆκ²ƒμ΄κ³ , μž¬μ‚¬μš© 될것이닀.

λ‚΄κ°€ 여기에 κΈ°μˆ ν•œ 것보닀 훨썬 λ§Žμ€ C++ λΌμ΄λΈŒλŸ¬λ¦¬κ°€ μ΄μž¬ν•œλ‹€. 당신은 라이브러리λ₯Ό 효과적으둜 μ“°κΈ° 전에, λ°˜λ“œμ‹œ 당신이 μ•Œκ³  μžˆλŠ” μš”μ•½ 보닀 더 λ§Žμ€ 것을 λ°°μ›Œμ•Ό ν•˜κ³ , λ‹Ήμ‹ μ˜ STL-compliant ν…œν”Œλ¦Ώμ„ μž‘μ„±ν•˜κΈ° 전에, λ°˜λ“œμ‹œ STL의 ν˜‘μ˜μ— κ΄€ν•΄μ„œ 곡뢀해야 ν•œλ‹€. ν‘œμ€ C++ λΌμ΄λΈŒλŸ¬λ¦¬λŠ” C 라이브러리 보닀 훨씬 ν’λΆ€ν•˜λ‹€. μ•„λ§ˆ λ‹Ήμ‹  μžμ‹ μ΄ 그것(C++lib)에 μΉœμˆ™ν• μˆ˜λ‘ μ‹œκ°„μ€ μ ˆμ•½ 될것이닀. κ²Œλ‹€κ°€ 라이브러리의 λ””μžμΈ 철학은 - μΌλ°˜ν™”(generality), ν™•μž₯μ„±(extensibility), μ΅œμ ν™”(customizability), νš¨μœ¨μ„±(efficiency), μž¬μ‚¬μš©μ„±(reusability) - 당신이 μ˜¬λ°”λ₯Έ λ°°μ›€μœΌλ‘œ κ°€λŠ”λ° 맀우 도움이 λœλ‹€. ν‘œμ€ C++ 라이브러리의 κ³΅λΆ€λ‘œ 당신은 λ‹Ήμ‹ μ˜ μ†Œν”„νŠΈμ›¨μ–΄μ—μ„œ μ‚¬μš© κ°€λŠ₯ν•œ μ»΄ν¬λ„ŒνŠΈλ₯Ό λ§Œλ“œλŠ” 재반 μ§€μ‹μ˜ ν–₯상은 λ¬Όλ‘ , C++ 더 효율적으둜 C++의 νŠΉμ§•μ„ μ μš©μ‹œν‚€λŠ” 방법을 λ°°μš΄λ‹€. 그리고 당신은 당신이 κ°€μ§„ 라이브러리의 쒋은 λ””μžμΈμ˜ 방법에 λŒ€ν•œ ν•΄μ•ˆμ„ μ–»λŠ”λ‹€.

Valid XHTML 1.0! Valid CSS! powered by MoniWiki
last modified 2021-02-07 05:23:48
Processing time 0.1843 sec