U E D R , A S I H C RSS

EffectiveSTL/Container

  • STL„ ๊ตฌ„•˜๋Š” •ต‹ฌ š”†Œ—๋Š” —ฌ๋Ÿฌ ๊ฐ€ง€๊ฐ€ žˆ๋‹ค.(Iterator, Generic Algorithm, Container ๋“๋“). —ญ‹œ ๊ฐ€žฅ •ต‹ฌ ด๊ณ , กฐ๊ธˆ๋งŒ •Œ•„๋„ “ธˆ˜ žˆ๊ณ , Žธ•˜๊ฒŒ “ธˆ˜ žˆ๋Š” ๊ฒƒ€ Container๋‹ค. Container๋Š” Vector, List, Deque ๊ณผ ๊ฐ™ด ๋ฐด„ฐ๋ฅผ ๋‹ด๋Š” ๊ทธ๋ฆ‡๊ณผ ๊ฐ™€ Object๋ผ๊ณ  ๋ณด๋ฉด ๋œ๋‹ค.
  • STL˜ Container๋“ค˜ žฅ ด๋ผ๊ณ  •œ๋‹ค๋ฉด, —ญ‹œ œ —ฐ„, ๋ฉ”๋ชจ๋ฆฌ ๊ด€๋ฆฌ •Œ•„„œ •˜๊ธฐ, ž‹ ด •Œ•„„œ ๋Š˜—ˆ๋‹ค ฆ—ˆ๋‹ค •˜๊ธฐ ๋“๋“ด žˆ๊ฒ ๋‹ค. ๋˜•œ ธ„Ž˜ดŠค๊ฐ€ ด๊ฐ๋‚˜  €๊ฐ๋‚˜ ๋น„Šท๋น„Šท•ด„œ •˜๋‚˜๋งŒ ๊ณต๋ถ€•˜๋ฉด, ‰ฝ๊ฒŒ ๋‹ค๋ฅธ๊ฒƒ๋„ “ธˆ˜ žˆ๋‹ค๋Š” ๊ฒƒ๋„ ๋˜ •˜๋‚˜˜ žฅ ด ๋ ˆ˜ žˆ๊ฒ ๋‹ค.
  • ฐ 1žฅ Containers—„œ๋Š” ƒ™ฉ— ๋งž๋Š”   ˆ•œ Container ๊ณ ๋ฅด๋Š” ๋ฒ•, šจœจ„ ๊ทน๋Œ€™” •˜๊ธฐ ๋“๋“„ ๋‹ค๋ฃฌ๋‹ค.

Contents

1. Item1. Choose your containers with care.
1.1. STLด ง€›•˜๋Š” Containers
1.2. vector, deque, list ๊ณ ๋ฅด๋Š” Œ
1.3. Contiguous-memory Containers & Node-based Containers
1.4. STL Container ๊ณ ๋ฅด๋Š” Œ
2. Item2. Beware the illusion of container-independant code.
2.1. ™„๋ฒฝ•œ Container ๋…๋ฆฝ ธ ฝ”๋“œ ž‘„€ ๋ถˆ๊ฐ€๋Šฅ?
2.2. ๊ทธ๋‚˜๋งˆ ๊ณ น˜๊ธฐ ‰ฝ๊ฒŒ •˜๋Š” Œ๋“ค
3. Item3. Make copying cheap and correct for objects in containers.
3.1. STL way
3.2. ƒ†๋ฐ›€ ๊ฐฒด๋ฅผ ๋„„๋•Œ˜ ๋ฌธ œ 
3.3. •ด๊ฒฐ…
3.4. Why copy?
4. Item4. Call empty instead of checking size() against zero.
5. Item5. Prefer range member functions to their single-element counterparts.
5.1. a ปจ…Œด๋„ˆ— žˆ๋Š” ๋‚ดšฉ˜ ๋’ท๋ถ€๋ถ„˜  ˆ๋ฐ˜„ b๋ผ๋Š” ๋ฒก„ปจ…Œด๋„ˆ— ๋„ฃ๊ณ  ‹ถ๋‹ค๋ฉด, –ด๋–ป๊ฒŒ •ด•ผ• ๊นŒ?
6. Item6. Be alery for c++'s most vexing parse
6.1. ๋ฌธ œ ?
6.2. ˜ˆ œ : ints.dat —  €žฅ๋˜–ด žˆ๋Š”  •ˆ˜๋“ค„ ฝ–ด„œ list<int> data— “ฐ๋Š” ž‘—…„ •œ๋‹ค.
6.3. •ด๊ฒฐ…
6.4. žก๋‹ด
7. Item7. When using containers of newed pointers, remember to delete the pointers before the container is destroyed
7.1. „œ๋ก 
7.2. ˜ˆ œ
7.3. ๋ณด™„๋ฒ• 1(class for function object)
7.4. ๋ณด™„๋ฒ• 2(Smart Pointer)
8. Item8. Never create containers of auto_ptrs.
9. Item9. Choose carefully among erasing options.
9.1. –ด๋–ค ปจ…Œด๋„ˆ๊ฐ€ int๊ฐ’๋“ค„ ๋‹ด๊ณ  žˆ๋‹ค๊ณ  •˜ž. ๊ฐ๊ธฐ„œ 1982 ๋ผ๋Š” ˆž๋ฅผ ๋ชฝ๋•… ง€›Œฃผ๊ณ  ‹ถ๋‹ค๋ฉด?
9.2. กฐ๊ด ๊ฒ€‚ฌ•ด„œ ๋ชฝ๋•… ง€›Œฃผ๊ธฐ
9.2.1. ‰ฝ๊ฒŒ • ˆ˜ žˆ๋Š” ปจ…Œด๋„ˆ๋“ค
9.2.2. Associative Container ผ๋•Œ
9.3. žก๋‹ด
10. Item10. Be aware of allocator conventions and restrictions.
11. Item11. Understand the legitimte uses of custom allocators.
12. Item12. Have realistic expectations about the thread safety of STL containers.


1. Item1. Choose your containers with care.

