STL.NET Primer (1/4)์์ ์ด์ด์ง๋ ๊ธ์
๋๋ค.ํ๋ณตํ ๊ณ ๋ฏผ : ๋ฌด์์ ์ ํํด์ผ ํ๋๊ฐ?
CLI ํ์
์ผ๋ก ์ด๋ฃจ์ด์ง ์ปฌ๋ ์
์ ์กฐ์ํ๋ ๋ฐ ์์ด Visual C++ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ ํ ๊ฐ๋ฅํ ์ปจํ
์ด๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์๋ ์ธ ๊ฐ์ง๊ฐ ์๋๋ฐ, ์ด๋ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ธ ๊ฐ์ง์ ํ์
๋งค๊ฐ๋ณ์ํ(type parameterization) ๋ชจ๋ธ์ ๊ฐ๊ฐ ๊ธฐ๋ฐํ์ฌ ๋ง๋ค์ด์ง ๊ฒ์
๋๋ค. ์๋์ ๋ฆฌ์คํธ๋ ๊ฐ ๋ชจ๋ธ์ ํด๋นํ๋ ์ฝ๋ ์ํ๊ณผ ํจ๊ป ์ด๋ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์์ฝํ ๊ฒ์
๋๋ค.
์ค๋ฆฌ์ง๋ย System::Collectionsย ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋, ๋ชจ๋ CLI ํ์
์ ๊ธฐ์ด ํด๋์ค(base class)์ธย Object๋ฅผ ํตํด ์์ ํ์
์ ์ ์ฅํ๋ ๋ฐ์ ๊ธฐ๋ฐ์ ๋ก๋๋ค. ๊ทธ ์๋ก, ์๋์๋ย IListย ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ย ArrayList๊ฐ ์์ต๋๋ค. ์ด ํ์
์ย Objectย ํ์
์ ๋ฐฐ์ด์ ๋ํ๋ด๋ฉฐ, ์ด ์์ ์์๋ย Stringย ํ์
์ ์์๋ฅผ ๋ด๊ณ ์์ต๋๋ค.
void objectCollection()
{
using namespace System::Collections;
ArrayList ^as = gcnew ArrrayList;
as->Add( "Pooh" ); as->Add( "Piglet" );
as->Add( "Eeyore" ); as->Add( "Rabbit" );
as->Sort();
Console::WriteLine( "ArrayList holds {0} elements: ",
as->Count );
for ( int i = 0; i < as->Count; i++ )
Console::WriteLine( as[ i ] );
int index = as->IndexOf( "Pooh" );
if ( index != -1 )
{
// ๋ช
์์ ์ธ ๋ค์ด์บ์คํธ๊ฐ ํ์ํฉ๋๋ค.
String^ item = safe_cast( as[ index ]);
as->RemoveAt( index );
}
as->Remove( "Rabbit" );
Console::WriteLine( " ArrayList holds {0} elements: ",
as->Count );
IEnumerator^ is = as->GetEnumerator();
While ( is->MoveNext() )
Console::WriteLine( is->Current );
}
C++
๋ณต์ฌ
์๋ก์ด ์ปจํ
์ด๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ CLI Generic ๋ฉ์ปค๋์ฆ์ ๊ธฐ๋ฐ์ ๋๊ณ ์์ต๋๋ค. ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ย System::Collections::Genericย ๋ค์์คํ์ด์ค์์ ์ฐพ์ ์ ์์ฃ . ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ Visual Studio 2005 ๋ฒ ํ 1์์ ์ ๋ณด์๋๋ฐ, ์ต์ข
ํ์ด ๋ฐฐํฌ๋๊ธฐ์ ์์ ๋ณ๊ฒฝ์ด ๊ฐํด์ง๋ฆฌ๋ผ ์์๋ฉ๋๋ค.ย Collection<T>๋ ๊ตฌ์ฒดํ๋ ์ง๋ค๋ฆญ ๊ธฐ๋ฐ ํด๋์ค(concrete generic base class)๋ก์, ์ฌ์ฉ์๋ค์ ์ด ํด๋์ค๋ฅผ ๊ธฐ์ด ํด๋์ค๋ก ํ์ฌ ๊ทธ๋ค๋ง์ ํนํ๋ ์ปจํ
์ด๋ ํด๋์ค๋ฅผ ํ์์ํฌ ๊ฒ์
๋๋ค. ๋ค์์ ์์ ์์ ๋์ผํ ๋ด์ฉ์ด ๋ด๊ธด ์ง๋ค๋ฆญ ๋ฒ์ ์ ์์ ์ฝ๋์
๋๋ค.
void genericCollection()
{
using namespace System::Collections::Generic;
Collection<String^> ^cols =
gcnew Collection<String^>;
cols->Add( "Pooh" ); cols->Add( "Piglet" );
cols->Add( "Eeyore" ); cols->Add( "Rabbit" );
// ์ฝ๋ ์
์ ๊ด๊ณ๋ ์ ๋ ฌ ๋ฉ์๋๊ฐ ์์ต๋๋ค.
Console::WriteLine( "Collection holds {0} elements: ",
cols->Count );
for ( int i = 0; i < cols->Count; i++ )
Console::WriteLine( cols[ i ] );
int index = cols->IndexOf( "Pooh" );
if ( index != -1 )
{
// ๋ค์ด์บ์คํธ๊ฐ ํ์ ์์ต๋๋ค ...
String ^item = cols[ index ];
cols->RemoveAt( index );
}
cols->Remove( "Rabbit" );
Console::WriteLine( " Collection holds {0} elements:",
cols->Count );
IEnumerator<String^> ^is = cols->GetEnumerator();
while ( is->MoveNext() )
Console::WriteLine( is->Current );
}
C++
๋ณต์ฌ
STL.NET์์ ์ฌ์ฉํ๋ ํ์
๋งค๊ฐ๋ณ์ํ(type parameterization) ๋ชจ๋ธ์ ๋งค์ฐ ๋ค๋ฅธ๋ฐ, ๋ฐ๋ก ์ด ๋ชจ๋ธ์ด ๋ค์ ์ ์ ์ฃผ์ ์
๋๋ค. ๋ค์์ ๊ตฌํ ์ฝ๋๋ย Stringย ์ปจํ
์ด๋๋ก์, ์๋์์ ์ข๋ ๊น๊ฒ ํ๊ณ ๋ค ๋ด์ฉ์
๋๋ค.
#include <cli/vector>
#include <algorithm>
void stlCollection()
{
vector<String^> ^svec = gcnew vector<String^>;
svec->push_back("Pooh"); svec->push_back("Piglet");
svec->push_back("Eeyore"); svec->push_back("Rabbit");
// ์ง๋ค๋ฆญ ์๊ณ ๋ฆฌ์ฆ: sort
sort( svec->begin(), svec->end() );
Console::WriteLine( "Collection holds {0} elements: ",
svec->size() );
for ( int i = 0; i < svec->size(); i++ )
Console::WriteLine( svec[ i ] );
// ์ง๋ค๋ฆญ ์๊ณ ๋ฆฌ์ฆ: find
vector::iterator iter =
find( svec->begin(), svec->end(), "Pooh" );
if ( iter != svec->end() )
{
// ๋ค์ด์บ์คํธ๊ฐ ํ์ ์์ต๋๋ค ...
String ^item = *iter;
svec->erase( iter );
}
// ์ง๋ค๋ฆญ ์๊ณ ๋ฆฌ์ฆ: remove ...
remove(svec->begin(),svec->begin(),svec->end(),"Rabbit");
Console::WriteLine( " Collection holds {0} elements: ",
svec->size() );
IEnumerator ^is = svec->GetEnumerator();
while ( is->MoveNext() )
Console::WriteLine( is->Current );
}
C++
๋ณต์ฌ
์ STL.NET์ธ๊ฐ?
STL.NET์ ๋ํ์ฌ ํ๊ณ ๋ค๊ธฐ์ ์์, ๋ถ๋ช
ํ ํด๋์ด์ผ ํ ์ฌํญ์ ์ง๊ณ ๊ฐ๋๋ก ํ์ฃ . ๋ฐ๋ก ๋ค์๊ณผ ๊ฐ์ ์ง๋ฌธ์ ๊ดํ ๊ฒ์
๋๋ค : ์ Visual C++ ํ๋ก๊ทธ๋๋จธ๋ ์ธ์ด ์ค๋ฆฝ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ธย System::Collections๋ย System::Collections::Generic๋ณด๋ค, STL.NET ์ปจํ
์ด๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ข์๊น?
๋ณดํต,ย System::Collectionsย ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํผํ๊ฒ ๋๋ ์ด์ ๋ Visual Studio 2005์์ย Genericย ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ ๊ณตํ๋ ์ด์ ์ ๋์ผํฉ๋๋ค. ์ฆ, ๋งค๊ฐ๋ณ์ํ์ ๋ํย Objectย ๋ชจ๋ธ์ ํ์
์ ๋ณด๋ฅผ ์์คํจ์ผ๋ก ์ธํ์ฌ ๋ณต์กํ๊ณ ๋ ์์ ํ์ง ์๋ค๋ ๊ฒ์ด์ฃ . 16๊ฐ ํน์ ๊ทธ ์ดํ์ ์์๋ฅผ ๊ฐ์ง ์ปจํ
์ด๋์์๋ ๋ฒ๋ธ ์ํธ(bubble sort)๊ฐ ๋ฌธ์ ์๋ ๊ฒ์ฒ๋ผ, ๊ฐ๋จํ๊ฒ ์ฌ์ฉํ ๋์๋ ์ด ๋ชจ๋ธ๋ ๊ด์ฐฎ์ต๋๋ค. ํ์ง๋ง ์ฌ๋ฌ๋ถ์ ์ ํ๋ฆฌ์ผ์ด์
์ด ์ค์ธ๊ณ์ ๋ฌธ์ ๋ฅผ ๋ค๋ฃจ๋ ๊ฒฝ์ฐ๋ผ๋ฉด, ์ฌ๋ฌ๋ถ์๊ฒ๋ ์ข๋ ์ ๊ตํ ํด๊ฒฐ์ฑ
์ด ํ์ํ๊ฒ ๋ ๊ฒ์
๋๋ค.
๋ฐ๋ผ์, Visual C++ ๊ฐ์ ์์คํ
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์ํ ๋์์ STL.NET๊ณผย System::Collections::Genericย ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก ์ขํ์ง๋๋ค. ๊ทธ๋ ๋ค๋ฉด, ์ Visual C++ ํ๋ก๊ทธ๋๋จธ๋ ์ด ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค STL.NET์ ์ ํธํด์ผ ํ ๊น์? ๊ทธ๋ฆฌ๊ณ ์ด๋ ๋๋จธ์ง ์ฐ๋ฆฌ์ ํ๋ก๊ทธ๋จ์ ๋ค๋ฅธ .NET ์ธ์ด๋ก๋ถํฐ ๊ฒฉ๋ฆฌ์ํค๋ ๊ผด์ ์๋๊น์? ์ด๋ ์ ํจํ ์ง๋ฌธ์ผ ๋ฟ๋ง ์๋๋ผ, ๋ต๋ณ๋ฐ์ ๋งํ ๊ฐ์น๊ฐ ์๋ ์ง๋ฌธ์
๋๋ค.
์ฒซ ๋ฒ์งธ ๋ต๋ณ์ ํ์ฅ์ฑ(extensibility)์
๋๋ค. Alex Stepanov๊ฐ ๋ฐ๋ช
ํ STL์ ์ ๋์์ธ ํจํด์ ์๊ณ ๋ฆฌ์ฆ๊ณผ ์ปจํ
์ด๋๋ฅผ ๊ฐ๊ธฐ ๋ค๋ฅธ ๋ ์์ญ(domain space)๋ก ๋๋๋๋ค. ๋ฐ๋ผ์ ์ฌ๋ฌ๋ถ์ ๋ชจ๋ ์ข
๋ฅ์ ์ปจํ
์ด๋์ ์ ์ฉ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ถ๊ฐํ ์ ์๊ฑฐ๋, ๊ทธ ์๊ณ ๋ฆฌ์ฆ์ด ์ ์ฉ๋ ์ปจํ
์ด๋๋ค์ ์ถ๊ฐํ ์ ์์ต๋๋ค. ํ์ง๋งย Genericย ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ข๋ ์ ํ์ ์ธ ์ปจํ
์ด๋ ๋ชจ๋ธ์ด๋ฉฐ, ์ด ์ฌ์ค์ ์ฐ๋ฆฌ๋ฅผ ๋ ๋ฒ์งธ ๋ต๋ณ์ผ๋ก ์ด๋๋๋ค.
๋ ๋ฒ์งธ ๋ต๋ณ์ ํต์ผ์ฑ(unification)์
๋๋ค. ์ค์ ์ C++ ํ๋ก๊ทธ๋๋จธ๋ค์ ๊ธฐ์กด์ ์ฝ๋ ๋ชธ์ฒด๋ฟ๋ง์ด ์๋๋ผ, ์ด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ํจ๊ปํจ์ผ๋ก์จ ์ ๋ฌธ์ ๊ธฐ์ ์ ์ตํ์์ต๋๋ค. ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๋ฐ๋ (.NET์ผ๋ก์) ์ด์ฃผ๋ก(migration path)๋ฅผ ์ ๊ณตํ๋ ๋ฐ ์์ด ๊ธฐ์กด์ ์ฝ๋๋ฟ๋ง ์๋๋ผ, ๋ชธ์ ์ต์ํด์ง ๊ธฐ์กด์ ๊ธฐ์ ๋ ํจ๊ป ํ ์ ์๋๋ก ํ๋ ๊ฒ์
๋๋ค. ์ฌ๋ฌ๋ถ์ด C++๋ก ํ๋ก๊ทธ๋๋ฐ์ ํ ๋์ STL์ ์์กดํด์์ ๊ฒฝ์ฐ .NET ํ์์ STL์ ์ฌ์ฉ ๋ชปํ๊ฒ ๋๋ค๋ฉด, ์ฌ๋ฌ๋ถ์ ์ด๋ฅผ ํฌ๋ํฐ ์์ค๋ก ์ฌ๊ธธ ๊ฒ์
๋๋ค(์ ์ด๋ ์ ์ ๊ฒฝํ์ผ๋ก๋ ๊ทธ๋ฌ์ต๋๋ค). ์ด๋ฌํ ๊ฒฌํด๋ ์ ์ ์๊ฒฌ์ ๋๋ ์จ ๋ง์ ๊ณ ๊ธ C++ ํ๋ก๊ทธ๋๋จธ๋ค์๊ฒ์ ์ด๋ฏธ ์ ๊ธฐ๋์๋ ์ฌํญ์ด๋ฉฐ, ์ด๋ก ์ธํด ๊ทธ๋ค์ .NET์ผ๋ก ์ด์ฃผํ๋ ๊ฒ์ ๋ณด๋ฅํ๋ค๊ณ ๋งํด์์ต๋๋ค.
์ธ ๋ฒ์งธ ๋ต๋ณ์ ์ฑ๋ฅ(performance)์
๋๋ค. ํ์ง๋ง C++ ํ๋ก๊ทธ๋๋จธ๋ ์ฑ๋ฅ์ ๊ดํ ์ฃผ์ ์ ๋ํด์ ... ํ , ๋งํ์๋ฉด, ์ง์ฆ๋ ์ ๋๋ก ์๋ฏผํ๊ธฐ ๋๋ฌธ์, ์ด ์ฐ์ฌ๋ฌผ ์ค ์ ์ ํ ์์ ์์ ๋ค์ ๋ค๋ฃจ๋๋ก ํ๊ฒ ์ต๋๋ค.
๋ง์ง๋ง์ผ๋ก, ๋จ์ ์ง๋ฌธ, "์ข์์, Stan. ์ง๊ธ๊น์ง ๋ชจ๋ ์ข์๋ค๊ณ ์. ํ์ง๋ง ์ด๋ C++ ํ๋ก๊ทธ๋๋จธ์ C++/CLI ํ๋ก๊ทธ๋จ์ ๋๋จธ์ง ๋ค๋ฅธ .NET ์ปค๋ฎค๋ํฐ๋ก๋ถํฐ ๊ณ ๋ฆฝ์ํค๊ฒ ๋๋ ์ผ์ด ์๋๊ฐ์?" ์ด์ ๋ํ ๋ต๋ณ์, ์ ๊ฐ ๋ฏฟ๊ธฐ๋ก๋, '์๋์ค'์
๋๋ค. Anson Tsao, Martyn Lovel, P.J. Plauger๋ฅผ ๋น๋กฏํ STL.NET ์ํคํ
ํธ๋ค์ ์ด ์ฌ์์ ๋ํด ์ฌ์ฌ์๊ณ ๋ฅผ ํด์์ผ๋ฉฐ, ์ฐ๋ฆฌ๋ ์ฐ๋ฆฌ์ ๋ฅ๋ ฅ, ์ฆย IEnumerator,ย IList,ย ๊ทธ๋ฆฌ๊ณ ย ICollection์ ๋ํ ์ง์์ ํตํด ๋ค๋ฅธ .NET ์ธ์ด์ ์ํธ์ด์ฉ์ ์ด๋ค๋ผ ์ ์๋ค๋ ๋ฐ์ ํ์ ์ ๊ฐ์ง๋๋ค. ์ด์ด์ง ์ ์ ์ปฌ๋ผ ์ค ํ๋์์๋ ์ด ์ฌํญ์ ๋ํ์ฌ ๊น๊ฒ ๋ค๋ฃฐ ๊ฒ์
๋๋ค.
STL.NET Primer (3/4)์ผ๋ก ๊ณ์๋ฉ๋๋ค.



