STL.NET Primer (2/4) ์์ ์ด์ด์ง๋ ๊ธ์
๋๋ค.๊ธฐ๋ฐ ์ง์ ์ ์
STL.NET ์ ์์๊ฐ๋ ๋ฐ๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์์ต๋๋ค: ํ๋๋ STL๊ณผ STL.NET์ ์ฐจ์ด์ ์ ์์๋ณด๋ ๊ฒ์ด๊ณ , ๋ค๋ฅธ ํ๋๋ STL๊ณผ STL.NET์ด ๊ณตํต์ ์ ์์๋ณด๋ ๊ฒ์
๋๋ค. ์ด ๋์ ์ฐจ์ด์ ์ ๋์ดํ๋ ๊ฒ์ ์ด๋ฏธ STL์ ๋ง๋ณด์๋ ์ฌ๋์๊ฒ๋ง ์๋ซ์ ๋ฒํ๊ธฐ ๋๋ฌธ์, (๋
ํ ์ฐ๊ธฐ๋ก ์ง์์ํค๋ ๋ฏํ) ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฏ์ ๋ถ๋ถ์ ๋ํ ์ค๋ช
์ ํผํ๋ ๊ฒ์ด ์ข์ ๋ฏ ํฉ๋๋ค. ๋งํ์๋ฉด, ์ปจํ
์ด๋์ ์ธ๋ฐํ ํน์ง, ๊ทธ๋ฆฌ๊ณ ย Systemย ์ปฌ๋ ์
๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ํธ์ด์ฉ ์๋ฆฌ๋ผ๋ ๋ํดํ ๋ถ๋ถ์ ๋ํด์๋ ์ค๋ช
์ ์์ ํ๊ฒ ๋ค๋ ๋ป์
๋๋ค. ๋ฌผ๋ก ์ด๋ค ์ฌํญ๋ ํฅ๋ฏธ๋ก์ด ๋ถ๋ถ์ด๊ธด ํฉ๋๋ค. ํ์ง๋ง ์ด๋ค ์ฌํญ์ ๋ํ ์ค๋ช
์ ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๊น์ด ๋น ์ง ์๋ก์ด ๋๊ตฐ๊ฐ์ ๋ชซ์ผ๋ก ๋จ๊ฒจ๋๋ ํธ์ด ๋ ๋ฌ์ง ์์๊น์? ์ด๊ฒ์ด ๋ฐ๋ก ์๋์ ์ด์ด์ง ๋ด์ฉ - ์
๋ฌธ์๋ฅผ ์ํ ๋ด์ฉ- ์ ๋ด๊ธด ์ ์ ์๋์
๋๋ค. ์ด๋ฐ ๋ฐฉ๋ฒ์ ์ทจํจ์ผ๋ก์จ ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ฒ์ ๋ฐ์ ๋ด๋๋ ์ฌ๋์, STL๊ณผ STL.NET ๋ชจ๋๊ฐ ์ ๊ณตํ๋ ํ์ฅ๋ ๋ชจ๋ธ, ์ฆ ๋งค๊ฐ๋ณ์ํ๋(parameterized) ์ปฌ๋ ์
์ ๊ธฐ๋ถ์ข๊ฒ ๋ค๊ฐ๊ฐ ์ ์์ ๊ฒ์
๋๋ค.
๊ทธ๋ ๋ค๋ฉด STL๊ณผ STL.NET์ด ๊ณต์ ํ๋ ๋ถ๋ถ์ ๋ฌด์์ผ๊น์? ์ด ๋ ๋ชจ๋ ์์ฐจ(sequential) ์ปจํ
์ด๋์ ์ฐ๊ด(associative) ์ปจํ
์ด๋์ด๋ ๋ ๊ฐ์ ๊ธฐ๋ณธ ์ปดํฌ๋ํธ์ ์ง๋ค๋ฆญ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ๊ตฌ์ฑ๋์ด ์๋ค๋ ๊ฒ์
๋๋ค. (๋ง์ต๋๋ค. ์ฌ๋ฌ๋ถ์ด STL์ ์ต์ํ ๊ฐ๋ฐ์๋ผ๋ฉด, ์ด๋ค ๋ด์ฉ์ด ์ด์ด์ง์ง ์๊ณ ์์ ๊ฒ์
๋๋ค. ๊ทธ๋ ๋ค ํ๋๋ผ๋, ์ด ์ ์ ๊ธฐ๋ณธ ์ฉ์ด์ ๊ธฐ๋ฐ ์ง์์ ์ค๋ช
ํ๋ ๋ฐ ํ ์ ๋์๊ธฐ ๋๋ฌธ์, ๊ทธ๋ฌํ ์ฌ๋ฌ๋ถ์ ์ธ๋ด์ฌ์ ์์ฒญํ๋ ๋ฐ์
๋๋ค.) ์ง๋ค๋ฆญ ์๊ณ ๋ฆฌ์ฆ์ ์ปจํ
์ด๋ ํ์
์ ์ง์ ์ ์ผ๋ก ์ด์ฉ๋์ง ์์ต๋๋ค. ๊ทธ ๋์ , ์ด๋ค ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํ ์์์ ๋ฒ์๋ฅผ ๋ํ๋ด๋ ๋ฐ๋ณต์(iterator)๊ฐ ๋์ด๊ฐ๋๋ฐ, ํต์ ์ด๋ค ๋ฐ๋ณต์๋ฅผ ๊ฐ๋ฆฌ์ผ first์ last๋ผ ์นญํฉ๋๋ค. ๊ณต์์ ์ผ๋ก ์ข์ธก ํฌํจ ๊ฐ๊ฒฉ(left-inclusive interval)์ด๋ผ ์ด๋ฆ๋ถ์ ์๋์ ์์ ๋ฒ์ ํ๊ธฐ๋ฒ์,
// "first์ last๊น์ง์ ๋ชจ๋ ์์๋ฅผ ํฌํจํ์ง๋ง last๋
// ํฌํจํ์ง ์์ต๋๋ค." ๋ผ๋ ์๋ฏธ๋ฅผ ๊ฐ์ต๋๋ค.
[ first, last )
C++
๋ณต์ฌ
๋ฒ์๊ฐย first์์ย last๊น์ง์ง๋ง (first์๋ ๋ฌ๋ฆฌ)ย last๋ ํฌํจ๋์ง ์์์ ๋ํ๋
๋๋ค.ย first์ย last๊ฐ ๊ฐ์ ๊ฒฝ์ฐ์๋ ๊ทธ ๋ฒ์ ์์ ์ด๋ ํ ์์๋ ์๋ค๋ ๋ป์
๋๋ค.
์์ฐจ(sequential) ์ปจํ
์ด๋์๋ ๋จ์ผ ํ์
์ผ๋ก ์ด๋ฃจ์ด์ง ์ ๋๋ ์์๋ค์ด ๋ด๊ฒจ ์์ต๋๋ค. ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์์ฐจ ์ปจํ
์ด๋๋ย vector์ย listย ํ์
์
๋๋ค. (์ธ ๋ฒ์งธ ์์ฐจ ์ปจํ
์ด๋์ธ - '๋ฐํฌ'๋ผ๊ณ ์ฝ์ต๋๋ค - ๋ย vector์ฒ๋ผ ๋์ํ์ง๋ง, ๋งจ ์ ์์์ ๋ํ ํจ์จ์ ์ธ ์ฝ์
๊ณผ ์ญ์ ์ ํนํ๋์ด ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ํ(queue)๋ฅผ ๊ตฌํํ ๋๋ย vector๋ณด๋ค๋ย deque๊ฐ ๋ ๋ฌ์ต๋๋ค.)
์์ฐจ ์ปจํ
์ด๋ ํ์
๋ฅผ ์ฐธ์กฐํ๊ธฐ์ ์์ ํด์ผํ ๊ฒ์, ๋ค์์ ํค๋ ํ์ผ ์ค์์ ์ ์ ํ ํ์ผ์ ํฌํจํ๋ ๊ฒ์
๋๋ค.
#include <cli/vector>
#include <cli/list>
#include <cli/deque>
C++
๋ณต์ฌ
์ด๋ค ํค๋ ํ์ผ์๋ย interface_vector์ ๊ฐ์ ๊ณต์ ๋๋ ๊ธฐ์ด ์ธํฐํ์ด์ค์ ์ ์ธ๋ถ์,ย generic_vector๋ฑ์ ์ด๋ค ์ปจํ
์ด๋์ ํ์ ๋ป ์ปจํ
์ด๋๋ ํจ๊ป ๋ด๊ฒจ ์์ต๋๋ค.
STL.NET ์ปจํ
์ด๋๋ ์ฐธ์กฐ ํ์
์
๋๋ค. ์ปจํ
์ด๋ ์ ์ธ๋ถ์๋ ํธ๋ํน ํธ๋ค(tracking handle)์ด ์๋๋ฐ, ์ด๋ ์๋์ ์ผ๋กย nullptr๋ก ์ด๊ธฐํ๋ฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๋ย gcnewย ์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ ์ค์ ์ปจํ
์ด๋๋ฅผ ํ ๋นํ๊ฒ ๋ฉ๋๋ค. ์ด์ ์ ์์ ์ด๋ฏธ ์ด๋ฅผ ๊ฐ๋จํ๊ฒ ๋ณด์ฌ์ฃผ๊ธด ํ์ง๋ง, ์ฌ๊ธฐ์ ํ๋ฒ ๋ ๋ช
์ํ๋๋ก ํ์ฃ .
void f()
{
// ๋น vector๋ฅผ ํ ๋นํฉ๋๋ค . . .
vector<String^>^ = gcnew vector<String^>;
// ๊ธฐ๋ณธ์ ์ผ๋ก nullptr๋ก ๊ฐ๊ฐ ์ค์ ๋์ด ์๋
// 10๊ฐ ์์๊ฐ ๋ด๊ธด ๋ฆฌ์คํธ๋ฅผ ํ ๋นํฉ๋๋ค.
list<Object^>^ olist = gcnew list<Object^>( 10 );
// ํธ๋ํน ํธ๋ค์ nullptr๋ก ์๋ ์ค์ ๋ฉ๋๋ค.
deque<int>^ ideck;
// ๋ญ๊ฐ ํฅ๋ฏธ๋ก์ด ์ผ์ ํฉ๋๋ค . . .
};
C++
๋ณต์ฌ
์ฐ๊ด ์ปจํ
์ด๋์ ๋ํ ์ ์ธ๋ฒ๊ณผ ์ฉ๋ฒ์ ๊ดํด์๋ ์ด ์ฐ์ฌ๋ฌผ์ ๋ค์ ์ปฌ๋ผ์์ ๋ค๋ฃจ๋๋ก ํ๊ฒ ์ต๋๋ค.
์ฐ๊ด ์ปจํ
์ด๋๋ ์์์ ๋ณด๊ด๊ณผ ๋์ฐพ๊ธฐ(retrieval)์ ๋ํ ์ง์(query)๋ฅผ ํจ์จ์ ์ผ๋ก ์ง์ํฉ๋๋ค. ๊ธฐ๋ณธ์ ์ธ ๋ ๊ฐ์ง ์ฐ๊ด ์ปจํ
์ด๋ ํ์
์ย map๊ณผย set์ด์ฃ .ย map์ key์ value ์์ผ๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. key๋ ๊ฒ์์ ์ํด ์ฌ์ฉ๋๊ณ , value์๋ ์ ์ฅํ๊ณ ๋์ฐพ์์ฌ ๋ฐ์ดํฐ๊ฐ ๋ด๊น๋๋ค. ์๋ฅผ ๋ค์ด, ์ ํ๋ฒํธ๋ถ๋ ์์ฝ๊ฒย map์ ์ด์ฉํ์ฌ ๋ํ๋ผ ์ ์๋๋ฐ, ์ฌ๊ธฐ์ key๋ ๊ฐ๊ฐ์ ์ด๋ฆ์ ๋ํ๋ด๊ณ , value๋ ๊ทธ ์ด๋ฆ์ ์ฐ๊ด๋ ์ ํ ๋ฒํธ๋ฅผ ๋ํ๋
๋๋ค.
map์ ์์ ์ ๊ธฐ์ด๋ฅผ ์ด๋ฃจ๋ ํธ๋ฆฌ ์ถ์์ฒด(tree abstraction)์ ์ด์ฉํ์ฌ ์์๋ฅผ ์ค๋ฆ์์ผ๋ก ์ ๋ ฌํฉ๋๋ค.ย hash_mapย ์ปจํ
์ด๋๋ ๋์ฐพ๊ธฐ(retrieval) ๋ช
๋ น์ ์์ด ์ข๋ ํจ์จ์ ์
๋๋ค. ํ์ง๋งย hash_map์ ๋ฐ๋ณต(iteration)์ ๋ค์ ์์์ ์ธ ์์(random order)๋ก ๊ฐ ์์์ ์ ๊ทผ(access)ํฉ๋๋ค. ๋ง์ฝ ๋์ฐพ๊ธฐ๊ฐ ์ฃผ๋ ๋ชฉ์ ์ด๋ผ๋ฉดย hash_map์ ์ฌ์ฉํ๋ ํธ์ด ์ข์ต๋๋ค.
set์ ๋จ์ผ key ๊ฐ๋ค๋ก ๊ตฌ์ฑ๋๋ฉฐ, ๊ทธ ๊ฐ์ด ์กด์ฌํ๋์ง์ ๋ํ ์ง์(query)์ ํจ๊ณผ์ ์
๋๋ค. ์๋ฅผ ๋ค์ด, ํ
์คํธ ์ง์ ์์คํ
(text query system)์ ๋ง๋ค ๊ฒฝ์ฐ์๋ ํ
์คํธ์ ๋ด๊ธด ๋จ์ด๋ค๋ก ์ด๋ฃจ์ด์ง ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๊ตฌ์ถํ๊ธฐ ์ํด์ the, and, but๋ฑ๊ณผ ๊ฐ์ ์ ์ธ์ํฌ ์ผ๋ฐ ์ดํ ๋ชฉ๋ก์ด ํ์ํ ๊ฒ์
๋๋ค. ์ด ํ๋ก๊ทธ๋จ์ ํ
์คํธ์ ๋ด๊ธด ๊ฐ ๋จ์ด๋ฅผ ์ฐจ๋ก๋ก ์ฝ์ด, ์ฝ์ด๋ธ ๋จ์ด๊ฐ ์ ์ธ ๋จ์ด ๋ชฉ๋ก์ ์๋์ง๋ฅผ ๊ฒ์ฌํ๊ณ , ์ง์ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ๊ทธ ๋จ์ด๋ฅผ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํ๊ฑฐ๋ ๋ฒ๋ฆด ๊ฒ์
๋๋ค.ย set๋ฟ๋ง ์๋๋ผ,ย hash_set์ด๋ ์ปจํ
์ด๋๋ ์๋๋ฐ, ์ด๋ค ๊ฐ์ ์ผ๋ฐ์ ํน์ง์ย map๊ณผย hash_map๊ฐ์ ๋ณด์ด๋ ์ผ๋ฐ์ ํน์ง๊ณผ ๋์ผํฉ๋๋ค.
map๊ณผย set์ ๋ด๊ธธ ๊ฐ key๋ ๊ฐ๊ธฐ ์๋ก ๋ฌ๋ผ์ผ ํฉ๋๋ค. ํ์ง๋งย multimap๊ณผย multiset์ ์ค๋ณต๋ key๋ฅผ ํ์ฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์์ ์ ํ๋ฒํธ๋ถ๋ ํ ๊ฐ์ธ์ ์ํ ์ฌ๋ฌ ์ฌํญ์ด ๊ธฐ์ฌ๋ ์ ์์ด์ผ ํ ๊ฒ์
๋๋ค. ๋ฐ๋ก ์ด ๊ฒฝ์ฐ์ย multimap์ ์ฌ์ฉํ๋ฉด ๋ฉ๋๋ค. ์ด๋ฐ์๋ย hash_multimap๊ณผย hash_multiset์ด๋ ์ปจํ
์ด๋๊ฐ ์์ต๋๋ค.
์ด๋ค ์ปจํ
์ด๋ ํ์
์ ๋ํ ํค๋ ํ์ผ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
//map๊ณผ multimap์ ๊ฒฝ์ฐ
#include <cli/map>
//set๊ณผ multiset์ ๊ฒฝ์ฐ
#include <cli/set>
//hash_map๊ณผ hash_multimap์ ๊ฒฝ์ฐ
#include <cli/hash_map>
//hash_set๊ณผ hash_multiset์ ๊ฒฝ์ฐ
#include <cli/hash_set>
C++
๋ณต์ฌ
๊ฐ๋จํ ๋ฐ๋ชจ
์ด์ ์์ ๋ฅผ ๋ค๋ฃจ๋ฉด์ ์ข๋ ๊ตฌ์ฒด์ ์ผ๋ก ๋ค์ด๊ฐ๋ณด๋๋ก ํ์ฃ . ๋ค์์ ํ
์คํธ ํ์ผ์ ์๋ ๋จ์ด์ ๊ฐ์๋ฅผ ์ธ๋ ๊ฐ๋จํ ํ๋ก๊ทธ๋จ์
๋๋ค. ์ด ํ๋ก๊ทธ๋จ์ย map๊ณผย hash_set, ๊ทธ๋ฆฌ๊ณ ย vector์ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์ง๋ฅผ ๋ณด์ฌ์ฃผ๊ณ ์์ต๋๋ค. ํจ์ ํ๋๊ฐ ๋ค์๊ณผ ๊ฐ์ด ์ ์ธ๋์ด ์์ต๋๋ค.
map<String^, int>^
build_word_count( vector<array<String^>^>^ words,
array<String^> ^common_words )
C++
๋ณต์ฌ
ํ
ํ๋ฆฟ ๊ตฌ๋ฌธ(syntax)์ ์ฌ๋ฌ๋ถ์ด ์ด์ ์ต์ํด์ง๊ธฐ ์ ๊น์ง๋ ์ ์ ์์ด ๋ณด์ผ ๊ฒ์
๋๋ค. ์ด์ ์ด๋ฅผ ๋ถ์ํด๋ณด๋๋ก ํ์ฃ .ย build_word_count()์ ๋ฐํ ํ์
์ย map์ผ๋ก์, ์ดย map์ key๋ ์ด ํ์ผ์ ๊ฐ๊ธฐ ๊ณ ์ ํ ๋จ์ด๋ฅผ ๋ํ๋ด๋ ๋ฌธ์์ด(string)์ด๊ณ , value๋ ํด๋น ๋จ์ด๊ฐ ๋ด๊ธด ํ์๋ฅผ ๋ํ๋ด๋ ์ ์์
๋๋ค. ์ด ํจ์์ ์ฒซ ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ ์ด ํ์ผ์ ๋ด๊ธด ๊ฐ ๋จ์ด๋ค์ ๋ฌธ์์ด ์์๋ก ๊ฐ๋ CLI ๋ฐฐ์ด ๋ฒกํฐ์
๋๋ค. ๋ ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ ๋จ์ด ๊ฐ์ ์ธ๊ธฐ์ ์์ด ์ ์ธ์ํฌ ๋จ์ด๋ค์ ๋ชจ์์
๋๋ค.
์ ์ ์ธ๋ฌธ์๋ ์ฌ๋ฌย ^(hat์ด๋ผ๊ณ ๋ถ๋ฅด๋๊ตฐ์. ์ญ์ฃผ)์ด ๋ซ๊ธฐ ๊ดํธ์ ํจ๊ป ๋๋ ค ์๊ธฐ ๋๋ฌธ์ ๋ณต์กํด ๋ณด์
๋๋ค. ์ด ๋ฌธ์ฅ์ ํ์์ย typedef์ ์ด์ฉํ์ฌ ๋จ์ํํ ์ ์์ต๋๋ค.
typedef array<String^>^ words;
typedef vector<words>^ text;
C++
๋ณต์ฌ
์ย typedef๋ฌธ์ ์ด์ฉํ์ฌ ์ ์ธํ๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒ์
๋๋ค.
map<String^ int>^
build_word_count( text theText, words common )
C++
๋ณต์ฌ
๋ช
์์ ์ผ๋ก ์ ์ธ๋ย mapย ๋ํ ์ ๊ฑฐํ ์ ์์ง๋ง, ์ด ์ปฌ๋ผ์ ์ฝ๋ ์ฌ๋ฌ๋ถ์๊ฒ ์ฐ์ต์ด ๋๋ผ๊ณ ๋๋์์ต๋๋ค. ๋ค์์ ์ ํจ์๋ฅผ ๊ตฌํํ ์ฐจ๋ก์
๋๋ค. ์ฐ๋ฆฌ๋ ์ด ์์
์ ๋ ๋ถ๋ถ์ผ๋ก ๋๋ ๊ฒ์
๋๋ค: ์๋์ ๋ณด์ด๋ ๋ฐ์ ๊ฐ์ด, (1)์ฐ๋ฆฌ์ย map๊ณผย hash_set์ ๋ํ ์ด๊ธฐํ, ๊ทธ๋ฆฌ๊ณ (2)ํ
์คํธ ๊ทธ ์์ฒด์ ๋ํ ์ค์ ์ฒ๋ฆฌ์
๋๋ค.
// ํญ๋ชฉ #1: ์ปจํ
์ด๋์ ๋ํ ์ด๊ธฐํ
// ํฌ๊ธฐ๊ฐ ์ผ๋ง๋ ๋ ์ง ๋ชจ๋ฅด๋ ์ํ์์ ๋น์ด์๋ map์ ํ ๋นํฉ๋๋ค . . .
map<String^, int> ^wordOccur = gcnew map<String^, int>
// ๋ฐฐ์ด์ ๋ด๊ธด ์์๋ค๋ก hash_set์ ์ฑ์๋๋ค.
hash_set<String^> ^comWords =
gcnew hash_set<String^>(
&common[0],
&common[common->Length]);
C++
๋ณต์ฌ
์ฌ๋ฌ๋ถ์ด STL์ ์ต์ํ์ง ์๋ค๋ฉด,ย hash_set์ ๋ํ ์ด๊ธฐํ ๋ถ๋ถ์ด ์ง์ ๋ถํ๊ฒ ๋ณด์ผ ๊ฒ์
๋๋ค. ํ์ง๋ง ๊ตฌ๋ฌธ์ ๋ผ์ด๋๊ณ ๋ณธ๋ค๋ฉด, ์ฌ์ค ์ด ์ ์ธ๋ฌธ์ ์ง๊ด์ ์ด๊ณ ๋ ๋งค์ฐ ๊ฐ๋ ฅํฉ๋๋ค.
์ฐ๋ฆฌ๊ฐ ์ํ๋ ๊ฒ์ย hash_set์ ๋ฐฐ์ด์ ๋ด๊ธด ์์๋ค๋ก ์ด๊ธฐํํ๋ ๊ฒ์
๋๋ค. ๋ฌผ๋ก ์ฐ๋ฆฌ๋ ์ด๋ฅผย for eachย ๋ฌธ์ ์ด์ฉํ์ฌ ๊ฐ ์์๋ค์ ๋ฐฉ๋ฌธ(iterating)ํจ์ผ๋ก์จ ๋ช
์์ ์ผ๋ก ์ด๋ค๋ผ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด,
// hash_set๋ฌธ์ ๋จ์ํํฉ๋๋ค.
// ํํธ #1: ๋น hash_set์ ํ ๋นํฉ๋๋ค.
hash_set<String^> ^comWords = gcnew hash_set<String^>;
// ํํธ #2: ๋ฐฐ์ด์ ์์๋ค๋ก hash_set์ ์ฑ์๋๋ค.
for each ( String^ wd in common )
comWords->insert( wd );
C++
๋ณต์ฌ
๋ฐฐ์ด์ ๋ด๊ธด ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์, ๊ทธ๋ฆฌ๊ณ ๋ง์ง๋ง ์ ํจ ์์๋ฅผ ํ๋ ๋๊ธด ์์์ ์ฃผ์๋ฅผย hash_setย ์์ฑ์์ ๋๊น์ผ๋ก์จ,ย hash_set์ ๋์ผํ๊ฒ ์ฑ์ฐ๊ฒ ๋ฉ๋๋ค. ์ด ๋ ๊ฐ์ ์ฃผ์๋ย hash_setย ์์ฑ์๊ฐ ๋ฐฉ๋ฌธ(iterating)ํ ์์๋ค์ ๋ฒ์๋ฅผ ์๋ ค์ฃผ์ด, ์ด๋ค ์์๋ฅผ ์ด ์ปจํ
์ด๋์ ๋ฃ์ต๋๋ค. ์ด๊ฒ์ด ๋ฐ๋ก ์ด ์ ์ฒ์์์ ์ ๊ฐ ์ธ๊ธํ๋ ๋ฐ๋ณต์ ๋ฒ์(iterator range)์ ๊ดํ ๊ด์ฉ๊ตฌ์
๋๋ค.
์ ์ฝ๋์ ๋ ๋ฒ์งธ ๋จ์ ํ
์คํธ๋ฅผ ์ค์ง์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๋ถ๋ถ์
๋๋ค. ์์ง ์ฐ๋ฆฌ๋ ๋ฐ๋ณต์๋ฅผ ๊ณต์์ ์ผ๋ก ๋ค๋ฃจ์ง ์์๊ธฐ ๋๋ฌธ์, ์ด์ ๋ถํฐ ํํ ๋ง์ด ์ฐ๋ย forย ๋ฃจํ๋ฅผ ์ด์ฉํ์ฌย vectorย ์์ ์ํํด ๋ณด๊ฒ ์ต๋๋ค. ์ฐ๋ฆฌ๋ย for eachย ๋ฌธ์ ์ฌ์ฉํ์ฌย vector์ ๋ด๊ธด ๊ฐ๊ฐ์ ๋ฐฐ์ด ์์์ ์ ๊ทผํ ๊ฒ์
๋๋ค. ๋ค์์ ์ด์ ๊ดํ ์ฝ๋์
๋๋ค.
// ๊ฐ๊ฐ์ ๋ฐฐ์ด์ ์ฐจ๋ก๋ก ์ ๊ทผํฉ๋๋ค.
for ( int ix = 0; ix < theText->size(); ++ix )
{
for each ( String^ wd in theText[ ix ] )
if ( common->find( wd ) == common->end() )
word_map[ wd ]++;
}
// word_map์ ๋ฐํํด์ผ ํ๋ค๋ ๊ฒ์ ์์ง ๋ง์๋ค . . .
return word_map;
C++
๋ณต์ฌ
find()๋ย hash_setย ๋ฉค๋ฒ ํจ์๋ก์, ํน์ ์์ดํ
์ด ์ด ์ปจํ
์ด๋์ ์กด์ฌํ๋์ง๋ฅผ ์์๋ด๋ ๋ฐ ์ฌ์ฉํฉ๋๋ค. ์ฐธ๊ณ ์ ์ผ๋ก, ๋ชจ๋ ์ฐ๊ด ์ปจํ
์ด๋๋ย find()ย ๋ฉค๋ฒ๋ฅผ ์ง์ํฉ๋๋ค. (๋ง์ต๋๋ค. ๊ธฐ๋ณธ(built-in) ๋ฐฐ์ด์ ํฌํจํ ์์ฐจ ์ปจํ
์ด๋, ๊ทธ๋ฆฌ๊ณ STL/STL.NET ๋ชจ๋ธ์ ํตํฉ ๊ฐ๋ฅํ ๋ชจ๋ ์ปฌ๋ ์
์๋ย find()ย ์ง๋ค๋ฆญ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด๋ฌํ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์ปจํ
์ด๋์ ๋ถ๋ฆฌ๋ ์ค์ ๋ณด๋ค๋ ์ด๋ก ์ ์ผ๋ก ๋์ฑ ๋ช
ํํฉ๋๋ค. ์ด๋ ํนํย listย ์์ฐจ ์ปจํ
์ด๋์์ ๊ทธ๋ฌํฉ๋๋ค.) ์ด ๋ฉค๋ฒ ํจ์๋ ์ ๊ฐ ์์ง ์ธ๊ธํ์ง ์์๋ ๊ฒ, ์ฆ ์ด ์ปจํ
์ด๋์ ๋ฐ๋ณต์๋ฅผ ๋ฐํํฉ๋๋ค. ์ฐ์ ์ ๋ฐ๋ณต์๋ฅผ ํฌ์ธํฐ ํ์
์ด๋ผ๊ณ ์๊ฐํด๋ณด๊ธฐ๋ก ํ์ฃ . ์ฐพ๊ณ ์ ํ๋ ์์ดํ
์ด ์ปจํ
์ด๋ ์์ ์๋ค๋ฉด,ย find()๋ ๊ทธ ์์ดํ
์ ๋ํ ๋ฐ๋ณต์๋ฅผ ๋ฐํํ๊ณ , ๊ทธ๋ ์ง ์๋ค๋ฉด ์ปจํ
์ด๋์ ๋ง์ง๋ง์์ ํ๋ ์ง๋ ์์ดํ
์ ๋ํ ๋ฐ๋ณต์๋ฅผ ๋ฐํํฉ๋๋ค. ์ด ๊ฐ์ย end()๊ฐ ๋ฐํํ๋ ๋ฐ๋ณต์ ๊ฐ๊ณผ ๋์ผํฉ๋๋ค. STL์์์ ์์ ๊ฒ์์ ์ฑ๊ณต ์ฌ๋ถ์ ๋ํ ๊ฒฐ์ ์ ๊ฒ์ ๋ฉ์๋๊ฐ ๋ฐํํ๋ ๋ฐ๋ณต์์ย end()๊ฐ ๋ฐํํ๋ ๋ฐ๋ณต์๋ฅผ ๋น๊ตํ๋ ๊ฒ์ผ๋ก ์ด๋ฃจ์ด์ง๋๋ค. ๋ง์ฝ ์ด๋ค ๋ ๋ฐ๋ณต์์ ๊ฐ์ด ๋์ผํ๋ค๋ฉด, ๊ทธ ์์๋ ์ปจํ
์ด๋์ ์กด์ฌํ์ง ์๋ ๊ฒ์
๋๋ค.
๋ชจ๋ ์ปจํ
์ด๋์๋ย begin()์ย end()ย ๋ฉค๋ฒ ํจ์๊ฐ ์์ต๋๋ค.ย begin()์ ์ปจํ
์ด๋์ ์ฒซ ๋ฒ์งธ ์์์ ๋ํ ๋ฐ๋ณต์๋ฅผ ๋ฐํํ๊ณ , ์ด๋ฏธ ์ ๊ฐ ๋งํ๋ค์ํผ,ย end()๋ ์ปจํ
์ด๋์ ๋ง์ง๋ง ์์๋ฅผ ํ๋ ๋๊ธด ์์์ ๋ฐ๋ณต์๋ฅผ ๋ฐํํฉ๋๋ค. ๋ค์์ ์ด๋ป๊ฒ ๋ฐ๋ณต์๋ฅผ ์ ์ธํ๋์ง์, ์ด๋ป๊ฒ ์ด๋ค ๋ ๋ฉค๋ฒ๋ฅผ ์ด์ฉํ์ฌ ์ด๊ธฐํํ๋์ง๋ฅผ ๋ณด์ฌ์ค๋๋ค.
vector<words>::iterator first = theText->begin();
vector<words>::iterator last = theText->end();
C++
๋ณต์ฌ
์ปจํ
์ด๋ ๋ด๋ถ ์ํ๋, ๋ณดํตย for๋ย whileย ๋ฃจํ์์ first๋ฅผ ์ฆ๊ฐ์์ผ,ย first์ย last๊ฐ ๊ฐ์์ก์ ๋ ๋๋ด๋ ๊ฒ์ผ๋ก ์ด๋ฃจ์ด์ง๋๋ค. ์๋ฅผ ๋ค์ด,
for ( ; first != last; ++first )
C++
๋ณต์ฌ
๋ฐ๋ณต์ ์์ด ๋ฐ๋์ ํ์ํ ์ด์ ๋ ์ฆ๊ฐ ์ฐ์ฐ์์ ๋ํ ๋ฐ๋ณต์ ์ธ ์ ์ฉ์ ํตํดย first์์ ์์ํ์ฌย last๊น์ง ๋๋ฌ ํ ์ ์์ด์ผ ํ๊ธฐ ๋๋ฌธ์
๋๋ค. ์ปดํ์ผ๋ฌ ์์ ์ด ์ด๋ฅผ ๊ฐ์ ํ ์๋ ์๊ธฐ ๋๋ฌธ์, ์ด๋ฌํ ์๊ตฌ ์ฌํญ์ ๋ง์กฑ์ํค์ง ๋ชปํ๋ค๋ฉด ์คํ์(run-time)์ย ์ ์๋์ง ์์(undefined)ย ํ๋์ ๋ณด์ด๊ฒ ๋๋ ๊ฒฐ๊ณผ๋ฅผ ์ด๋ํฉ๋๋ค.(๋ฐ์ค์น ์ด ๋ถ๋ถ์ ํด์์ด ์ ๋งคํ๊ฒ ๋ ๋ถ๋ถ์
๋๋ค.. ์ค๋ ฅ์ด ๋ธ๋ ค์๋ฆฌ.. ์ญ์ฃผ)
์์ ์์ฒด์ ๋ํ ์ ๊ทผ(access)์ ์ญ์ฐธ์กฐ ์ฐ์ฐ์(*)๋ฅผ ํตํด ๋ฐ๋ณต์๋ฅผ ์ฐธ์กฐํจ์ผ๋ก์จ ์ด๋ฃน๋๋ค. ์๋ฅผ ๋ค์ด, ์ฐ๋ฆฌ์ ๋ฒกํฐ์์ ๊ฐ๊ฐ์ CLI ๋ฐฐ์ด ์์๋ฅผ ๋์ฐพ๊ณ ์ ํ๋ค๋ฉด,ย forย ๋ฃจํ ์์ ๋ค์๊ณผ ๊ฐ์ด ๊ธฐ์
ํ๋ฉด ๋ฉ๋๋ค.
array<String^> ^as = *first;
C++
๋ณต์ฌ
์ฐ๊ด ์ปจํ
์ด๋์ ๋ํ ์์ธํ ์ ์ธ๋ฒ๊ณผ ์ฉ๋ฒ์ ์ด ์ฐ์ฌ๋ฌผ์ ๋์ค ์ปฌ๋ผ์์ ๋ค๋ฃจ๋๋ก ํ๊ฒ ์ต๋๋ค.
STL.NET Primer (4/4)์ผ๋ก ์ด์ด์ง๋๋ค.