1.1. STLด ง€›•˜๋Š” Containers

  • Sequence Containers - vector, deque, list, string( vector<char> ) ๋“๋“
  • Associative Containers - set, multiset, map, multimap ๋“๋“
  • ๊ทธ ™ธ— Non Standard๋ผ๊ณ  จžˆ๋Š”๊ฒŒ žˆ๊ธด •œ๋ฐ, ž˜ •ˆ“ฐ๋Š” ๊ฒƒ ๊ฐ™๋‹ค. ˜น‹œ๋ผ๋„ ๋‚˜ค‘— ค‘š”„ด ๋ถ€๊ฐ๋˜๋ฉด ๋‹ค‹œ ๋ด•ผ๊ฒ ๋‹ค. ๋”ด๊ฒŒ ๊ธ‰•˜๋‹ˆ ผ๋‹จ.. AfterCheck
  • vector๊ฐ€ ข‹๋‹ค๊ณ  จžˆ๋‹ค. ž˜ “ฐž. ๊ฐ€๋”๊ฐ€๋‹ค ‹œ๊ฐ„, €žฅ๊ณต๊ฐ„ ๋“๋“— žˆ–ด„œ Associative Containers๋ฅผ ••๋„• ๋•Œ๋„ žˆ๋‹ค๊ณ  •œ๋‹ค.
    • vector ๋Š” Sequence Container ๋‹ˆ๊นŒ ๋ณด†ต Associative Container ๋“ค(ฃผ๋กœ Map)๋ณด๋‹ค ๋ฉ”๋ชจ๋ฆฌ๋‚ญ๋น„๊ฐ€ ๋œ•จ. ๊ทธ๋Œ€‹  •˜๋‚˜ ๋‹จœ„ ๊ฒ€ƒ‰„ • ๋•Œ—๋Š” Associative Container ๋“คด ๋” ๋น ๋ฅธ ๊ฒฝšฐ๊ฐ€ žˆŒ. (˜ˆ๋ฅผ ๋“ค–ด  „™”๋ฒˆ˜ธ๋“ค„  €žฅ•œ container —„œ 024878113 „ ฐพ๋Š”๋‹ค๋ฉด.? map ˜ ๊ฒฝšฐ๋Š” ๋ฐ”๋กœ •ด‰ฌ•จˆ˜๋ฅผ ดšฉ, •œ— ฐพง€๋งŒ, Sequence Container ๋“ค˜ ๊ฒฝšฐ ฒ˜Œ๋ถ€„ˆœฐจ œผ๋กœ ขŒ•… ๊ฒ€ƒ‰•˜๊ฒ ง€.) --1002

1.2. vector, deque, list ๊ณ ๋ฅด๋Š” Œ

  • vector๋Š” ๋ฌด๋‚œ•˜๊ฒŒ “ฐ๊ณ  ‹ถ„๋•Œ
  • list๋Š” ค‘๊ฐ„—„œ ‚ฝž…, ‚ญ œ๊ฐ€ žฃผ ผ–ด๋‚ ๋•Œ
  • deque๋Š” ข…๋‹จ (‹œž‘๊ณผ ๋)—„œ ‚ฝž…, ‚ญ œ๊ฐ€ žฃผ ผ–ด๋‚ ๋•Œ

1.3. Contiguous-memory Containers & Node-based Containers

  •  „ž๋Š” ๋ฐฐ—ด„ ๊ธฐ๋ฐ˜œผ๋กœ •˜๋Š” Container(ฆ‰, ๋™  ๋ฉ”๋ชจ๋ฆฌ • ๋‹น„ • ๋•Œ • ๋‹น๋œ ๋ฉ”๋ชจ๋ฆฌ๋“คด —ฐ† ด ๋œ๋‹ค), ›„ž๋Š” ๋…ธ๋“œ๋ฅผ ๊ธฐ๋ฐ˜œผ๋กœ •˜๋Š” Container(๋…ธ๋“œ˜ ๊ฒฝšฐ๋Š” ๋ฐ˜๋“œ‹œ —ฐ† ธ ๋ฉ”๋ชจ๋ฆฌ๊ฐ€ •„๋‹ ˆ˜ žˆ๋‹ค.)๋‹ค. ๋…ธ๋“œ๊ฐ€ ๋ญ”ง€๋Š” ๋งฌ๋“œ ๋ฆฌŠคŠธ๋ฅผ งœ๋ณด๋ฉด •Œ๊ฒŒ ๋œ๋‹ค.
  •  „ž—๋Š” vector, string, deque ๋“ด žˆ๋‹ค. ๋ญ”๊ฐ€ ๋˜ ๋ณตžก•œ ๋งด žˆ๊ธด •œ๋ฐ ๊ทธ๋ƒฅ ๋„˜–ด๊ฐ€ž. ๋Œ€ถฉ insert, delete๊ฐ€ ผ–ด๋‚˜๋ฉด ๊ธฐกด˜ ›†Œ๊ฐ€ ด๋™•œ๋‹ค๋Š” ๋ง ๊ฐ™๋‹ค.
  • ›„ž—๋Š” list ๋“ด žˆ๋‹ค. ๋…ธ๋“œ๋Š” ๊ทธ๋ƒฅ ฌธ„ฐ๋งŒ ๋ฐ”๊ฟ” ฃผ๋ฉด insert, delete๊ฐ€ žœ žžฌ๋กœ ๋œ๋‹ค๋Š”๊ฐ ๋‹ค •Œ๊ฒƒด๋‹ค.

