- STL์ ๊ตฌ์ฑํ๋ ํต์ฌ ์์์๋ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์๋ค.(Iterator, Generic Algorithm, Container ๋ฑ๋ฑ). ์ญ์ ๊ฐ์ฅ ํต์ฌ์ ์ด๊ณ , ์กฐ๊ธ๋ง ์์๋ ์ธ์ ์๊ณ , ํธํ๊ฒ ์ธ์ ์๋ ๊ฒ์ Container๋ค. Container๋ Vector, List, Deque ๊ณผ ๊ฐ์ด ๋ฐ์ดํฐ๋ฅผ ๋ด๋ ๊ทธ๋ฆ๊ณผ ๊ฐ์ Object๋ผ๊ณ ๋ณด๋ฉด ๋๋ค.
- STL์ Container๋ค์ ์ฅ์ ์ด๋ผ๊ณ ํ๋ค๋ฉด, ์ญ์ ์ ์ฐ์ฑ, ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ์์์ ํ๊ธฐ, ์์ ์ด ์์์ ๋์๋ค ์ฆ์๋ค ํ๊ธฐ ๋ฑ๋ฑ์ด ์๊ฒ ๋ค. ๋ํ ์ธํฐํ์ด์ค๊ฐ ์ด๊ฑฐ๋ ์ ๊ฑฐ๋ ๋น์ท๋น์ทํด์ ํ๋๋ง ๊ณต๋ถํ๋ฉด, ์ฝ๊ฒ ๋ค๋ฅธ๊ฒ๋ ์ธ์ ์๋ค๋ ๊ฒ๋ ๋ ํ๋์ ์ฅ์ ์ด ๋ ์ ์๊ฒ ๋ค.
- ํฐ 1์ฅ Containers์์๋ ์ํฉ์ ๋ง๋ ์ ์ ํ Container ๊ณ ๋ฅด๋ ๋ฒ, ํจ์จ์ฑ ๊ทน๋ํ ํ๊ธฐ ๋ฑ๋ฑ์ ๋ค๋ฃฌ๋ค.
Contents
- 1. Item1. Choose your containers with care.
- 2. Item2. Beware the illusion of container-independant code.
- 3. Item3. Make copying cheap and correct for objects in containers.
- 4. Item4. Call empty instead of checking size() against zero.
- 5. Item5. Prefer range member functions to their single-element counterparts.
- 6. Item6. Be alery for c++'s most vexing parse
- 7. Item7. When using containers of newed pointers, remember to delete the pointers before the container is destroyed
- 8. Item8. Never create containers of auto_ptrs.
- 9. Item9. Choose carefully among erasing options.
- 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.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
- 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.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.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 ๋ฉ์๋๋ ๋ฃจํ๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ํ๋ฒ์ ์ง ! ํด์ฃผ๋๊ฑฐ ๊ฐ๋ค.
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์ํฌ์ ์๊ธฐ ๋๋ฌธ์ ์ต์ ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์. ์ค ๋ถ์ง๋ฐํ ๋ณด๋๊ฐ ๋ณด๋ค. ๋์ ๊ฒฝ์์ฌ์ ์๊ทน ์ํค๋ ^^;; --์๋ฏผ
- 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.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
- ํจ์ํฌ์ธํฐ์. (๋๋ ์์์์ ํจ์๊ฐ์ฒด.) ํด๋น ํจ์ ๊ฐ์ฒด๋ก ์กฐ๊ฑด์ ํ์
ํ๋ค ์ญ์ ํ๊ฑฐ๋ ๋น๊ต,์ํธ ํ๋ ์ผ์ ๋ง์ด ํจ. --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++); // ์ง์์ผ ํ ๊ฐ์ด๋ฉด ์ผ๋จ ์ง์ฐ๊ณ ๋ฐ๋ณต์ ํ๋ ์ฆ๊ฐ์์ผ์ค๋ค. ํ์ ์ฐ์ฐ์๋ ๊ทธ ๊ฐ์ ๋ฏธ๋ฆฌ ๋ณต์ฌ๋ฅผ ํ๊ธฐ 떄๋ฌธ์ ๊ฐ๋ฅํ ์ผ์ด๋ค.
} // ๊ทธ๋ฅ ์ง์ฐ๋ฉด ๊ทธ ๋ฐ๋ณต์๋ void๊ฐ ๋๋ค. ์์ข๋ค--;
else ++i; // ์๋๋ฉด ๊ทธ๋ฅ ์ฆ๊ฐ
}
9.3. ์ก๋ด ¶
- ๋ฐ๋ณต์๋ฅผ ์ด์ฉํด์ ๋ฃจํ๋ฅผ ๋๋ค๊ฐ ์ด๋ค ๊ฑธ ์ง์ฐ๋ฉด, ๊ทธ๊ฑธ ๊ฐ๋ฆฌํค๊ณ ์๋ ๋ฐ๋ณต์๋ ๊ฐฑ์ ๋๋ค. ๋ค์์ ์ด๋ป๊ฒ ๋ ์ง ์ฅ๋ด ๋ชปํ๋ค๋ ๋ป์ด๋ค. ์ฃผ์ํ์.