1.4. STL Container ๊ณ ๋ฅด๋Š” Œ

  • –‘๋—„œ insert, delete •˜๋ ค๋ฉด? Associative Containers๋Š” “ฐ๋ฉด •ˆ๋œ๋‹ค.
  • Random Access Iterator(ž„˜  ‘๊ทผ ๋ฐ˜๋ณตž)๊ฐ€ •„š”•˜๋‹ค๋ฉด, vector, deque, string จ•ผ •œ๋‹ค. (rope๋ž€๊ฒƒ๋„ žˆ„ค), Bidirectional Iterator(–‘๋ฐฉ–ฅ ๋ฐ˜๋ณตž)๊ฐ€ •„š”•˜๋‹ค๋ฉด, slist๋Š” “ฐ๋ฉด •ˆ๋œ๋‹ค.(๋‹น—ฐ•˜๊ฒ ง€) Hashed Containers ๋˜ “ฐง€ ๋ง๋žœ๋‹ค.
  • Insert, Delete • ๋•Œ ›†Œ˜ ธ๋Šค œ„น˜๊ฐ€ ๋ณ€•˜๋ฉด •ˆ๋œ๋‹ค? ๊ทธ๋Ÿฌ๋ฉด Contiguous-memory Containers๋Š” “ฐ๋ฉด •ˆ๋œ๋‹ค. (•ด๋‹น ›†Œ˜ ธ๋Šค œ„น˜๊ฐ€ ๋ณ€•œ๋‹ค.)
  • Search †๋„๊ฐ€ ค‘š”•˜๋‹ค๋ฉด Hashed Containers, Sorted Vector, Associative Containers๋ฅผ “ด๋‹ค. (๋ฐ”๋กœ ธ๋Šค๋กœ  ‘๊ทผ, ƒˆ˜ ๊ฒ€ƒ‰†๋„)
  • Insert, Delete๋ฅผ šจœจ œผ๋กœ “ฐ๋ ค๋ฉด, Node Based Containers๋ฅผ “ฐž.
  • Iterator, Pointer, Reference ๊ฐ‹ „ ตœ†Œ™” •˜๋ ค๋ฉด Node Based Containers๋ฅผ “ด๋‹ค.



2. Item2. Beware the illusion of container-independant code.

2.1. ™„๋ฒฝ•œ Container ๋…๋ฆฝ ธ ฝ”๋“œ ž‘„€ ๋ถˆ๊ฐ€๋Šฅ?

  • Standard Contiguois-memory Container๋“ค€ ž„˜ ‘๊ทผ —ฐ‚ฐž []„ ง€›•˜ง€๋งŒ, ๋‹ค๋ฅธ๊ง€›•˜ง€ •Š๋Š”๋‹ค.
  • Standard Node-based Container๋“ค€ –‘๋ฐฉ–ฅ ๋ฐ˜๋ณตž(bidirectional Iterator)๋ฅผ ง€›•œ๋‹ค.
  • ๊ฒฐ๊ตญ ด ฝ”๋“œ—„œ ด ปจ…Œด๋„ˆ—„œ ž‘๋™•˜๋Š” •จˆ˜๋ฅผ ผ๋Š”๋ฐ, ปจ…Œด๋„ˆ๋ฅผ ๊ฐ™€ ๊ณ„—ด˜ ๊ฒƒœผ๋กœ ๋ฐ”๊พธ๋ฉด ข‹๊ฒ ง€๋งŒ, „–ฅด ๋‹ค๋ฅธ๊ธ๋กœ ๋ฐ”๊พธ๋ฉด--; ๋งŽด ๊ณ ณ•ผ • ๊ฒƒด๋‹ค.
  • ๊ฐ๊ฐ˜ ปจ…Œด๋„ˆ๋Š” žฅ ๊ณผ ๋‹จ „ ๊ฐ€ง€๊ณ  žˆ๋‹ค. ๊ณ ๋ฅด๋Š” ๋Šฅ๋ ฅ„ ๊ธฐ๋ฅดž.
    STL Tutorial and Refereince ๋ฅผ ๋ณด๋ฉด, ผ๋ถ€๋Ÿฌ •ด๋‹น Container —๊ฒŒ ตœ ™”๋œ ๋ฉ”†Œ๋“œ๋“ค๋งŒ ง€›•œ๋‹ค๊ณ  จžˆ—ˆ๋˜ ๊ธฐ–ต. ˜ˆ๋ฅผ ๋“ ๋‹ค๋ฉด, Vector ˜ ๊ฒฝšฐ push_front ๊ฐ™€ ๊ฒƒด —†๋‹ค. (๋งŒผ vector— push_front ๋ฅผ •œ๋‹ค๋ฉด? push_front ๋ ๋•Œ๋งˆ๋‹ค ๋งค๋ฒˆ ๊ธฐกด˜ ›†Œ๋“ค œ„น˜๊ฐ€ ๋ฐ”๋€๋‹ค.) --1002

2.2. ๊ทธ๋‚˜๋งˆ ๊ณ น˜๊ธฐ ‰ฝ๊ฒŒ •˜๋Š” Œ๋“ค

  • typedef„ “ฐž.

~cpp 
vector<Type>::itarator // typedef vector<Type>::iterator VTIT ด๋Ÿฐ‹œผ๋กœ ๋ฐ”๊ฟ€ˆ˜ žˆ๋‹ค. •žœผ๋กœ๋Š”  €๋ ‡๊ฒŒ ๊ธธ๊ฒŒ “ฐง€ •Š๊ณ ๋„ VIIT ด๋ ‡๊ฒŒ “ธˆ˜ žˆ๋‹ค.
  • Encapsulization„ ž˜ •˜ž. ๋ฐ”๋€Œ๋Š” ๊ฒƒ— ๋Œ€•œ ถฉ๊ฒฉด „–ด๋“ค ๊ฒƒด๋‹ค.



3. Item3. Make copying cheap and correct for objects in containers.

3.1. STL way

  • ปจ…Œด๋„ˆ— ๋„„ ๋•Œ๋‚˜ ๋บ„ ๋•Œ, ๋ณต‚ฌ๋ฅผ •œ๋‹ค.
  • ปจ…Œด๋„ˆ— Object๋ฅผ ๋„„๋•Œ—๋Š”, ๊ทธ Object˜ ๋ณต‚ฌ ƒ„ž(const reference)™€, ๋Œ€ž… —ฐ‚ฐž๋ฅผ žฌ •˜(const reference) •ดฃผž. •ˆ๊ทธ๋Ÿฌ๋ฉด ๋ณต‚ฌ๋กœ ธ•œ —„ฒญ๋‚œ ๋‚ญ๋น„๋ฅผ ๋ณด๊ฒŒ ๋ ๊ฒƒด๋‹ค.

3.2. ƒ†๋ฐ›€ ๊ฐฒด๋ฅผ ๋„„๋•Œ˜ ๋ฌธ œ 

  • Slicing—๋Ÿฌ

~cpp 
vector<Widget> vw;

class SpecialWidget : public Widget ...

SpecialWidget sw;

vw.push_back(sw) // –ด๋–ป๊ฒŒ ๋ ๊นŒ. ๋ณต‚ฌ๋˜๋ฉด„œ SpecialWidget๋งŒ˜ Šนˆ˜„€  œ๊ฐ๋˜๊ณ , Widget˜ Šน„๋งŒ ๋‚จ๊ฒŒ ๋œ๋‹ค.
  • •ด๊ฒฐ…œผ๋ก  ๊ฐ€ƒ•จˆ˜ ๋“๋“ด žˆ๋‹ค. •˜ง€๋งŒ ๋” ข‹€ ๋ฐฉ๋ฒ•ด žˆ๋‹ค.

3.3. •ด๊ฒฐ…

  • ปจ…Œด๋„ˆ— ๊ฐ’„„ง€ ๋ง๊ณ , ฌธ„ฐ๋ฅผ ๋„ฃ๋Š” ๊ฒƒด๋‹ค.

~cpp 
vector<Widget*> vw;
vw.push_back(new SpecialWidget); // ž˜๋œ๋‹ค.
  • •˜ง€๋งŒ —ญ‹œ ๋‚ด๊ฐ€ delete•ดค˜•ผ •œ๋‹ค๋Š” ๋‹จ ด žˆ๋‹ค. ๋Œ€•ˆœผ๋กœ smart pointers๋ผ๋Š”๊ฒŒ žˆ๋‹ค.(ด๊ฒŒ ๋ญ˜๊นŒ)
    MoreEffectiveC++/Techniques1of3 ˜ Item 28 „ ๋ด๋ผ. ˜๋ฌธ„ ๋ณด๋Š”๊ฒƒด ๋” ข‹„๊ฒƒด๋‹ค. MoreEffectiveC++ ˜  „ž…๊ณผ •„๋‚ ๋กœ๊ทธ ๋ชจ๋‘๋‹ค †Œžฅ•˜๊ณ  žˆœผ๋‹ˆ •„š”•˜๋ฉด ๋ง•˜๊ณ , ๋‚˜๋„ ด …  •๋ฆฌ • ๋ ค๊ณ  –ˆ๋Š”๋ฐ, ฐธ—ฌ•˜๋„๋ก ๋…ธ๋ ฅ•˜๋งˆ --ƒ๋ฏผ

3.4. Why copy?

  • ๋ถˆ•„š”•œ ๊ฐฒด˜ ๋ณต‚ฌ๋ฅผ ๋ง‰๊ธฐ œ„•ด ๋””žธ ๋˜–ดžˆ๋‹ค.(ž˜ ด•ด๊ฐ€ •ˆ๊ฐ„๋‹ค.)
  • ๋‚ด๊ฐ€ š”๊ตฌ• ๋•Œ๋งŒ ๊ทธ๋งŒผ ๋งŽ€ ๊ณต๊ฐ„„ • ๋‹น•œ๋‹ค.



4. Item4. Call empty instead of checking size() against zero.

  • ปจ…Œด๋„ˆ— •˜๋‚˜๋„ •ˆ๋“ค—ˆ๋‹ค๋Š”๊ฒƒ„ ๊ฐ€ •• ๋•Œ size() == 0 ด๊ฒƒ๋ณด๋‹ค empty() ๊ฐ€ ๋” ข‹๋‹ค๊ณ  •œ๋‹ค.
  • empty()๋Š” ƒˆ˜ ‹œ๊ฐ„— ˆ˜–‰ด ๊ฐ€๋Šฅ•˜๊ณ , size()๋Š” „ ˜• ‹œ๊ฐ„— ˆ˜–‰ด ๊ฐ€๋Šฅ•˜๋‹ค.
  • ๊ณ ๋กœ empty() “ฐž.



5. Item5. Prefer range member functions to their single-element counterparts.

  • ๋ฒ”œ„ ๊ฐ€ง€๊ณ  ๋…ธ๋Š” ๋ฉ”†Œ๋“œ๊ฐ€ •˜๋‚˜”ฉ ๊ฐ€ง€๊ณ  ๋…ธ๋Š” ๋ฉ”†Œ๋“œ๋ณด๋‹ค šฐ›”•˜๋‹ค. ˆ˜–‰‹œ๊ฐ„˜ ฐจด๊ฐ€ žˆ๋Š”๋“ฏ•˜๋‹ค.

5.1. a ปจ…Œด๋„ˆ— žˆ๋Š” ๋‚ดšฉ˜ ๋’ท๋ถ€๋ถ„˜  ˆ๋ฐ˜„ b๋ผ๋Š” ๋ฒก„ปจ…Œด๋„ˆ— ๋„ฃ๊ณ  ‹ถ๋‹ค๋ฉด, –ด๋–ป๊ฒŒ •ด•ผ• ๊นŒ?

  • STL— ตˆ™•˜ง€ •Š๋‹ค๋ฉด •„๋งˆ๋„ ๋‹คŒ๊ณผ ๊ฐ™ด •  ๊ฒƒด๋‹ค.

~cpp 
// ๋ช…‹œ ธ ๋ฐ˜๋ณต๋ฌธ„ “ด๋‹ค.
vector<Object> a,b;

b.clear();

for(vector<Object>::const_itarator VWCI = a.begin() + a.size()/2 ; VWCI != a.end() ; ++VWCI)
	b.push_back(*VWCI)


  • •ฝ๊ฐ„ ตˆ™•œ ‚ฌ๋žŒด๋ผ๋ฉด..

~cpp 
// copy •Œ๊ณ ๋ฆฌฆ˜„ ดšฉ•œ๋‹ค.
vector<Object> a,b;

b.clear();
copy( a.begin() + a.size() / 2, a.end(), back_inserter(b)) ;

  • –ด๋А  •๋„ •Œ๊ณ , ตˆ™•œ ‚ฌ๋žŒด๋ฉด ๋‹คŒ๊ณผ ๊ฐ™ด..

~cpp 
// assign ๋ฉ”†Œ๋“œ๋ฅผ ‚ฌšฉ•œ๋‹ค.
vector<Object> a,b;

b.assign(a.begin() + a.size() / 2, a.end());

  • ด ๋„ค ๊ฐ€ง€ ๋ฐฉ๋ฒ•„ ๋ณดž. ฒซ๋ฒˆงธ ๋‘๋ฒˆงธ ๋ฐฉ๋ฒ•€ ๋ฃจ”„๋ฅผ ‚ฌšฉ•œ๋‹ค. ๋‘๋ฒˆงธ ๋ฐฉ๋ฒ•— ๋ฃจ”„๊ฐ€ –ด๋”จ๋ƒ๊ณ  ๋ฌผœผ๋ฉด ๋‚˜๋Š” ๋ชจ๋ฅธ๋‹ค. copy •Œ๊ณ ๋ฆฌฆ˜ ๋‚ด๋ถ€—„œ ๋ฃจ”„๋ฅผ ‚ฌšฉ•œ๋‹จ๋‹ค. •˜ง€๋งŒ assign ๋ฉ”†Œ๋“œ๋Š” ๋ฃจ”„๋ฅผ ‚ฌšฉ•˜ง€ •Š๊ณ  •œ๋ฒˆ— ง ! •ดฃผ๋Š”๊ฐ ๊ฐ™๋‹ค.

  • copy, push_back ด๋Ÿฐ๊ฒƒ€ ๋„–ด„๋•Œ insert iterator๋ฅผ ‚ฌšฉ•œ๋‹ค. ฆ‰, •˜๋‚˜ ๋„ฃ๊ณ  ๋ฉ”๋ชจ๋ฆฌ • ๋‹น •ดฃผ๊ณ , ๊ฐฒด ๋ณต‚ฌ•˜๊ณ (ฐ ๊ฐฒด๋ฉด... --; ๋ฌต๋…), ๋˜ •˜๋‚˜ ๋„–ดฃผ๊ณ   € ง“•˜๊ณ .. ด๋Ÿฐ๊ฒƒด๋‹ค. •˜ง€๋งŒ assign€ ๋˜‘๊ฐ™€ ž‘—…„ •œ๋ฒˆ— ง ~, ๋งŒ•ฝ 100๊ฐœ˜ ๊ฐฒด๋ฅผ ๋„ฃ๋Š”๋‹ค๋ฉด assign€ copyด๋Ÿฐ๊ฒƒ๋ณด๋‹ค 1/100 ๋ฐ–— ‹œ๊ฐ„ด •ˆธ๋ฆฐ๋‹ค๋Š” ๊ฒƒด๋‹ค.( •™••˜„ •Š๊ฒ ง€๋งŒ.. ๋ญ ๊ทธ๋Ÿฌ•˜๋‹ค.)

  • ๋˜ •˜๋‚˜˜ ๋ฌธ œ , insert ๋ฉ”†Œ๋“œ๋Š” ‹ค–‰• ๋•Œ๋งˆ๋‹ค ƒˆ๋กœšด ๊ณต๊ฐ„„ • ๋‹น•˜๊ธฐ œ„•ด •˜๋‚˜”ฉ ๋ฐ€๋ฆฐ๋‹ค. ๋งŒ•ฝ ปจ…Œด๋„ˆ๊ฐ€ n๊ฐœ˜ ๊ฐฒด๋ฅผ ๊ฐ€ง€๊ณ  žˆ๊ณ , ๊ฐ๊ธฐ๋‹ค m๊ฐœ˜ ๊ฐฒด๋ฅผ insert๋กœ ๋„œผ๋ฉด.. n*m๋งŒผ ๋’ค๋กœ ๋•ก๊ธฐ๋А๋ผ ‹œ๊ฐ„„ ๋‚ญ๋น„•˜๊ฒŒ ๋œ๋‹ค. int๊ฐ™€ ๊ธฐ๋ณธ ž๋ฃŒ˜•ด๋ฉด ๊ดœฐฎ„ง€๋„ ๋ชจ๋ฅดง€๋งŒ.. ๋งŒ•ฝ— ๊ฐฒด๊ฐ€ ฐ ๊ฒฝšฐ๋ผ๋ฉด, ๋Œ€ž… —ฐ‚ฐž, ๋ณต‚ฌ ƒ„ž ด๋Ÿฐ๊ฒƒ๋„  €๋งŒผ ˜ธถœ•˜๊ฒŒ ๋œ๋‹ค. ๋ฏธนœ๋‹ค.

  • range ๋ฉค๋ฒ„ ๋ฉ”†Œ๋“œ๋Š” ฃผ–ด„ ๋‘๊ฐœ˜ ๋ฐ˜๋ณตž๋กœ ฌ๊ธฐ๋ฅผ ๊ณ„‚ฐ•ด„œ •œ๋ฒˆ— ˜ฎ๊ธฐ๊ณ  ๋„ฃ๋Š”๋‹ค. ๋ฒก„ฐ๋ฅผ ˜ˆ๋กœ ๋“ค๋ฉด, ๋งŒ•ฝ— ฃผ–ด„ ๊ณต๊ฐ„ด ๊ฝ‰ ฐผ„๋•Œ, insert๋ฅผ ˆ˜–‰•˜๋ฉด, ƒˆ๋กœšด ๊ณต๊ฐ„ • ๋‹น•ด„œ ง€๊ธˆ˜ ๋‚ดšฉ๋“ค๊ณผ, ๋„œผ๋ ค๋Š” ๊ฒƒ๋“ค„ ๊ทธ๋ฆฌ๋กœ ˜ฎ๊ธฐ๊ณ  ง€๊ธˆ žˆ๋Š”๊ง€šฐ๋Š” ž‘—…ด ˆ˜–‰๋œ๋‹ค. ดง“„ 100๋ฒˆ •ด๋ณด๋ผ, ปด“จ„ฐ๊ฐ€ ƒ๋‹นžˆ ๊ธฐ๋ถ„๋‚˜๋น • ง€๋„ ๋ชจ๋ฅธ๋‹ค. •˜ง€๋งŒ range ๋ฉค๋ฒ„ ๋ฉ”†Œ๋“œ๋Š” ๋ฏธ๋ฆฌ ๋Š˜๋ ค•ผ •  ฌ๊ธฐ๋ฅผ •Œ๊ธฐ ๋•Œ๋ฌธ— •œ๋ฒˆ๋งŒ •˜๋ฉด ๋œ๋‹ค.

  • „๋Šฅ ๋”ฐง€๊ธฐ ๊ณจน˜ •„”ˆ ‚ฌ๋žŒด๋ผ๋„, range ‹œ๋ฆฌˆ๊ฐ€ •˜๋‚˜”ฉ ‹œ๋ฆฌˆ๋ณด๋‹ค ƒ€ด•‘ –‘ด  ๋‹ค๋Š” ๊•Œ๊ฒƒด๋‹ค.



6. Item6. Be alery for c++'s most vexing parse

6.1. ๋ฌธ œ ?

  • •„ง๊นŒง€๋„ STL„ ™„๋ฒฝ•˜๊ฒŒ ง€›•˜๋Š” ปดŒŒผ๋Ÿฌ๋Š” กดžฌ•˜ง€ •Š๋Š”๋‹ค.
  • žŠ–ด๋ฒ„๋ฆฌ๊ณ  žˆ—ˆ๋˜ ด๋ž˜Šค˜ ƒ„ž— ๊ด€•œ..

~cpp 
class Widget {...};    // ๋””ดŠธ ƒ„ž๊ฐ€ žˆ๋‹ค๊ณ  ๊ฐ€ •
Widget a               // ๋งž๋‹ค.
Widget b()             // ๊ณผ—ฐ?
  • Widget b() ด๊ฒƒ€ Widget˜•˜ ๊ฐฒด๋ฅผ ๋ฆฌ„•ดฃผ๋Š” b๋ผ๋Š” ด๋ฆ„„ ๊ฐ€„ •จˆ˜๋‹ค. ด๊ฒƒ๊ณผ ๊ด€๋ จ•ด ŒŒ‹ —๋Ÿฌ๊ฐ€ žฃผ ผ–ด๋‚œ๋‹ค๊ณ  •œ๋‹ค.

6.2. ˜ˆ œ : ints.dat —  €žฅ๋˜–ด žˆ๋Š”  •ˆ˜๋“ค„ ฝ–ด„œ list<int> data— “ฐ๋Š” ž‘—…„ •œ๋‹ค.


~cpp 
ifstream dataFile("ints.dat");
list<int> data(ifstream_iterator<int>(dataFile),ifstream_iterator<int>());     // ด๋Ÿฐ ๋ฐฉ๋ฒ•๋„ žˆ๊ตฐ. ๋‚œ ๋งจ๋‚  ๋Œ๋ ค๊ฐ€๋ฉด„œ ๋„—ˆ๋Š”๋ฐ..--;

  • ™ ง€๋Š” ๋ชจ๋ฅด๊ฒ ง€๋งŒ ๋‘๋ฒˆงธ ๋ฌธžฅ€ ž‘๋™•˜ง€ •Š๋Š”๋‹ค. œ„—„œ  œ๊ธฐ•œ ๋ฌธ œ ๋•Œ๋ฌธ(๊ด„˜ธ— ๊ด€๋ จ๋œ)ด๋‹ค. ๋ณ„๋ฃจ ค‘š”•œ ๊ฒƒ ๊ฐ™„ •Šœผ๋‹ˆ ๊ทธ๋ƒฅ ๋„˜–ด๊ฐ. ๊ทธ๋ž˜๋„ •ด๊ฒฐ…€..

6.3. •ด๊ฒฐ…

~cpp 
ifstream dataFile("ints.dat");
ifstream_iterator<int> dataBegin(dataFile);
ifstream_iterator<int> dataEnd;

list<int> data(dataBegin, dataEnd);         // š”๋Ÿฐ‹œผ๋กœ จฃผž.

6.4. žก๋‹ด

  • C++ด ด๋ ‡๊ฒŒ • ๋งค•œ„€ ๋ชฐ๋ž๋‹ค.
  • STL—„œ ๋ฐ˜๋ณตž๋กœ ๋Œ๋ฆฌ๋Š”๊‘œค€ Šคƒ€ผด๋ž€๋‹ค. ๊ทธ๋ ‡๊ฒŒ •˜๋„๋ก •˜ž.



7. Item7. When using containers of newed pointers, remember to delete the pointers before the container is destroyed

7.1. „œ๋ก 

  • ˆ„ˆ„žˆ ๊ฐ•กฐ–ˆ๋˜ new๋กœ ๋งŒ๋“ ๊ฐ ๋„—ˆœผ๋ฉด, delete •ดฃผž๋Š” ๊ฒƒด๋‹ค.
  • ปจ…Œด๋„ˆ๊ฐ€ ŒŒ๊ดด๋ ๋•Œ ฌธ„ฐ๋Š” ง€›Œฃผ๊ฒ ง€๋งŒ, ฌธ„ฐ๊ฐ€ ๊ฐ€๋ฆฌ‚ค๋Š” ๊ฐฒด๋Š” destroy๋˜ง€ •Š๋Š”๋‹ค.(Detected Memory Leaks!)

7.2. ˜ˆ œ

~cpp 
vector<Object*> v;

for(int i = 0 ; i < 10 ; ++i)
	v.push_back(new Object); // new๋กœ ๋„–ดคฌ๋‹ค.

...
...

for(vector<Object*>::iterator i = v.begin() ; i != v.end() ; ++i)
	delete *i // ง€›Œฃผž.

return 0;

  • •˜ง€๋งŒ ... ๋ถ€๋ถ„—„œ ˜ˆ™ธ๊ฐ€ „ ธ„œ ”„๋กœ๊ทธ๋žจด ๋๋‚˜๋ฒ„๋ฆฐ๋‹ค๋ฉด? ๋˜๋‹ค‹œ Detected Memory Leaks!

7.3. ๋ณด™„๋ฒ• 1(class for function object)

  • ด๋ฅผ ๋ณด™„•˜๊ธฐ œ„•ด delete๋ฅผ •จˆ˜ ๊ฐฒด๋กœ ๋งŒ๋“œ๋Š” ๋ฒ•ด žˆ๋‹ค.(๋ญ•ผ ด๊ฐ?)
    • Fucntion Object ๋ณด†ต class‚ค›Œ๋“œ๋ฅผ “ฐ๋˜๋ฐ, struct(ด•˜ class๋ผ๊ณ  ”€)๋ฅผ จ๋†จ๊ตฐ. ๋ญ, ๋ณ„ ƒ๊ด€—†ง€๋งŒ, ๋‚ด๋ถ€ ธž —†ด •จˆ˜๋งŒœผ๋กœ ๊ตฌ„๋œ classด๋‹ค. STL—„œ Generic „ ๊ตฌ˜„•˜๊ธฐ— ฃผšจ•œ ๋ฐฉ๋ฒ•ด๊ณ , •จˆ˜๋กœ๋งŒ ๊ตฌ„๋˜–ด žˆ–ด„œ, ปดŒŒผ‹œ—  „๋ถ€ inline‹œ‚ฌˆ˜ žˆ๊ธฐ ๋•Œ๋ฌธ— ตœ ™” ๋ฌธ œ๋ฅผ •ด๊ฒฐ–ˆŒ. ˜ค ๋ถ€ง€๋Ÿฐžˆ ๋ณด๋Š”๊ฐ€ ๋ณด๋„ค. ๋‚˜˜ ๊ฒฝŸ‹ฌ„ ž๊ทน ‹œ‚ค๋Š” ^^;; --ƒ๋ฏผ

~cpp 
struct DeleteObject : public unary_function<const T*, void>
{
         template<typename T>
	void operator()(const T* ptr) const
	{
		delete PTR;
	}
};

void f()
{
	...
	for_each(v.begin(), v.End(), DeleteObject());    //  •๋ง ดƒ•˜๊ตฐ..--;
}
  • ๋ฐ‘—๊บผ “ฐ๊ณ  ๋ง๋ถ™ด๋Š” ๊ด๋ฐ ด ๋ฐฉ๋ฒ•€ —ด๋ผ •ˆข‹€ ๊ฐ๋ž€๋‹ค.(struct DeleteObject, ณ‡ ๊ทธ๋Ÿฌ๋ฉด„œ ๋ญ•˜๋Ÿฌ „ค๋ช…•ด?-.-)

7.4. ๋ณด™„๋ฒ• 2(Smart Pointer)

  • ๋˜ ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•œผ๋กœ ปจ…Œด๋„ˆ— ฌธ„ฐ๋ฅผ ๋„ฃ๋Š” ๋Œ€‹  Šค๋งˆŠธ ฌธ„ฐ๋ฅผ ๋„ฃ๋Š” ๊ฒƒด๋‹ค.(•„•…..--; MDC++(MEC++)„ ๋ด•ผ •˜๋Š”๊ฐ€..ใ… .ใ… )

~cpp 
typedef boost::shared_ptr<Object> SPO;	// boost ๋ผด๋ธŒ๋Ÿฌ๋ฆฌ๋ผ๋Š”๊ฒŒ žˆ๋‹จ๋‹ค.

vector<SPO> v;
for(int i = 0 ; i < 10 ; ++i)
	v.push_back(SPO(new Object));



8. Item8. Never create containers of auto_ptrs.

  • ƒ๋žต. ๋„๋ฌดง€ ๋ญ”๋ง•˜๋Š”๊ง€ ๋ชจ๋ฅด๊ฒ ๋‹ค. COAP๋Š” ๋˜ ๋ญ๊ณ ..--;
    • ปจ…Œด๋„ˆ๋ฅผ ˜ค†  ฌธ„ฐ๋กœ ƒ„•˜ง€ ๋ง๊ฒƒ~


9. Item9. Choose carefully among erasing options.

9.1. –ด๋–ค ปจ…Œด๋„ˆ๊ฐ€ int๊ฐ’๋“ค„ ๋‹ด๊ณ  žˆ๋‹ค๊ณ  •˜ž. ๊ฐ๊ธฐ„œ 1982 ๋ผ๋Š” ˆž๋ฅผ ๋ชฝ๋•… ง€›Œฃผ๊ณ  ‹ถ๋‹ค๋ฉด?

  • Contiguous-memory container ผ๋•Œ

~cpp 
c.erase( remove(c.begin(), c.end(), 1982), c.end() );        // ด๊ด ๋‚ด๋ถ€ œผ๋กœ –ด๋–ป๊ฒŒ ๋Œ•„๊ฐ€๋Š” ๊ธ๊นŒ. ฐพ•„๋ด•ผ๊ฒ ๊ตฐ. 
  • listผ๋•Œ - erase จ๋„ ๋˜ง€๋งŒ remove๊ฐ€ ๋” šจœจ ด๋‹ค.

~cpp 
c.remove(1982);
  • Associative container ผ๋•Œ - remove“ฐ๋ฉด ๋‚œ๋ฆฌ๋‚œ๋‹ค.(—†œผ๋‹ˆ๊น--;) ๋˜  œ๋„ค๋ฆญ •Œ๊ณ ๋ฆฌฆ˜ remove๋„ —ญ‹œ •ˆ๋œ๋‹ค. ปจ…Œด๋„ˆ๊ฐ€ ๋ง๊ฐ€ˆˆ˜๋„ žˆ๋‹ค.

~cpp 
c.erase(1982);

9.2. กฐ๊ด ๊ฒ€‚ฌ•ด„œ ๋ชฝ๋•… ง€›Œฃผ๊ธฐ

  • ๋˜ ดƒ•œ Œด žˆ๊ตฐ. bool˜•„ ๋ฆฌ„•˜๋Š” •จˆ˜๋ฅผ ธž๋กœ ๊ฐ™ด ๋„–ดฃผ๋ฉด ๊ทธ กฐ๊„ ๋งŒ•˜๋Š” ๊ฐ’€ ๋ชจกฐ๋ฆฌ ง€›Œฃผ๋Š”..(•จˆ˜ ฌธ„ผ๊นŒ.. •จˆ˜ ฌธ„ฐ๋Š” •„ง๋„ –ธ œ “ฐ๋Š”๊ง€ ๋ชจ๋ฅด๊ฒ ๋‹ค. ˜น‹œ •„‹œ๋Š”๋ถ„€ ข€ ๊ฐ€๋ฅดณ ฃผ„š”^^;)
    • •จˆ˜ฌธ„ž„. (๋˜๋Š” œ„—„œ˜ •จˆ˜๊ฐฒด.) •ด๋‹น •จˆ˜ ๊ฐฒด๋กœ กฐ๊„ ŒŒ•…•œ๋’ค ‚ญ œ•˜๊ฐ๋‚˜ ๋น„๊ต,†ŒŠธ •˜๋Š” ผ„ ๋งŽด •จ. --1002

9.2.1. ‰ฝ๊ฒŒ • ˆ˜ žˆ๋Š” ปจ…Œด๋„ˆ๋“ค

~cpp 
bool badValue(int x) { ... }    // ๋„–ด„ •จˆ˜ „ –ธ

~cpp 
c.erase( remove_if(c.begin(), c.end(), badValue), c.end() );    // Contiguous-memory Containerผ๋•Œ(vector, deque, string)

~cpp 
c.remove_if(badValue);    // listผ๋•Œ

9.2.2. Associative Container ผ๋•Œ

  • ‰ฝง€๋งŒ ๋น„šจœจ ธ ๋ฐฉ๋ฒ• - remove_copy_if ๋ฅผ ‚ฌšฉ•œ๋‹ค. ด๊ฒƒ€ ง€šฐ๊ณ  ‹ถ€๊ œ™ธ•œ ๋‚˜๋จธง€ ๊ฒƒ๋“ค„ ƒˆ๋กœšด ปจ…Œด๋„ˆ๋กœ ˜ฎ๊ธด๋‹ค. ๊ทธ ๋‹คŒ— ›๋ž˜ ปจ…Œด๋„ˆ๋ฅผ ƒˆ๋กœ ๋งŒ๋“ ๊ฒƒ๊ณผ ๋ฐ”๊ฟ” ๋ฒ„๋ฆฐ๋‹ค.(šฐšธ•˜๊ตฐ--;)

~cpp 
AssocContainer<int> c;    // map,multimap,set,multiset ๋“„ ผ๋ฐ˜™”•œ ด๋ฆ„ด๋‹ค. ‹ค œ๋กœ  €๋Ÿฐ ด๋ฆ„˜ ปจ…Œด๋„ˆ๋Š” —†๋‹ค.--;
...
AssocContainer<int> goodValues;

remove_copy_if(c.begin(), c.end(), inserter(goodValues, goodValues.end()), badValue);     // —‰ ด๋ถ„๋ฒ•--;. ๋ณด๋ฉด„œ ๋А๋ผ๋Š” ๊ง€๋งŒ  •๋ง ‹ ๊ธฐ•œ๊ฐ ๋งŽ๋‹ค.  €๋Ÿฐ ๊ฒƒ๋“ค„ ๋„๋Œ€ฒด ๋ฌดŠจ ƒ๊ฐœผ๋กœ ๊ตฌ˜„–ˆ„ง€..

c.swap(goodValues);       // c๋ž‘ goodValues๋ž‘ ๋ฐ”๊พผ๋‹ค. ด๋Ÿฐ๊ฒƒ๋„ žˆ๊ตฐ.
  • –ด๋ ตง€๋งŒ šจœจ ธ ๋ฐฉ๋ฒ• - ๋ญ ๋˜ ŒŒผ— “ด๋‹ค๊ณ  •ด„œ ดƒ•œ๋ฐฉ๋ฒ• “ฐ๋Š”๋ฐ ๊ทธ๋ƒฅ ๋„˜๊ฒผ๋‹ค.

~cpp 
AssocContainer<int> c;

for(AssocContainer<int>::iterator i = c.begin() ; c != c.end() ; )
{
    if(badValue(*i))
    {
        c.erase(i++);     // ง€›Œ•ผ •  ๊ฐ’ด๋ฉด ผ๋‹จ ง€šฐ๊ณ  ๋ฐ˜๋ณตž •˜๋‚˜ ฆ๊ฐ€‹œผœค€๋‹ค. ›„œ„ —ฐ‚ฐž๋Š” ๊ทธ ๊ฐ’„ ๋ฏธ๋ฆฌ ๋ณต‚ฌ๋ฅผ •˜๊ธฐ &#46468;๋ฌธ— ๊ฐ€๋Šฅ•œ ผด๋‹ค. 
    }                     // ๊ทธ๋ƒฅ ง€šฐ๋ฉด ๊ทธ ๋ฐ˜๋ณตž๋Š” void๊ฐ€ ๋œ๋‹ค. •ˆข‹๋‹ค--;
    else ++i;             // •„๋‹ˆ๋ฉด ๊ทธ๋ƒฅ ฆ๊ฐ€
}

9.3. žก๋‹ด

  • ๋ฐ˜๋ณตž๋ฅผ ดšฉ•ด„œ ๋ฃจ”„๋ฅผ ๋Œ๋‹ค๊ฐ€ –ด๋–ค ๊ง€šฐ๋ฉด, ๊ทธ๊ธ ๊ฐ€๋ฆฌ‚ค๊ณ  žˆ๋˜ ๋ฐ˜๋ณตž๋Š” ๊ฐ‹ ๋œ๋‹ค. ๋‹คŒ— –ด๋–ป๊ฒŒ ๋ ง€ žฅ๋‹ด ๋ชป•œ๋‹ค๋Š” ๋œปด๋‹ค. ฃผ˜•˜ž.


10. Item10. Be aware of allocator conventions and restrictions.


11. Item11. Understand the legitimte uses of custom allocators.


12. Item12. Have realistic expectations about the thread safety of STL containers.

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