Unity3D

제공 : 한빛 네트워크
저자 : 최흥배
이전기사 :

• About STL : C++ STL 프로그래밍(1)
• About STL : C++ STL 프로그래밍(2-1)
• About STL : C++ STL 프로그래밍(2-2)
• About STL : C++ STL 프로그래밍(3)
• About STL : C++ STL 프로그래밍(4)
• About STL : C++ STL 프로그래밍(5-1)

5.5.3. deque 실습 예제

다음은 deque에서 가장 자주 사용하는 멤버들을 사용하는 전체 코드입니다. 

[리스트 1]

#include 
#include 

using namespace std;


// 서버/ 클라이언트간에 주고 받는 패킷
struct Packet
{
	unsigned short Index; // 패킷 인덱스
	unsigned short BodySize; // 패킷 보디(실제 데이터)의 크기
	char	       acBodyData[100]; // 패킷의 데이터
};


int main() 
{
	Packet Pkt1;
	Pkt1.Index = 1;		Pkt1.BodySize = 10;

	Packet Pkt2;
	Pkt2.Index = 2;		Pkt2.BodySize = 12;

	Packet Pkt3;
	Pkt3.Index = 3;		Pkt3.BodySize = 14;


	deque< Packet > ReceivePackets;


	// 뒤에 추가
	ReceivePackets.push_back( Pkt2 );
	ReceivePackets.push_back( Pkt3 );

	// 앞에 추가
	ReceivePackets.push_front( Pkt1 );

	
	// 저장된 패킷 정보 출력
	for( deque< Packet >::iterator iterPos = ReceivePackets.begin();
		iterPos != ReceivePackets.end();
		++iterPos )
	{
		cout << "패킷 인덱스: " << iterPos->Index << endl;
		cout << "패킷 바디 크기: " << iterPos->BodySize << endl;
	}

	cout << endl << "역방향으로 출력" << endl;
	for( deque< Packet >::reverse_iterator iterPos = ReceivePackets.rbegin();
		iterPos != ReceivePackets.rend();
		++iterPos )
	{
		cout << "패킷 인덱스: " << iterPos->Index << endl;
		cout << "패킷 바디 크기: " << iterPos->BodySize << endl;
	}

	cout << endl << "배열 방식으로 접근" << endl;
	// 저장된 총 패킷 수
	int ReceivePacketCount = ReceivePackets.size();
	cout << "총 패킷 수: " << ReceivePacketCount << endl;
	for( int i = 0; i < ReceivePacketCount; ++i )
	{
		cout << "패킷 인덱스: " << ReceivePackets[i].Index << endl;
		cout << "패킷 바디 크기: " << ReceivePackets[i].BodySize << endl;
	}


	// 첫 번째, 마지막 위치에 있는 패킷
	Packet& FirstPacket = ReceivePackets.front();
	cout << "첫 번째 패킷의 인덱스: " << FirstPacket.Index << endl;

	Packet& LastPacket = ReceivePackets.back();
	cout << "마지막 패킷의 인덱스: " << LastPacket.Index << endl;

	// at을 사용하여 두 번째 패킷
	Packet& PacketAt = ReceivePackets.at(1);
	cout << "두 번째 패킷의 인덱스: " << PacketAt.Index << endl;


	// 첫 번째 패킷 삭제
	ReceivePackets.pop_front();
	cout << "첫 번째 패킷의 인덱스: " << ReceivePackets[0].Index << endl;

	// 마지막패킷삭제
	ReceivePackets.pop_back();
	LastPacket = ReceivePackets.back();
	cout << "마지막 패킷의 인덱스: " << LastPacket.Index << endl;

	// 모든 패킷을 삭제
	if( false == ReceivePackets.empty() )
	{
		cout << "모든 패킷을 삭제합니다." << endl;
		ReceivePackets.clear();
	}
}

결과 

5.5.3.1. insert 멤버

deque의 insert는 vector의 insert와 사용 방법이 같습니다. 지정된 위치에 삽입, 지정된 위치에 지정된 개수만큼 삽입, 지정된 위치에 반복자 구간 안에 있는 것들을 삽입이 있습니다. vector와 같이 insert는 삽입 되는 위치 이후에는 있는 모든 원소들이 뒤로 이동을 합니다. 그리고 insert의 성능은 vector 보다도 더 좋지 않습니다.

원형 : iterator insert( iterator _Where, const Type& _Val );
      void insert( iterator _Where, size_type _Count, const Type& _Val );
      template void insert( iterator _Where, InputIterator _First, 
                                            InputIterator _Last );

 
[그림 6] deque의 insert 처리 과정 

지정한 위치에 데이터 삽입. 아래는 300을 첫 번째 위치에 삽입합니다.

deque< int >::iterator iterInsertPos = deque1.begin();
deque1.insert( iterInsertPos, 300 );

지정한 위치에 데이터를 횟수만큼 삽입. 아래는 두 번째 위치에 10을 3번 추가합니다.

iterInsertPos = deque1.begin();
++iterInsertPos;
deque1.insert( iterInsertPos, 3, 10 );

지정한 위치에 반복자의 시작과 끝 안에 있는 원소를 삽입. 아래는 두 번째 위치에 deque2의 처음과 끝에 있는 원소를 삽입합니다.

deque< int > deque2;
deuqe2.push_back( 20 );
deuqe2.push_back( 30 );
deuqe2.push_back( 40 );

iterInsertPos = deque1.begin();
deque1.insert( ++iterInsertPos, deque2.begin(),deque2.end() );

5.5.3.2. erase 멤버

지정한 위치에 있는 원소를 삭제, 지정한 범위 안에 있는 원소를 삭제합니다. vector와 사용법이 같고 또 erase를 하는 위치 이후의 모든 원소들이 앞으로 이동하는 것도 같습니다.

원형 : iterator erase( iterator _Where );
      iterator erase( iterator _First, iterator _Last );

 
[그림 7] deque의 erase 처리 과정 

지정한 위치의 요소를 삭제. 아래는 첫 번째 요소를 삭제하는 코드입니다.

deque1.erase( deque1.begin() );

지정한 반복자 구간 안의 원소를 삭제합니다. 아래는 deque1의 첫 번째 요소에서 마지막까지 모두 삭제합니다.

deque1.erase( deque1.begin(), deque1.end() );

아래는 insert와 erase 사용 예입니다. 

[리스트 2] Insert와 erase

#include 
#include 

using namespace std;


int main()
{
	Packet Pkt1;
	Pkt1.Index = 1;		Pkt1.BodySize = 10;

	Packet Pkt2;
	Pkt2.Index = 2;		Pkt2.BodySize = 12;

	Packet Pkt3;
	Pkt3.Index = 3;		Pkt3.BodySize = 14;

	Packet Pkt4;
	Pkt4.Index = 4;		Pkt4.BodySize = 16;

	deque< Packet > ReceivePackets;
	ReceivePackets.push_back( Pkt1 );
	ReceivePackets.push_back( Pkt2 );
	ReceivePackets.push_back( Pkt3 );

	cout << "< insert >" << endl;

	// 첫 번째 위치에 Pkt3을 삽입
	cout << "insert 1" << endl;
	ReceivePackets.insert( ReceivePackets.begin(), Pkt3 );

	for( deque< Packet >::iterator iterPos = ReceivePackets.begin();
		iterPos != ReceivePackets.end();
		++iterPos )
	{
		cout << "패킷 인덱스: " << iterPos->Index;
		cout << "        패킷 바디 크기: " << iterPos->BodySize << endl;
	}

	// 두 번째 위치에 Pkt4를 2개 삽입
	cout << endl << "insert 2" << endl;
	ReceivePackets.insert( ++ReceivePackets.begin(), 2, Pkt4 );
	for( deque< Packet >::iterator iterPos = ReceivePackets.begin();
		iterPos != ReceivePackets.end();
		++iterPos )
	{
		cout << "패킷 인덱스: " << iterPos->Index;
		cout << "        패킷 바디 크기: " << iterPos->BodySize << endl;
	}


	deque< Packet > ReceivePackets2;
	ReceivePackets2.push_back( Pkt3 );
	ReceivePackets2.push_back( Pkt4 );
	ReceivePackets2.push_back( Pkt1 );

	// ReceivePackets2의 모든 것을 ReceivePackets의 첫 번째 위치에 삽입
	cout << endl << "insert 3" << endl;
	ReceivePackets.insert( ReceivePackets.begin(), ReceivePackets2.begin(), 
                                  ReceivePackets2.end() );
	for( deque< Packet >::iterator iterPos = ReceivePackets.begin();
		iterPos != ReceivePackets.end();
		++iterPos )
	{
		cout << "패킷 인덱스: " << iterPos->Index;
		cout << "        패킷 바디 크기: " << iterPos->BodySize << endl;
	}


	cout << endl << "< erase >" << endl;	
	// 두 번째 원소를 삭제한다.
	cout << "erase 1" << endl;
	ReceivePackets.erase( ++ReceivePackets.begin() );
	for( deque< Packet >::iterator iterPos = ReceivePackets.begin();
		iterPos != ReceivePackets.end();
		++iterPos )
	{
		cout << "패킷 인덱스: " << iterPos->Index;
		cout << "        패킷 바디 크기: " << iterPos->BodySize << endl;
	}

	// 두 번째 이후부터 모두 삭제한다.
	cout << endl << "erase 2" << endl;
	ReceivePackets.erase( ++ReceivePackets.begin(), ReceivePackets.end() );
	for( deque< Packet >::iterator iterPos = ReceivePackets.begin();
		iterPos != ReceivePackets.end();
		++iterPos )
	{
		cout << "패킷 인덱스: " << iterPos->Index;
		cout << "        패킷 바디 크기: " << iterPos->BodySize << endl;
	}
}

결과 

5.5.1.4 assign

vector의 assign과 같이 deque의 assign도 컨테이너를 특정 데이터로 채울 때 사용합니다. 특정 값이나 다른 deque의 특정 영역(반복자로 가리키는)에 있는 데이터로 채울 수 있습니다. assign을 사용하는 deque에 데이터가 있다면 이를 덮어쓰면서 채웁니다.

원형 : void assign( size_type _Count, const Type& _Val );
template void assign( InputIterator _First, InputIterator _Last );

 
[그림 8] deque의 assign 

지정 데이터를 지정 개수만큼 채웁니다. 숫자 7를 7개 채웁니다.

deque1.assign( 7, 7 );

다른 deque의 반복자로 지정한 영역으로 채웁니다.

deque1.erase( deque1.begin(), deque1.end() );

5.5.1.5 swap

deque1과 deque2가 있을 때 두 deque에 저장한 데이터를 서로 맞바꿀 때 사용합니다. swap 원형은 아래와 같습니다.

원형 : void swap( deque& _Right );
friend void swap( deque& _Left, deque& _Right )
template void swap(
       deque< Type, Allocator>& _Left, deque< Type, Allocator>& _Right );

deque A와 B를 swap하는 모습을 그림으로 나타내면 아래와 같습니다. 

 
[그림 9] deque의 swap 

아래는 deque1과 deque2를 swap하는 방법을 두 가지로 나타낸 코드입니다.

deque1.swap( deque2 );
swap(deque1, deque2 );

[리스트 3] assign, swap

#include 
#include 

using namespace std;

int main()
{
	deque< int > deque1;

	cout << "assign 1" << endl;
	deque1.assign( 7, 7 );
	for( deque< int >::iterator iterPos = deque1.begin();
		iterPos != deque1.end();
		++iterPos )
	{
		cout << "deque 1 : " << *iterPos << endl;
	}

	cout << endl << "assign 2" << endl;
	deque< int > deque2;
	deque2.assign( deque1.begin(), deque1.end() );
	for( deque< int >::iterator iterPos = deque2.begin();
		iterPos != deque2.end();
		++iterPos )
	{
		cout << "deque 2 : " << *iterPos << endl;
	}

	// swap
	deque< int > deque3;
	deque3.push_back(10);
	deque3.push_back(20);
	deque3.push_back(30);

	cout << endl << "swap" << endl;
	deque3.swap( deque1 );
	for( deque< int >::iterator iterPos = deque3.begin();
		iterPos != deque3.end();
		++iterPos )
	{
		cout << "deque 3 : " << *iterPos << endl;
	}

	for( deque< int >::iterator iterPos = deque1.begin();
		iterPos != deque1.end();
		++iterPos )
	{
		cout << "deque 1 : " << *iterPos << endl;
	}
}

결과 

 

deque에서 자주 사용하는 deque의 멤버를 중심으로 설명하였습니다. 여기에서 설명하지 않은 나머지 deque 멤버의 사용법은 여기(http://msdn.microsoft.com/en-us/library/8tk0b6f0.aspx)에서 참고해 주세요. 앞에서 여러 번 언급했듯이 deque 사용법이 이전 회의 vector와 거의 같습니다. 위 예제에서 deque를 vector로 바꾸어도 push_front를 제외하고는 문제없이 컴파일할 수 있습니다. deque와 vector는 사용법은 비슷하나 자료구조는 완전히 다릅니다. 앞과 끝에 데이터를 추가, 삭제하는 일이 대부분이라면 deque가 vector보다 좋지만, 그렇지 않다면 vector를 사용하는 쪽이 훨씬 더 좋습니다. STL 컨테이너는 사용이 어렵다기보다는 언제 어떤 STL 컨테이너를 사용해야 알맞은지 선택하기가 어렵습니다. STL 컨테이너를 올바른 장소에 사용하려면 컨테이너의 자료구조가 무엇인지 확실하게 알고 있어야 합니다. 만약 자료구조를 잘 모른다면 꼭 자료구조 공부를 STL 공부보다 먼저 해야 합니다.

5.6. 과제

1. deque를 사용하여 FIFO, LIFO 방식의 스택을 만들어 보세요. 

2. deque를 사용하여 Undo, Redo 구현해 보세요. 
간단한 예제로 deque의 원리만 익혀보는 과제입니다. Deque에 숫자를 저장하고 Undo를 하면 가장 마지막에 넣은 데이터를 빼고 Redo를 하면 뺀 데이터를 다시 넣습니다. deque를 2개 사용하면 횟수 제한이 없는 Undo, Redo를 구현할 수 있습니다.

출처 : http://www.hanb.co.kr/

제공 : 한빛 네트워크
저자 : 최흥배
이전기사 :

• About STL : C++ STL 프로그래밍(1)
• About STL : C++ STL 프로그래밍(2-1)
• About STL : C++ STL 프로그래밍(2-2)
• About STL : C++ STL 프로그래밍(3)
• About STL : C++ STL 프로그래밍(4)

이번 회는 STL 컨테이너 라이브러리 중 하나인 deque를 설명합니다. 앞 회의 list, vector 글을 보신 분들은 아시겠지만 STL 컨테이너 라이브러리는 사용하는 방법이 서로 비슷하므로 하나만 잘 알면 다른 컨테이너도 쉽게 배울 수 있습니다. 이전에 연재했던 list나 vector에 대한 글을 보지 않은 분은 꼭 보신 후 이 글을 보기를 권합니다. 또 이미 list나 vector를 알고 있는 분들은 deque의 자료구조 및 특징을 잘 파악하기를 바랍니다. 

5.1 deque의 자료구조

deque의 자료구조는 이름과 같이 Deque(Double Ended Queue) 자료구조입니다. Deque 자료구조는 Queue 자료구조와 비슷하므로 먼저 Queue 자료구조를 설명하겠습니다. Queue는 선형 리스트로 선입선출(FIFO) 방식을 사용합니다. 아래 그림처럼 시작과 끝을 가리키는 포인터로 삽입과 삭제를 합니다. 

 
[그림 1] 큐(Queue) 자료구조 

[그림 1]에서 F(Front)는 가장 앞에 있는 것을 가리키며 삭제 작업을 할 때 사용합니다. 위 그림에서 삭제를 한다며 ‘a’는 없어지고 F는 ‘b’를 가리킵니다. R(Rear)은 가장 마지막에 있는 것을 가리키며 삽입 작업을 할 때 사용합니다. 위 그림에서 ‘g’를 추가하면 ‘f’ 다음에 위치하며 R은 ‘f’를 가리킵니다.

Queue는 앞으로는 삭제, 뒤로는 삽입을 할 때 사용합니다.

OS의 작업 스케줄링처럼 입력 순서대로 처리를 할 때 Queue를 사용하면 좋습니다. Deque과 Queue와 다른 점은 삽입과 삭제를 한쪽이 아닌 앞, 뒤 양쪽에서 할 수 있다는 것만 다르며 Queue와 같습니다. 

 
[그림 2] 덱(Deque) 자료구조 

[그림 1]과 다르게 [그림 2]를 보면 앞과 뒤에서 삽입과 삭제를 할 수 있습니다. Deque는 Stack과 Queue의 장점을 모은 것으로 FIFO 방식과 LIFO 방식 둘 다 사용할 수 있습니다. 

5.2 Deque의 특징

Deque의 장점을 정리하면 아래와 같습니다. 

1. 크기가 가변적이다. 
리스트와 같이 데이터를 담을 수 있는 크기가 가변적입니다. 

2. 앞과 뒤에서 삽입과 삭제가 좋다. 
Deque가 다른 자료구조와 가장 다른 점으로 앞과 뒤에서 삽입, 삭제가 좋습니다. 

3. 중간에 데이터 삽입, 삭제가 용이하지 않다. 
데이터를 중간에 삽입하거나 삭제하는 것은 피해야 합니다. 삽입과 삭제를 중간에 한다면 삽입하거나 삭제한 위치 앞뒤 데이터를 모두 이동해야 합니다. 

 
[그림 3] 데이터 g를 중간에 삽입하는 과정 

 
[그림 4] 데이터 c를 삭제하는 과정 

4. 구현이 쉽지 않다. 
Deque은 Stack과 Queue가 결합된 자료구조로 연결 리스트보다 구현하기가 더 어렵습니다. 

5. 랜덤 접근이 가능하다. 

연결 리스트처럼 리스트를 탐색하지 않고 원하는 요소에 바로 접근할 수 있습니다.

5.3 deque를 사용하는 경우

Deque의 특징을 고려할 때 다음과 같은 경우에 사용하면 좋습니다. 

1. 앞과 뒤에서 삽입, 삭제를 한다. 
이것이 deque를 사용하는 가장 큰 이유입니다. 대부분 작업이 데이터를 앞이나 뒤에 삽입, 삭제를 한다면 STL 컨테이너 라이브러리 중에서 deque를 사용할 때 성능이 가장 좋습니다. 

2. 저장할 데이터 개수가 가변적이다. 
저장할 데이터 개수를 미리 알 수 없어도 deque는 크기가 동적으로 변하므로 유연하게 사용할 수 있습니다. 

3. 검색을 거의 하지 않는다. 
많은 데이터를 저장한다면 앞 회에서 여러 번 언급했듯이 map, set, hash_map 중 하나를 선택해서 사용하는 편이 좋습니다. 

4. 데이터 접근을 랜덤하게 하고 싶다. 
vector와 같이 랜덤 접근이 가능합니다. 사용하는 방법도 같습니다. 

5.4 deque VS vector

deque는 전체적으로 멤버 함수의 기능이나 사용 방법이 vector와 거의 같습니다. vector는 삽입과 삭제를 뒤(back)에서만 해야 성능이 좋지만, deque는 삽입과 삭제를 앞과 뒤에서 해도 좋으며 앞뒤 삽입, 삭제 성능도 vector보다 좋습니다. 하지만, deque는 앞뒤에서 삽입, 삭제하는 것을 제외한 다른 위치에서의 삽입과 삭제는 vector보다 성능이 좋지 않습니다. 

[표 1] deque와 vector의 차이 

deque와 vector를 비교할 때 고려해야 되는 점은 
deque는 앞과 뒤에서 삽입과 삭제 성능이 vector보다 더 좋다. 
deque는 앞과 뒤 삽입, 삭제를 제외한 기능은 vector보다 성능이 좋지 못하다. 

게임 서버에서 deque를 사용하는 경우 

게임 서버는 클라이언트에서 보낸 패킷을 차례대로 처리합니다. 서버에서 네트워크 데이터를 받는 함수에서 데이터를 받으면 패킷으로 만든 후 받은 순서대로 순차적으로 처리합니다. 이렇게 순차적으로 저장한 패킷을 처리할 때는 deque가 가장 적합한 자료구조입니다. 다만, 실제 현업에서는 이 부분에 STL의 deque를 사용하지 않는 경우가 종종 있습니다. 이유는 네트워크에서 데이터를 받아 패킷으로 만들어 저장하고, 그 패킷을 처리하는 부분은 게임 서버의 성능 면에서 가장 중요한 부분이므로 deque보다 더 빠르게 처리하기를 원하므로 독자적인 자료구조를 만들어 사용합니다(즉, 범용성보다는 성능을 우선시합니다). 

5.5 deque 사용 방법

deque를 사용하려면 deque 헤더 파일을 포함합니다.

#include 

deque 형식은 아래와 같습니다.

deque< 자료 type > 변수 이름

int를 사용하는 deque 선언은 아래와 같습니다.

deque< int > deque1;

deque도 동적 할당을 할 수 있습니다.

deque< 자료 type >* 변수 이름 = new deque< 자료 type >;
deque< int >* deque1 = new deque< int >;

5.5.1 deque의 주요 멤버들

deque 멤버 중 일반적으로 자주 사용하는 멤버들입니다. vector에 없는 pop_front와 push_front가 있다는 것 빼고는 vector의 기능과 같습니다. 

[표 2] 자주 사용하는 deque 멤버

5.5.2. 기본 사용 멤버

deque의 가장 기본적인(추가, 삭제, 접근 등) 사용법을 설명합니다. 

[표 3] 추가, 삭제, 접근 등에 사용하는 멤버들 

 
[그림 5] deque의 추가, 삭제, 접근 멤버들 

추가 

앞과 뒤에 추가를 할 수 있습니다. 보통 deque를 사용할 때는 뒤에 추가를 하고 앞에서는 삭제를 합니다. 앞쪽 추가는 push_front()를 사용합니다.

deque< int > deque1;
deque1.push_front( 100 );

뒤에 추가할 때는 push_back()을 사용합니다.

deque< int > deque1;
deque1.push_back( 200 );

삭제 

앞과 뒤에서 삭제 할 수 있습니다. 앞에서 삭제를 할 때는 pop_front()를 사용합니다.

deque1.pop_front();

뒤에서 삭제를 할 때는 pop_back()를 사용합니다.

deque1.pop_back();

접근 

첫 번째 위치의 반복자를 얻을 때는 begin()을 사용합니다.

deque< int >::iterator IterBegin = deque1.begin();
cout << *IterBegin << endl;

반복자로 다른 원소에 접근을 할 때는 반복자에 ‘++’ 이나 ‘–-‘을 사용합니다.

deque< int >::iterator IterPos = deque1.begin();

// 두 번째 위치로 이동
++IterPos;
// 첫 번째 위치로 이동
--IterPos;

end()는 deque에 저장된 원소 중 마지막 다음 위치, 즉 사용하지 못하는 영역을 가리킵니다. 보통 반복문에서 컨테이너에 남은 원소가 있는지 조사할 때 주로 사용합니다.

deque< int >::iterator IterEnd = deque1.end();
for(deque< int >::iterator IterPos = deque1.begin; IterPos != IterEnd;
     ++IterPos )
{
   ……
}

첫 번째 위치에 있는 데이터를 얻을 때는 front(), 마지막 위치에 있는 데이터를 얻을 때는 back()을 사용합니다.

int& FirstValue = deque1.front();
int& LastValue = deque1.back();

begin()과 end()는 순방향으로 앞과 뒤를 가리키고, 역방향으로는 rbegin()과 rend()를 사용합니다. 특정 위치에 있는 데이터를 얻을 때는 at()이나 배열 식 접근([])을 사용합니다.

int& Value2 = deque1.at(1); // 두 번째 위치
int Value3 = deque1[2];      // 세 번째 위치

모두 삭제 

clear()를 사용하면 저장한 모든 데이터를 삭제합니다.

deque1.clear();

데이터 저장 여부 

deque에 저장한 데이터가 있는지 없는지는 empty()로 조사합니다. 데이터가 있으면 false, 없다면 true를 반환합니다.

bool bEmpty = deque1.empty();

저장된 원소 개수 조사 

size()로 deque에 저장된 데이터 개수를 조사합니다.

deque< int >::size_type TotalCount = deque1.size();

지금까지 설명한 deque 멤버들의 사용법을 보면 전 회에 설명한 vector와 같다는 것을 충분히 알 수 있을 것입니다. vector를 공부하신 분들은 아주 쉽죠? ^^ 이후에 소개하는 내용도 vector에서 설명한 것과 같으니 편안하게 잘 따라와 주세요.

출처 : http://www.hanb.co.kr/

제공 : 한빛 네트워크
저자 : 최흥배
이전기사 :

• About STL : C++ STL 프로그래밍(1)
• About STL : C++ STL 프로그래밍(2-1)
• About STL : C++ STL 프로그래밍(2-2)

이번 회부터는 본격적으로 STL에 대해서 이야기합니다. STL은 C++ 템플릿을 사용해 만든 표준 라이브러리입니다. 그러니 템플릿에 대해서 아직 잘 모르시는 분들은 앞에 연재한 템플릿에 대한 글을 읽어보시기를 권합니다. 일반적으로 STL 중에서 가장 많이 사용하는 라이브러리는 컨테이너 라이브러리입니다. 컨테이너는 말 그대로 무엇인가를 담는 것입니다. 컨테이너는 int나 float 등의 기본 자료 형이나 구조체, 클래스같은 유저 정의 자료 형을 담습니다. STL의 컨테이너는 list, vector, deque, map, set이 있습니다. 이번 회는 list에 대해서 이야기합니다.

list의 자료구조

list는 자료구조 중 '연결 리스트'를 템플릿으로 구현한 것입니다. 그래서 list를 알려면 '연결 리스트'라는 자료구조의 이해가 꼭 필요합니다. 연결 리스트는 단어 그 자체로 해석하면 "(무엇인가)서로 연결 되어 줄지어 있다"라고 말할 수 있습니다. 말보다는 그림을 보는 것이 이해하기 쉬울 테니 아래 그림을 봐 주세요. 


그림 1. 연결 리스트

연결 리스트의 특징

1. 고정 길이인 배열에 비해 길이가 가변적이다.
배열은 처음에 설정한 크기 이외에는 더 이상 데이터를 담을 수 없지만 연결 리스트는 동적으로 크기를 변경 할 수 있습니다. 

2. 중간에 데이터 삽입, 삭제가 용이하다.
데이터를 중간에 삽입할 때 배열은 <그림 1>에서 B와 C사이에 새로운 데이터를 넣는다면 <그림 2>와 같이 C 이후의 데이터를 모두 뒤로 이동 해야 합니다. 그러나 연결 리스트는 <그림 3>과 같이 B와 C사이에 넣으면서 연결 고리만 바꾸면 됩니다. 


그림 2. 배열에서 데이터 삽입하기 


그림 3. 연결 리스트에서 데이터 삽입하기 

<그림 2>의 B를 삭제 하면 배열은 C 이후의 모든 데이터를 앞으로 이동해야 합니다. 그러나 연결 리스트는 <그림 4>와 같이 B를 삭제하고 B의 연결 고리를 없애면 됩니다. 


그림 4. 연결 리스트에서 데이터 삭제하기 

이렇게 연결 리스트는 배열에 비해서 크기가 가변적이고, 중간에 데이터 삭제와 삽입이 용이하다는 장점이 있습니다. 그렇지만 단점으로는 배열에 비해서 데이터의 삽입과 삭제를 구현하기 어렵고 내부 절차가 복잡합니다. 배열은 랜덤하게 접근할 수 있지만 연결 리스트는 랜덤하게 접근할 수 없습니다. 연결 리스트는 특징을 잘 파악한 후 알맞은 곳에 사용해야 됩니다.

STL list를 사용하면 좋은 점

STL을 사용하지 않는다면 C/C++ 언어, 자료구조를 공부하고 필요한 자료구조를 직접 만들어 사용해야 합니다. 직접 만들어 사용하면 여러 번 되풀이(프로젝트나 회사가 바뀌면)하여 만들어야 하므로 불필요한 시간을 소비하고, 연결 리스트 자료구조를 잘못 구현하여 버그를 만들 위험이 있고, 개인마다 구현 방법이 다르므로 사용이나 유지보수 측면에서 불편합니다. 

그러나 STL list(이하 list)를 사용하면 연결 리스트를 따로 만들어야 하는 시간을 절약할 수 있고, 이미 검증되어 있으므로 안전하고, 표준 라이브러리이므로 사용 방법이 언제나 같아서 사용 및 유지보수가 좋아집니다. 

다만, list를 사용할 때는 특성을 잘 파악하여 올바르게 사용해야 합니다. list를 적합하지 않은 곳에 사용하면 성능의 하락 및 시스템 에러를 유발할 위험이 생깁니다.

list를 사용해야 하는 경우

1. 저장할 데이터 개수가 가변적이다.
저장할 데이터 개수가 정해져 있지 않은 경우 배열은 설정된 크기를 넘어가면 데이터가 넘쳐서 실행 도중 프로그램 오류가 발생하므로 코드를 수정 후 재컴파일해야 됩니다. 그렇다고 배열에 설정된 크기가 변할 때마다 재컴파일하는 것을 방지하려고 넉넉한 크기로 큰 배열을 만든다면 메모리 낭비가 발생합니다. 그러나 list를 사용하면 저장 공간의 크기가 자동으로 변하므로 유연하게 사용할 수 있습니다.

2. 중간에 데이터 삽입이나 삭제가 자주 일어난다.
MMORPG 게임은 지도가 아주 크고 게임상에서 어떤 캐릭터의 행동에 대한 정보를 근처의 클라이언트에게만 통보하므로 지도를 작은 단위로(보통 사각형으로) 나눈 후 같은 단위에 포함 되어 있는 클라이언트와 그 단위 근처의 클라이언트에게만 통보합니다. 지도를 작은 단위로 분할하여 해당 영역에 들어오는 유저는 저장하고 나가는 유저는 삭제를 해야 합니다. 이와 같이 빈번하게 삽입과 삭제가 일어나는 곳에 list를 사용합니다. 


그림 5. 하나의 지도로 접속한 클라이언트간의 인접 위치를 관리하는 것은 너무 비효율적이므로 오른쪽과 같이 지도를 작은 단위로 나눈 후 접속한 클라이언트를 단위 별로 관리한다. 

3. 저장할 데이터 개수가 많으면서 검색을 자주 한다면 다른 컨테이너 라이브러리를 사용해야 한다.
아주 많은 데이터를 저장하면서 특정 데이터를 자주 검색해야 할 때 list를 사용하면 검색 속도가 많이 느려지므로 이런 경우에는 map이나 set, hash_map을 사용해야 합니다. 

4. 데이터를 랜덤하게 접근하는 경우가 많지 않다.
배열은 랜덤 접근이 가능하나 list는 순차 접근만 가능합니다. 그래서 저장된 위치를 알더라도 반복자(Iterator)(아래에 설명하겠습니다)를 통해서 접근해야 합니다. 아이템을 자주 사용하는 온라인 게임에서는 아이템 사용 시 아이템 정보에 빈번하게 접근하므로 성능을 위해 메모리 낭비를 감수하고 배열로 데이터를 저장해서 랜덤 접근을 사용하게 합니다.

list 사용 방법

list를 사용하려면 list 헤더 파일을 포함해야 합니다.

#include <list>

list 형식은 아래와 같습니다.

list< 자료 type > 변수 이름 

list를 int 형에 대해 선언했습니다.

list< int > list1;

선언 후에는 리스트를 사용하면 됩니다. 물론, 동적 할당도 가능합니다.

list < 자료 type >* 변수 이름 = new list< 자료 type >;
list< int >* list2 = new list< int>;

STL의 namespace

위에서는 list를 바로 사용했는데 이렇게 사용하려면 STL의 namespace를 선언해야 합니다.

using namespace std;

위와 같이 namespace를 선언하지 않고 list를 사용하려면 STL 라이브러리 앞에 namespace를 적어 줘야 합니다.

std::list< int > list;

반복자(Iterator)

list에 저장된 데이터에 접근하려면 반복자를 사용해야 하므로 list를 설명하기 전에 반복자에 대해서 간단하게 이야기합니다. 반복자는 포인터의 일반화된 개념이라고 봐도 됩니다. STL 컨테이너에 저장된 데이터를 순회할 수 있으며 컨테이너에서 특정 위치를 가리킵니다. 포인터와 비슷하게 ++과 --로 이동하고 대입과 비교도 가능합니다. 그리고 각 컨테이너는 컨테이너 전용의 반복자를 구현하고 있습니다. 반복자의 선언 형식은 다음과 같습니다.

STL의 컨테이너 < 자료 type >::iterator 변수 이름

반복자 사용에 대해서 예를 들어 보겠습니다. 


그림 6. 순 방향의 앞과 끝 반복자, 역 방향의 앞과 끝 반복자 

아래에 begin(), end(), rbegin(), rend()를 설명할 때 <그림 6>을 참고하세요. 설명을 위해 아래와 같이 list1을 선언합니다.

list< int > list1;

begin()
첫 번째 요소를 가리키는 반복자를 반환합니다.

예) list< int >::iterator iterFirst = list1.begin();

end()
마지막 요소를 가리킵니다. 주의할 점은 begin()과 달리 end()는 마지막 요소 바로 다음을 가리킵니다. 즉 사용할 수 없는 영역을 가리키므로 end() 위치의 반복자는 사용하지 못합니다.

예) list< int >::iterator iterEnd = list1.end();

for문에서 list에 저장된 모든 요소에 접근하려면 begin()과 end() 반복자를 사용하면 됩니다.

for( list< int >::iterator iterPos = list1.begin(); iterPos != list1.end(); ++iterPos )
{
  cout << "list1의 요소 : " << *iterPos << endl;
}

list< int >::iterator iterPos는 list에 정의된 반복자를 가져오며, list< int >::iterator iterPos = list1.begin();은 list1의 첫 번째 요소를 가리킵니다. iterPos != list1.end();는 반복자가 end()를 가리키면 for 문을 빠져 나오게 합니다. ++iterPos는 반복자를 하나씩 이동 시킵니다. 

rbegin()
begin()와 비슷한데 다른 점은 역 방향으로 첫 번째 요소를 가리킨다는 것입니다. 그리고 사용하는 반복자도 다릅니다.

예) list::reverse_iterator IterPos = list1->rbegin();

rend()
end()와 비슷한데 다른 점은 역 방향으로 마지막 요소 다음을 가리킨다는 것입니다.

예) list::reverse_iterator IterPos = list1.rend();

반복문에서 rbegin()과 rend()를 사용하여 list1의 각 데이터에 접근한다면 아래처럼 사용하면 됩니다.

for( list::reverse_iterator IterPos = list1.rbegin(); IterPos != list1.rend(); ++IterPos )
{
  cout << "역 방향 list1의 요소 : " << *IterPos << endl;
}

그럼 이제 본격적으로 list의 주요 멤버들의 사용 법에 대해서 설명합니다.

list의 주요 멤버들

표 1. 자주 사용하는 list 멤버 

그럼 각 멤버들의 사용법에 대해서 설명하겠습니다. 아래의 그림도 참조하세요 


그림 7. list의 앞과 뒤 추가 삭제 및 접근 


표 2. push_front, pop_front, push_back, pop_back, front, back, clear, empty, size의 원형 및 설명 

위에 설명한 것으로는 아직 감이 서지 않는 분도 있을 테니 위에 설명한 것을 사용하는 예제 코드를 봐 주세요. 아래의 코드는 게임에서 사용하는 아이템의 정보를 list 컨테이너를 사용하여 아이템 정보를 앞과 뒤에 추가 및 삭제를 하고 front, back를 사용하여 저장한 아이템 요소를 출력합니다. 

#include <iostream>
#include <list>

using namespace std;

// 아이템 구조체
struct Item
{
  Item( int itemCd, int buyMoney )
  {
    ItemCd = itemCd;
    BuyMoney = buyMoney;
  }

  int ItemCd;  // 아이템코드
  int BuyMoney;  // 판매금액
};

void main()
{
  list< Item > Itemlist;

  // 앞에 데이터 추가
  Item item1( 1, 2000 );
  Itemlist.push_front( item1 );

  Item item2( 2, 1000 );
  Itemlist.push_front( item2 );

  // 뒤에 데이터 추가
  Item item3( 3, 3000 );
  Itemlist.push_back( item3 );

  Item item4( 4, 4500 );
  Itemlist.push_back( item4 );

  // 아이템 코드 번호가 2, 1, 3, 4의 순서로 출력된다.
  list< Item >::iterator iterEnd = Itemlist.end();
  for(list< Item >::iterator iterPos = Itemlist.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "아이템 코드 : " << iterPos->ItemCd << endl;
  }

  // 앞에 있는 데이터를 삭제한다.
  Itemlist.pop_front();

  // 앞에 있는 데이터의 참조를 반환한다.
  Item front_item = Itemlist.front(); 
  // 아이템 코드 1이 출력된다.
  cout << "아이템 코드 : " << front_item.ItemCd << endl;


  // 마지막에 있는 데이터를 삭제한다.
  Itemlist.pop_back();

  // 마지막에 있는 데이터의 참조를 반환한다.
  Item back_item = Itemlist.back();
  // 아이템 코드 3이 출력된다.
  cout << "아이템 코드 : " << back_item.ItemCd << endl;

  // 저장된 데이터가 있는가?
  if( false == Itemlist.empty() )
  {
    list< Item >::size_type Count = Itemlist.size();
    cout << "남아 있는 아이템 개수: " << Count << endl;
  }

  // 모든 데이터를 지운다.
  Itemlist.clear();
  list< Item >::size_type Count = Itemlist.size();
  cout << "남아 있는 아이템 개수: " << Count << endl;
}

결과 

 

그럼 계속 해서 <표 1>에 소개된 list 멤버들의 설명을 계속 하겠습니다. 

insert 

insert는 지정된 위치에 삽입하며, 세 가지 방식이 있습니다. 세 가지 원형은 각각 지정된 위치에 삽입, 지정된 위치에 지정된 개수만큼 삽입, 지정된 위치에 지정 범위에 있는 것을 삽입합니다. 아래 그림을 참고하세요

원형 : iterator insert( iterator _Where, const Type& _Val );
       void insert( iterator _Where, size_type _Count, const Type& _Val );
       template void insert( iterator _Where, 
          InputIterator _First, InputIterator _Last );

그림 8. insert의 세 가지 방법 

첫 번째 insert는 지정한 위치에 데이터를 삽입합니다.

list< int >::iterator iterInsertPos = list1.begin();
list1.insert( iterInsertPos, 100 );

이 코드는 100을 첫 번째 위치에 삽입합니다.
두 번째 insert는 지정한 위치에 데이터를 횟수만큼 삽입합니다.

iterInsertPos = list1.begin();
++iterInsertPos;
list1.insert( iterInsertPos, 2, 200 );

list1의 두 번째 위치에 200을 두 번 추가합니다.
세 번째 insert는 지정한 위치에 복사 할 list의 시작과 끝 반복자가 가리키는 요소를 삽입합니다.

list< int > list2;
list2.push_back( 1000 );
list2.push_back( 2000 );
list2.push_back( 3000 );

iterInsertPos = list1.begin();
list1.insert( ++iterInsertPos, list2.begin(), list2.end() );

list1의 두 번째 위치에 list2의 모든 요소를 삽입합니다.
아래는 위에서 설명한 insert의 세 가지 방법을 사용한 전체 코드입니다. 

#include <iostream>
#include <list>

using namespace std;


void main()
{
  list< int > list1;

  list1.push_back(20);
  list1.push_back(30);


  cout << "삽입 테스트 1" << endl;

  // 첫 번째 위치에 삽입한다.
  list< int >::iterator iterInsertPos = list1.begin();
  list1.insert( iterInsertPos, 100 );
  
  // 100, 20, 30 순으로 출력된다.
  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }


  cout << endl << "삽입 테스트 2" << endl;

  // 두 번째 위치에 200을 2개 삽입한다.
  iterInsertPos = list1.begin();
  ++iterInsertPos;
  list1.insert( iterInsertPos, 2, 200 );
  
  // 100, 200, 200, 20, 30 순으로출력된다.
  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }


  cout << endl << "삽입 테스트 3" << endl;

  list< int > list2;
  list2.push_back( 1000 );
  list2.push_back( 2000 );
  list2.push_back( 3000 );

  // 두 번째 위치에 list2의 모든 데이터를 삽입한다.
  iterInsertPos = list1.begin();
  list1.insert( ++iterInsertPos, list2.begin(), list2.end() );
  
  // 100, 1000, 2000, 3000, 200, 200, 20, 30 순으로출력된다.
  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }
}

결과 

 

erase 

erase는 지정된 범위에 있는 데이터 삭제하며, 두 가지 방식이 있습니다. 하나는 지정된 위치의 데이터를 삭제하고, 다른 하나는 지정된 범위의 데이터를 삭제합니다.

원형 : iterator erase( iterator _Where );
       iterator erase( iterator _First, iterator _Last );

그림 9. erase의 두 가지 방법 

첫 번째 erase는 지정한 위치의 요소를 삭제합니다. 다음은 첫 번째 요소를 삭제하는 코드입니다.

list1.erase( list1.begin() );

두 번째 erase는 지정한 반복자 요소만큼 삭제합니다. 다음 코드는 list1의 두 번째 요소에서 마지막까지 모두 삭제합니다.

list< int >::iterator iterPos = list1.begin();
++iterPos;
list1.erase( iterPos, list1.end() );

아래는 erase의 두 가지 사용 방법을 보여주는 전체 코드입니다. 

void main()
{
  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(30);
  list1.push_back(40);
  list1.push_back(50);

  cout << "erase 테스트 1" << endl;

  // 첫 번째 데이터 삭제
  list1.erase( list1.begin() );

  // 20, 30, 40, 50 출력
  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }

  cout << endl << "erase 테스트2" << endl;

  // 두 번째 데이터에서 마지막까지 삭제한다.
  list< int >::iterator iterPos = list1.begin();
  ++iterPos;
  list1.erase( iterPos, list1.end() );
  
  // 20 출력
  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }
}

결과 

iterPos = vector.begin() + 3;

반복문에서 list의 데이터를 삭제하면서 반복하는 경우 조심하지 않으면 버그가 발생합니다. 아래의 코드를 잘 봐주세요. 

#include <iostream>
#include <list>

using namespace std;

void main()
{
  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(30);
  list1.push_back(40);
  list1.push_back(50);
  
  list< int >::iterator iterPos = list1.begin();
  while( iterPos != list1.end() )
  {
    // 3으로 나누어지는 것은 제거한다.
    if( 0 == (*iterPos % 3) )
    {
      // 삭제 되는 것의 다음 반복자를 저장하고 또 이동하지 않게 한다.
      iterPos = list1.erase( iterPos );
      continue;
    }
    cout << "list1 : " << *iterPos << endl;
    ++iterPos;
  }
}

remove 

list에서 지정한 값과 일치하는 모든 데이터 삭제. erase와 다른 점은 erase는 반복자를 통해서 삭제하지만 remove는 값을 통해서 삭제합니다.

원형 : void remove( const Type& _Val );

list1에 담겨 있는 요소 중 특정 값과 일치하는 것을 모두 삭제하고 싶을 때는 아래와 같이 합니다.

// 20을 삭제한다.
list1.remove( 20 );

위에서는 값 삭제를 했지만 list가 구조체(클래스)의 포인터를 담고 있다면 삭제를 원하는 구조체의 포인터를 통해서 삭제가 가능합니다. 아래는 pitem2 구조체의 포인터를 삭제합니다.

// Item 포인터를 담아야한다.
list< Item* > Itemlist;

Item* pitem1 = new Item( 10, 100 );  Itemlist.push_back( pitem1 );
Item* pitem2 = new Item( 20, 200 );  Itemlist.push_back( pitem2 );
Item* pitem3 = new Item( 30, 300 );  Itemlist.push_back( pitem3 );

// pitem2를 삭제한다.
Itemlist.remove( pitem2 );

remove의 사용법에 대한 전체 코드입니다. 

#include <iostream>
#include <list>

using namespace std;

// 아이템 구조체
struct Item
{
  Item( int itemCd, int buyMoney )
  {
    ItemCd = itemCd;
    BuyMoney = buyMoney;
  }

  int ItemCd;  // 아이템 코드
  int BuyMoney;  // 판매 금액
};


void main()
{
  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(20);
  list1.push_back(30);

  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }

  cout << endl << "remove  테스트 1" << endl;

  // 20을 삭제한다.
  list1.remove( 20 );

  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }
  

  cout << endl << "remove  테스트 2 - 구조체를 삭제" << endl;

  // Item 포인터를 담아야한다.
  list< Item* > Itemlist;
  
  Item* pitem1 = new Item( 10, 100 );  Itemlist.push_back( pitem1 );
  Item* pitem2 = new Item( 20, 200 );  Itemlist.push_back( pitem2 );
  Item* pitem3 = new Item( 30, 300 );  Itemlist.push_back( pitem3 );
  
  // pitem2를 삭제한다.
  Itemlist.remove( pitem2 );
  
  list< Item* >::iterator iterEnd2 = Itemlist.end();
  for(list< Item* >::iterator iterPos = Itemlist.begin(); 
    iterPos != iterEnd2; 
    ++iterPos )
  {
    cout << "Itemlist : " << (*iterPos)->ItemCd << endl;
  }
}

결과 

 

에서 구조체의 포인터를 담아서 삭제하는 것을 잘 보시기를 바랍니다. 보통 책에서는 이미 정의된 자료 타입만을 삭제하는 것을 보여주는데 사용자 정의 타입이라도 포인터로 담으면 해당 포인터로 삭제가 가능합니다. 

remove_if 

predicate을 만족하는 모든 데이터 삭제.
remove와 다른 점은 함수 객체를 사용하여 매개 변수로 전달된 인자를 조사하여 true라면 삭제하는 것입니다.
참고로 함수 객체라는 것은 괄호 연산자를 멤버함수로 가지는 클래스(또는 구조체) 객체입니다.
일반적으로 많이 사용되는 함수 객체는 STL에 정의 되어 있습니다.

원형 : template<class Predicate> void remove_if( Predicate _Pred );

remove_if에 사용할 함수 객체를 먼저 선언합니다.

// 20 이상 30 미만이면 true
template <typename T> class Is_Over20_Under30 : public std::unary_function 
{
public:
  bool operator( ) ( T& val ) 
  {
    return ( val >= 20 && val < 30 );
  }
};

list에서 remove_if에 함수 객체를 사용하여 list의 요소를 삭제하는 방법입니다.

  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(25);
  list1.push_back(30);
  list1.push_back(34);

  // 20 이상 30 미만은 삭제한다.
  list1.remove_if( Is_Over20_Under30< int >() );

list1의 요소 중 20 이상 30 미만은 모두 삭제합니다. 

아래는 remove_if 사용 예입니다. 

#include <iostream>
#include <list>

using namespace std;

// 20 이상 30 미만이면 true
template <typename T> class Is_Over20_Under30 : public std::unary_function 
{
public:
   bool operator( ) ( T& val ) 
   {
      return ( val >= 20 && val < 30 );
   }
};

void main()
{
  list< int > list1;

  list1.push_back(10);
  list1.push_back(20);
  list1.push_back(25);
  list1.push_back(30);
  list1.push_back(34);

  // 20 이상 30 미만은 삭제한다.
  list1.remove_if( Is_Over20_Under30< int >() );

  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }
}

결과 

 

sort 

데이터들을 정렬합니다. STL에 정의된 방식으로 정렬하거나 사용자가 정의한 방식으로 정렬할 수 있습니다.

원형 : template<class Traits> void sort( Traits _Comp );

sort 멤버를 사용하면 list1에 있는 요소들이 올림차순으로 정렬합니다.

// 올림 차순으로 정렬한다.
list1.sort();

내림차순으로 정렬한다면 greater를 사용합니다.

list1.sort( greater< int >() );

greater< int >는 greater< T > 라는 이미 정의되어 있는 함수 객체를 사용한 것입니다.
greater< int >는 int 형 x, y를 비교해서 x > y이면 true를 반환합니다.
그리고 greater외에 >=의 greater_equal, <=의 less_equal를 사용할 수 있습니다.
greater 이외의 것도 사용해 보기를 바랍니다.
사용자 정의 함수로 정렬하려면 함수 객체를 만들어야 합니다.
아래 함수 객체는 T의 멤버 중 ItemCd를 서로 비교하여 정렬을 합니다.

// 함수 객체 정의
template <typename T> struct COMPARE_ITEM
{
  bool operator()( const T l, const T r ) const
  {
    // 정렬 시에는 올림 차순으로된다. 내림 차순으로 하고 싶으면 < 에서 > 로
    // 변경하면 된다.
    return l.ItemCd < r.ItemCd;
  }
};

정의가 끝나면 아래와 같이 사용하면 됩니다.

Itemlist.sort( COMPARE_ITEM< Item >() );

Itemlist가 담고 있는 Item은 ItemCd를 기준으로 올림 차순으로 정렬한다.
아래 list의 sort 및 유저가 정의한 함수 객체를 사용한 sort에 대한 코드입니다. 

#include <iostream>
#include <list>

using namespace std;


// 함수 객체 정의
template <typename T> struct COMPARE_ITEM
{
    bool operator()( const T l, const T r ) const
    {
    // 정렬 시에는 올림 차순으로된다. 내림 차순으로 하고 싶으면 < 에서 > 로
    // 변경하면 된다.
      return l.ItemCd < r.ItemCd;
    }
};

void main()
{
  list< int > list1;

  list1.push_back(20);
  list1.push_back(10);
  list1.push_back(35);
  list1.push_back(15);
  list1.push_back(12);

  cout << "sort 올림차순" << endl;
  // 올림 차순으로 정렬한다.
  list1.sort();

  list< int >::iterator iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }

  cout << endl << "sort 내림차순" << endl;
  // 내림 차순으로 정렬한다.
  list1.sort( greater< int >() );

  iterEnd = list1.end();
  for(list< int >::iterator iterPos = list1.begin(); 
    iterPos != iterEnd; 
    ++iterPos )
  {
    cout << "list 1 : " << *iterPos << endl;
  }

  cout << endl << "sort - 유저가 정의한 방식으로 정렬" << endl;

  list< Item > Itemlist;
  
  Item item1( 20, 100 );  Itemlist.push_back( item1 );
  Item item2( 10, 200 );  Itemlist.push_back( item2 );
  Item item3( 7, 300 );  Itemlist.push_back( item3 );
  
  // 정렬한다.
  Itemlist.sort( COMPARE_ITEM< Item >() );
  
  list< Item >::iterator iterEnd2 = Itemlist.end();
  for(list< Item >::iterator iterPos = Itemlist.begin(); 
    iterPos != iterEnd2; 
    ++iterPos )
  {
    cout << "Itemlist : " << iterPos->ItemCd << endl;
  }
}

결과 

 

보통 책에서는 list에서 제공하는 sort를 사용하는 설명이 일반적입니다. 그러나 현실에서는 유저정의 형의 데이터를 list에 담아서 사용하므로 유저가 정의한 함수 객체를 사용하여 정렬하는 경우가 많습니다.
이것으로 list에서 일반적으로 가장 자주 사용하는 멤버들에 대해서 알아 보았습니다.
아직 소개하지 않은 멤버들도 더 있습니다. 그러나 보통 현재까지 설명한 것들만 알고 있으면 list를 사용하는데 별 어려움이 없습니다. 소개하지 않은 멤버는 뒤에 표로 정리하겠습니다.
그럼 지금까지 배운 것을 토대로 list를 사용하여 이전 회에서 만들었던 스택을 개선해 보겠습니다.

list를 사용한 스택

이전 회에 설명한 template로 만들었던 스택에 대해서 잘 기억이 나지 않는 분들은 다시 한번 봐 주세요. 

http://network.hanb.co.kr/view.php?bi_id=1572 

이전 회에 만들었던 스택은 유연성이 부족합니다. 저장 공간의 크기가 고정적이고, LIFO(후입선출. 마지막에 들어간 것이 먼저 나온다) 방식으로만 작동합니다. 이것을 저장 공간의 크기가 가변적이고, FIFO(선입선출. 먼저 들어간 것이 먼저 나온다) 방식으로도 저장이 가능하도록 합니다. 

#include <iostream>
#include <list>

using namespace std;

template<typename T> 
class Stack
{
public:
  Stack() { Clear(); }

  // 저장 방식을 설정한다.
  void SetInOutType( bool bLIFO ) { m_bLIFO = bLIFO; }

  // 초기화 한다.
  void Clear()
  {
    if( false == m_Datas.empty() )
      m_Datas.clear();
  }

  // 스택에 저장된 개수
  int Count() { return static_cast( m_Datas.size() ); }

  // 저장된 데이터가 없는가?
  bool IsEmpty() { return m_Datas.empty(); }

  
  // 데이터를 저장한다.
  void push( T data )
  {
    m_Datas.push_back( data ); 
  }

  // 스택에서 빼낸다.
  bool pop( T* data )
  {
    if( IsEmpty() )
    {
      return false;
    }


    if( m_bLIFO )
    {
      memcpy( data, &m_Datas.back(), sizeof(T) );
      m_Datas.pop_back();
    }
    else
    {
      memcpy( data, &m_Datas.front(), sizeof(T) );
      m_Datas.pop_front();
    }

    return true;
  }

private:
  list m_Datas;
  bool  m_bLIFO; // true 이면 후입선출, false 이면 선입선출
};



void main()
{
  Stack< int > Int_Stack;

  // LIFO로 설정
  Int_Stack.SetInOutType( true );

  Int_Stack.push( 10 );
  Int_Stack.push( 20 );
  Int_Stack.push( 30 );

  int Value = 0;
  Int_Stack.pop( &Value );
  cout << "LIFO pop : " << Value << endl << endl;

  Int_Stack.Clear();


  // FIFO로 설정
  Int_Stack.SetInOutType( false );

  Int_Stack.push( 10 );
  Int_Stack.push( 20 );
  Int_Stack.push( 30 );

  Int_Stack.pop( &Value );
  cout << "FIFO pop : " << Value << endl << endl;
}

결과 

 

List에 대해서 가장 많이 사용하는 것을 기준으로 설명했는데 그림과 예제 코드를 보면서 이해가 잘 되었는지 모르겠네요. 

보통 STL 관련 글을 보면 int나 float과 같은 기본 자료 타입을 사용하는 것에 대해서는 잘 나오지만, 유저 정의 자료 형을 사용하는 것에 대해서는 잘 나오지 않습니다. 그러니 예제 코드 중 유저 정의 자료 형을 사용한 부분을 특히 잘 보시기를 바랍니다. 다만, 유저 정의 자료 형을 사용하는 경우 함수 객체라는 것을 알아야 정확하게 이해가 될 테니 함수 객체 부분에 대해서는 아직 설명을 제대로 하지 않아서 잘 이해가 되지 않을까 걱정이 됩니다. 이 부분에 대해서는 다음에 함수 객체에 대해서 설명할 때 다시 언급 하겠습니다. 

list의 멤버는 제가 설명한 것 이외에도 더 있으니 좀 더 알고 싶은 분들은 http://msdn.microsoft.com/en-us/library/00k1x78a.aspx를 참고해 주세요. 


표 3. 설명하지 않은 list의 멤버들

과제

이번 회부터는 STL 라이브러리를 설명하고 있으므로 배운 것을 활용하여 프로그램을 만들어 볼 수가 있습니다. 일방적으로 저의 글만 보는 것은 심심할 테니 제가 내는 문제를 풀어 보시기를 바랍니다.^^ 


[과제 그림 1] 점 5개로 이루어진 도형 

위 그림은 순서대로 A, B, C, D, E 점을 찍은 후 서로 연결하여 도형이 만들어진 것입니다. 

과제 1) 이것을 list를 사용하여 만들어 보세요 

꼭 그림을 그리지 않아도 됩니다. A, B, C, D, E의 값을 순서대로 넣고 순서대로 출력하면 됩니다. 


[과제 그림 2] 새로운 점 F 추가 

과제 2) 점 F가 새로 추가 되었습니다. A, B, C, D, F, E 순으로 선이 연결 되도록 해 보세요. 

과제 3) 점 D의 값을 (200, 100)으로 변경해 보세요. 

과제 4) 점 C를 삭제해 보세요. 

아주 간단하게 list 조작을 테스트 해 볼 수 있는 간단한 과제라고 생각합니다. 꼭 프로그램을 만들어 보세요.

출처 : http://www.hanb.co.kr/

제공: 한빛 네트워크
저자: 최흥배
이전기사:

• About STL : C++ STL 프로그래밍(1)
• About STL : C++ STL 프로그래밍(2-1)

이전 기사에서는 함수 템플릿에 대해 설명을 했으니 이번에는 클래스 템플릿에 대해서 설명하려고 합니다. 클래스 템플릿을 아주 간단하게 말하면 함수 템플릿이 함수에 템플릿을 사용한 것처럼 클래스 템플릿은 클래스에 템플릿을 사용한 것입니다. 

그러니 함수 템플릿에 대해서 잘 모르시는 분은 꼭 함수 템플릿에 대한 글을 먼저 보고 이 글을 보는 것이 이해하기에 좋습니다.

경험치 변경 이력 저장

기획팀에서 유저들이 게임에 접속하여 다른 유저들과 100번의 게임을 했을 때 유저들의 경험치가 변경 되는 이력을 볼 수 있기를 요청 하였습니다. 

기획팀의 요구를 들어주기 위해서 저는 게임이 끝날 때마다 경험치를 저장합니다. 또 경험치 이력 내역을 출력할 때 가장 최신에서 가장 오랜 된 것을 보여줘야 되기 때문에 스택(stack)이라는 자료 구조를 사용합니다.

경험치 이력을 저장하는 클래스의 구현과 이것을 사용하는 것은 아래와 같습니다. 

// 경험치를 저장할 수 있는 최대 개수
const int MAX_EXP_COUNT = 100;

// 경험치 저장 스택 클래스
class ExpStack
{
public:
  ExpStack()
  {
    Clear();
  }

  // 초기화 한다.
  void Clear()
  {
    m_Count = 0;
  }

  // 스택에 저장된 개수
  int Count()
  {
    return m_Count;
  }

        // 저장된 데이터가 없는가?
  bool IsEmpty()
  {
    return 0 == m_Count ? true : false;
  }

  // 경험치를 저장한다.
  bool push( float Exp )
  {
    // 저장할 수 있는 개수를 넘는지 조사한다.
    if( m_Count >= MAX_EXP_COUNT )
    {
      return false;
    }

    // 경험치를 저장 후 개수를 하나 늘린다.
    m_aData[ m_Count ] = Exp;
    ++m_Count;

    return true; 
  }

  // 스택에서 경험치를 빼낸다.
  float pop()
  {
    // 저장된 것이 없다면 0.0f를 반환한다.
    if( m_Count  < 1 )
    {
      return 0.0f;
    }

    // 개수를 하나 감소 후 반환한다.
    --m_Count;
    return m_aData[ m_Count ];
  }

private:
  float  m_aData[MAX_EXP_COUNT];
  int    m_Count;
};

#include 

using namespace std;

void main()
{
  ExpStack kExpStack;
  
  cout << "첫번째 게임 종료- 현재 경험치 145.5f" << endl;
  kExpStack.push( 145.5f );

  cout << "두번째 게임 종료- 현재 경험치 183.25f" << endl;
  kExpStack.push( 183.25f );

  cout << "세번째 게임 종료- 현재 경험치162.3f" << endl;
  kExpStack.push( 162.3f );


  int Count = kExpStack.Count();
  for( int i = 0; i < Count; ++i )
  {
    cout << "현재 경험치->" << kExpStack.pop() << endl;
  }
}

실행 결과 

 

실행 결과를 보면 알 수 있듯이 스택 자료구조를 사용하였기 때문에 제일 뒤에 넣은 데이터가 가장 제일 먼저 출력 되었습니다.

게임 돈 변경 이력도 저장해 주세요

경험치 변경 이력을 저장하고 출력하는 기능을 만들어서 기획팀에 보여주니 이번에는 게임 돈의변경 이력도 보고 싶다고 말합니다. 

위에서 경험치 변경 이력 저장 기능을 만들어 보았으니 금방 할 수 있는 것이죠. 그래서 이번에는 이전 보다 훨씬 더 빨리 만들었습니다. 

// 돈을 저장할 수 있는 최대 개수
const int MAX_MONEY_COUNT = 100;

// 돈 저장 스택 클래스
class MoneyStack
{
public:
  MoneyStack()
  {
    Clear();
  }

  // 초기화 한다.
  void Clear()
  {
    m_Count = 0;
  }

  // 스택에 저장된 개수
  int Count()
  {
    return m_Count;
  }

  // 저장된 데이터가없는가?
  bool IsEmpty()
  {
    return 0 == m_Count ? true : false;
  }

  // 돈을 저장한다.
  bool push( __int64 Money )
  {
    // 저장 할 수 있는 개수를 넘는지 조사한다.
    if( m_Count >= MAX_MONEY_COUNT )
    {
      return false;
    }

    // 저장후 개수를 하나 늘린다.
    m_aData[ m_Count ] = Money;
    ++m_Count;

    return true; 
  }

  // 스택에서 돈을 빼낸다.
  __int64 pop()
  {
    // 저장된 것이 없다면 0을 반환한다.
    if( m_Count  < 1 )
    {
      return 0;
    }

    // 개수를 하나 감소 후 반환한다.
    --m_Count;
    return m_aData[ m_Count ];
  }

private:
  __int64  m_aData[MAX_MONEY_COUNT];
  int  m_Count;
};

ExpStack 클래스와 MoneyStack 클래스가 비슷합니다 

게임 돈 변경 이력 저장 기능을 가지고 있는 MoneyStack 클래스를 만들고 보니 앞에 만든 ExpStack와 거의 같습니다. 저장하는 데이터의 자료형만 다를뿐이지 모든 것이 같습니다. 그리고 기획팀에서는 게임 캐릭터의 Level 변경 이력도 저장하여 보여주기를 바라는 것 같습니다. 이미 거의 똑같은 클래스를 두개 만들었고 앞으로도 기획팀에서 요청이 있으면 더 만들 것 같습니다. 이렇게 자료형만 다른 클래스를 어떻게 하면 하나의 클래스로 정의 할수 있을까요? 이와 비슷한 문제를 이전의 "함수 템플릿"에서도 나타나지 않았나요? 그때 어떻게 해결했죠?(생각나지 않는 분들은 앞의 "함수 템플릿"을 다시 한번 봐 주세요 ^^) 

템플릿으로 하면됩니다. 

기능은 같지만 변수의 자료형만 다른 함수를 템플릿을 사용하여 하나의 함수로 정의했듯이 이번에는 템플릿을 사용하여 클래스를 정의합니다. 클래스에서 템플릿을 사용하면 이것을 클래스 템플릿이라고 합니다. 클래스 템플릿을 사용하면 위에서 중복된 클래스를 하나의 클래스로 만들 수 있습니다.

클래스 템플릿을 사용하는 방법

클래스 템플릿을 정의하는 문법은 아래와 같습니다. 

 

정의한 클래스 템플릿을 사용하는 방법은 아래와 같습니다. 

Stack 템플릿 클래스

지금까지 만들었던 ExpStack 과 MoneyStack을 클래스 템플릿으로 만든 코드는 아래와 같습니다. 

const int MAX_COUNT = 100;

template<typename T> 
class Stack
{
public:
  Stack()
  {
    Clear();
  }

  // 초기화 한다.
  void Clear()
  {
    m_Count = 0;
  }

  // 스택에 저장된 개수
  int Count()
  {
    return m_Count;
  }

  // 저장된 데이터가 없는가?
  bool IsEmpty()
  {
    return 0 == m_Count ? true : false;
  }

  // 데이터를 저장한다.
  bool push( T data )
  {
    // 저장 할수 있는 개수를 넘는지 조사한다.
    if( m_Count >= MAX_COUNT )
    {
      return false;
    }

    // 저장후 개수를 하나 늘린다.
    m_aData[ m_Count ] = data;
    ++m_Count;

    return true; 
  }

  // 스택에서 빼낸다.
  T pop()
  {
    // 저장된 것이 없다면 0을 반환한다.
    if( m_Count  < 1 )
    {
      return 0;
    }

    // 개수를 하나 감소 후 반환한다.
    --m_Count;
    return m_aData[ m_Count ];
  }

private:
  T  m_aData[MAX_COUNT];
  int    m_Count;
};

#include 

using namespace std;

void main()
{
  Stack kStackExp;
  
  cout << "첫번째 게임 종료- 현재 경험치 145.5f" << endl;
  kStackExp.push( 145.5f );

  cout << "두번째 게임 종료- 현재 경험치 183.25f" << endl;
  kStackExp.push( 183.25f );

  cout << "세번째 게임 종료- 현재 경험치 162.3f" << endl;
  kStackExp.push( 162.3f );


  int Count = kStackExp.Count();
  for( int i = 0; i < Count; ++i )
  {
    cout << "현재 경험치->" << kStackExp.pop() << endl;
  }

  cout << endl << endl;

  Stack<__int64> kStackMoney;
  
  cout << "첫번째 게임 종료- 현재 돈 1000023" << endl;
  kStackMoney.push( 1000023 );

  cout << "두번째 게임 종료- 현재 돈 1000234" << endl;
  kStackMoney.push( 1000234 );

  cout << "세번째 게임 종료- 현재 돈 1000145" << endl;
  kStackMoney.push( 1000145 );


  Count = kStackMoney.Count();
  for( int i = 0; i < Count; ++i )
  {
    cout << "현재 돈->" << kStackMoney.pop() << endl;
  }
}

실행 결과 

 

클래스 템플릿으로 Stack을 구현하여 앞으로 다양한 데이터를 사용할 수 있게 되었습니다. 

그런데 위의 Stack 클래스는 부족한 부분이 있습니다. 앞으로 이 부족한 부분을 채워 나가면서 클래스 템플릿에 대해서 좀 더 알아 보겠습니다.

클래스 템플릿에서 non-type 파라메터 사용

위에서 만든 Stack 클래스는 데이터를 저장할 수 있는 공간이 100개로 정해져 있습니다. Stack의 크기는 사용하는 곳에 따라서 변동될 수 있어야 사용하기에 적합합니다. 

함수 템플릿을 설명할 때도 non-type이 나왔는데 사용 방법이 거의 같습니다. 템플릿 파라메터를 기본 데이터 형으로 합니다. 아래의 사용 예를 보시면 금방 이해가 갈 것입니다. 

// 템플릿 파라메터중 int Size가 non-type  파라메터입니다.
template<typename T, int Size> 
class Stack
{
public:
  Stack()
  {
    Clear();
  }

  // 초기화 한다.
  void Clear()
  {
    m_Count = 0;
  }

  // 스택에 저장된 개수
  int Count()
  {
    return m_Count;
  }

  // 저장된 데이터가 없는가?
  bool IsEmpty()
  {
    return 0 == m_Count ? true : false;
  }

  // 데이터를 담을수 있는 최대 개수
  int GetStackSize()
  {
    return Size;
  }

  // 데이터를 저장한다.
  bool push( T data )
  {
    // 저장할 수 있는 개수를 넘는지 조사한다.
    if( m_Count >= Size )
    {
      return false;
    }

    // 저장 후 개수를 하나 늘린다.
    m_aData[ m_Count ] = data;
    ++m_Count;

    return true; 
  }

  // 스택에서 빼낸다.
  T pop()
  {
    // 저장된 것이 없다면 0을 반환한다.
    if( m_Count  < 1 )
    {
      return 0;
    }

    // 개수를 하나 감소 후 반환한다.
    --m_Count;
    return m_aData[ m_Count ];
  }

private:
  T  m_aData[Size];
  int  m_Count;
};

#include 

using namespace std;

void main()
{
  Stack kStack1;
  cout << "스택의 크기는?" << kStack1.GetStackSize() << endl;

  Stack kStack2;
  cout << "스택의 크기는?" << kStack2.GetStackSize() << endl;
}

실행 결과 

템플릿 파라메터 디폴트 값 사용

일반 함수에서 함수 인자의 디폴트 값을 지정하듯이 클래스 템플릿의 파라메터도 디폴트 값으로 할 수 있습니다. 

// 템플릿 파라메터중 int Size가 non-type 파라메터입니다. 
// Size의 디폴트 값을 100으로 합니다.
template<typename T, int Size=100> 
class Stack
{
   …..  생략
}

void main()
{
  Stack kStack1;
  cout << "스택의크기는?" << kStack1.GetStackSize() << endl;

  Stack kStack2;
  cout << "스택의크기는?" << kStack2.GetStackSize() << endl;
}

List5에서 템플릿 파라메터 중 Size의 값을 디폴트 100으로 했습니다. 클래스를 생성할 때 두 번째 파라메터 값을 지정하지 않으면 디폴트 값이 사용 됩니다. 

실행 결과 

스택 클래스의 크기를 클래스 생성자에서 지정

클래스 템플릿에 대한 설명을 계속 하기 위해 현재까지 만든 스택 클래스를 변경합니다. 스택의 크기를 클래스 템플릿 파라메터가 아닌 생성자에서 지정하도록 변경하겠습니다. 

template<typename T, int Size=100> 
class Stack
{
public:
  explicit Stack( int size )
  {
    m_Size = size;
    m_aData = new T[m_Size];

    Clear();
  }

  ~Stack()
  {
    delete[] m_aData;
  }

  // 초기화 한다.
  void Clear()
  {
    m_Count = 0;
  }

  // 스택에 저장된 개수
  int Count()
  {
    return m_Count;
  }

  // 저장된 데이터가 없는가?
  bool IsEmpty()
  {
    return 0 == m_Count ? true : false;
  }

  // 데이터를 담을 수 있는 최대 개수
  int GetStackSize()
  {
    return m_Size;
  }

  // 데이터를 저장한다.
  bool push( T data )
  {
    // 저장할 수 있는 개수를 넘는지 조사한다.
    if( m_Count >= m_Size )
    {
      return false;
    }

    // 저장 후 개수를 하나 늘린다.
    m_aData[ m_Count ] = data;
    ++m_Count;

    return true; 
  }

  // 스택에서 빼낸다.
  T pop()
  {
    // 저장된 것이 없다면 0을 반환한다.
    if( m_Count  < 1 )
    {
      return 0;
    }

    // 개수를 하나 감소 후 반환한다.
    --m_Count;
    return m_aData[ m_Count ];
  }

private:
  T*  m_aData;
  int  m_Count;

  int m_Size;
};

#include 

using namespace std;


void main()
{
  Stack kStack1(64);
  cout << "스택의 크기는? " << kStack1.GetStackSize() << endl;
}

실행결과 

 

List 6의 코드에서 잘 보지 못한 키워드가 있을 것입니다. 바로 explicit 입니다. explicit 키워드로 규정된 생성자는 암시적인 형 변환을 할 수 없습니다. 그래서 List6의 void main()에서

  Stack kStack1 = 64; 

로 클래스를 생성하면 컴파일 에러가 발생합니다.

클래스 템플릿 전문화

기획팀에서 새로운 요구가 들어왔습니다. 이번에는 게임을 할 때 같이 게임을 했던 유저의 아이디를 저장하여 보여주기를 원합니다. 지금까지 만든 Stack 클래스는 기본 자료형을 사용하는 것을 전제로 했는데 유저의 아이디를 저장하려면 문자열이 저장되어야 하므로 사용할 수가 없습니다. 

기본 자료형으로 하지 않고 문자열을 사용한다는 것만 다르지 작동은 비슷하므로 Stack이라는 이름의 클래스를 사용하고 싶습니다. 기존의 Stack 클래스 템플릿과 클래스의 이름만 같지 행동은 다른 Stack 클래스를 구현 하려고 합니다. 이때 필요한 것인 클래스 템플릿의 전문화라는 것입니다. 클래스 템플릿 전문화는 기존에 구현한 클래스 템플릿과 이름과 파라메터 개수는 같지만 파라메터를 특정한 것으로 지정합니다. 

전문화된 클래스 템플릿 정의는 다음과 같은 형태를 가진다.

template <> 
class 클래스 이름<지정된 타입>
{
   ……………….
};

아래의 코드는 문자열을 저장하기 위해 char* 으로 전문화한 Stack 클래스입니다. 

// ID 문자열의 최대 길이(null 문자포함)
const int MAX_ID_LENGTH = 21;

// char* 를 사용한 Stack 클래스(List 6) 템플릿 전문화
template<> 
class Stack
{
public:
  explicit Stack( int size )
  {
    m_Size = size;

    m_ppData = new char *[m_Size];
    for( int i = 0; i < m_Size; ++i )
    {
      m_ppData[i] = new char[MAX_ID_LENGTH];
    }

    Clear();
  }

  ~Stack()
  {
    for( int i = 0; i < m_Size; ++i )
    {
      delete[] m_ppData[i];
    }

    delete[] m_ppData;
  }

  // 초기화한다.
  void Clear()
  {
    m_Count = 0;
  }

  // 스택에 저장된 개수
  int Count()
  {
    return m_Count;
  }

  // 저장된 데이터가 없는가?
  bool IsEmpty()
  {
    return 0 == m_Count ? true : false;
  }

  // 데이터를 담을 수 있는 최대 개수
  int GetStackSize()
  {
    return m_Size;
  }

  // 데이터를 저장한다.
  bool push( char* pID )
  {
    // 저장할 수 있는 개수를 넘는지 조사한다.
    if( m_Count >= m_Size )
    {
      return false;
    }

    // 저장 후 개수를 하나 늘린다.
    strncpy_s( m_ppData[m_Count], MAX_ID_LENGTH, pID, MAX_ID_LENGTH - 1);
    m_ppData[m_Count][MAX_ID_LENGTH - 1] = '\0';

    ++m_Count;

    return true; 
  }

  // 스택에서 빼낸다.
  char* pop()
  {
    // 저장된 것이 없다면 0을 반환한다.
    if( m_Count  < 1 )
    {
      return 0;
    }

    // 개수를 하나 감소 후 반환한다.
    --m_Count;
    return m_ppData[ m_Count ];
  }

private:
  char** m_ppData;
  int  m_Count;

  int m_Size;
};

#include 

using namespace std;

void main()
{
  Stack kStack1(64);
  cout << "스택의 크기는? " << kStack1.GetStackSize() << endl;
  kStack1.push( 10 );
  kStack1.push( 11 );
  kStack1.push( 12 );

  int Count1 = kStack1.Count();
  for( int i = 0; i < Count1; ++i )
  {
    cout << "유저의 레벨 변화 -> " << kStack1.pop() << endl;
  }

  cout << endl;

  char GameID1[MAX_ID_LENGTH] = "NiceChoi";
  char GameID2[MAX_ID_LENGTH] = "SuperMan";
  char GameID3[MAX_ID_LENGTH] = "Attom";

  // Stack 클래스 템플릿의 char*  전문화 버전을 생성한다.
  Stack kStack2(64);
  kStack2.push(GameID1);
  kStack2.push(GameID2);
  kStack2.push(GameID3);

  int Count2 = kStack2.Count();
  for(int i = 0; i < Count2; ++i)
  {
    cout << "같이 게임을 한유저의 ID -> " << kStack2.pop() << endl;
  }
}

실행 결과 

클래스 템플릿 부분 전문화

클래스 템플릿은 템플릿 파라메터 중 일부를 구체적인 형(type)을 사용, 또는 템플릿 파라메터를 포인터나 참조를 사용하여 부분 전문화를 할 수 있습니다. 

- 구체적인 형 사용에 의한 부분 전문화

template< typename T1, typename T2 > class Test { …. };

의 T2를 float로 구체화 하여 부분 전문화를 하면 다음과 같습니다.

template< typename T1 > class Test { ….. };

코드는 다음과 같습니다. 

template< typename T1, typename T2 >
class Test
{
public:
  T1 Add( T1 a, T2 b )
  {
    cout << "일반 템플릿을 사용했습니다." << endl;
    return a;
  }
};

// T2를 float로 구체화한 Test의 부분 전문화 템플릿
template< typename T1 > 
class Test
{
public:
  T1 Add( T1 a, float b )
  {
    cout << "부분 전문화 템플릿을 사용했습니다." << endl;
    return a;
  }
};

#include 

using namespace std;

void main()
{
  Test test1;
  test1.Add( 2, 3 );

  Test test2;
  test2.Add( 2, 5.8f );
}

 

위의 예에서는 템플릿 파라메터 2개 중 일부를 구체화하여 부분 전문화를 했지만 당연하지만 2개 이상도 가능합니다.

template< typename T1, typename T2, typename T3 > class Test { …. };

의 부분 전문화 템플릿은

template< typename T1, typename T2 > class Test { ….. };

- 포인터의 부분 전문화

template< typename T > class TestP { …. };

의 T의 T* 부분 전문화를 하는 다음과 같습니다.

template< typename T > class TestP {  …… };

코드는 다음과 같습니다. 

template< typename T > 
class TestP
{
public:
  void Add()
  {
    cout << "일반 템플릿을 사용했습니다." << endl;
  }
};

// T를 T*로 부분 전문화
template< typename T > 
class TestP
{
public:
  void Add()
  {
    cout << "포인터를 사용한 부분 전문화 템플릿을 사용했습니다." << endl;
  }
};

#include 

using namespace std;

void main()
{
  TestP test1;
  test1.Add();

  TestP test2;
  test2.Add();
}

실행 결과 

싱글톤 템플릿 클래스

클래스 상속을 할 때 템플릿 클래스를 상속 받음으로 상속 받는 클래스의 기능을 확장할 수 있습니다. 

저의 경우 현업에서 클래스 템플릿을 가장 많이 사용하는 경우가 클래스 템플릿을 사용한 싱글톤 클래스 템플릿을 사용하는 것입니다. 

어떠한 객체가 꼭 하나만 있어야 되는 경우 싱글톤으로 정의한 클래스 템플릿을 상속 받도록 합니다.

사용하는 방법은 베이스 클래스를 템플릿을 사용하여 만듭니다. 그리고 이것을 상속 받는 클래스에서 베이스 클래스의 템플릿 파라메터에 해당 클래스를 사용합니다. 즉 싱글톤 클래스 템플릿은 이것을 상속 받는 클래스를 싱글톤으로 만들어줍니다. 

위에서 설명한 클래스 템플릿에 대하여 이해를 하셨다면 의 코드를 보면 이해를 할 수 있으리라 생각합니다. 싱글톤 클래스 템플릿은 직접 생성을 하지 않으므로 주 멤버들을 static로 만들어줍니다. 그리고 생성자를 통해서 _Singleton를 생성하지 않고 GetSingleton()을 통해서만 생성하도록 합니다. 

#include 
using namespace std;


// 파라메터 T를 싱글톤이 되도록 정의 합니다.
template <typename T>
class MySingleton
{
public:
    MySingleton() {}
    virtual ~MySingleton() {}

    // 이 멤버를 통해서만 생성이 가능합니다.
    static T* GetSingleton()
    {
        // 아직 생성이 되어 있지 않으면 생성한다.
        if( NULL == _Singleton ) {
            _Singleton = new T; 
        }

       return ( _Singleton );
    }

    static void Release()
    {
        delete _Singleton;
        _Singleton = NULL;
    }

private:
    static T* _Singleton;
};

template <typename T> T* MySingleton ::_Singleton = NULL;

// 싱글톤 클래스 템플릿을 상속 받으면서 파라메터에 본 클래스를 넘깁니다.
class MyObject : public MySingleton
{
public:
MyObject() : _nValue(10) {}

void SetValue( int Value ) { _nValue = Value;}  
int GetValue() { return _nValue; }

private :
int _nValue;
};

void main()
{
   MyObject* MyObj1 = MyObject::GetSingleton();

   cout << MyObj1->GetValue() << endl;

   // MyObj2는 Myobj1과 동일한 객체입니다.
   MyObject* MyObj2 = MyObject::GetSingleton();
   MyObj2->SetValue(20);

   cout << MyObj1->GetValue() << endl;
   cout << MyObj2->GetValue() << endl;
}

클래스 템플릿 코딩 스타일 개선

위에서 예제로 구현한 다양한 클래스 템플릿의 코딩 스타일은 클래스 선언 안에서 각 멤버들의 정의를 구현하고 있습니다. 클래스의 코드 길이가 크지 않은 경우는 코드를 보는데 불편하지 않지만 코드 길이가 길어지는 경우 클래스의 전체적인 윤곽을 바로 알아보기가 쉽지 않습니다. 

긴 코드를 가지는 클래스 템플릿의 경우는 클래스의 선언과 정의를 분리하는 것이 좋습니다. 위에서 예제로 나온 클래스 템플릿 중 의 Stack 클래스 템플릿을 선언과 정의를 분리하면 아래와 같습니다. 

template<typename T> 
class Stack
{
public:
  explicit Stack( int size );

  ~Stack();

  // 초기화 한다.
  void Clear();

  // 스택에 저장된 개수
  int Count();

  // 저장된 데이터가 없는가?
  bool IsEmpty();

  // 데이터를 담을 수 있는 최대 개수
  int GetStackSize();

  // 데이터를 저장한다.
  bool push( T data );

  // 스택에서 빼낸다.
  T pop();

private:
  T*  m_aData;
  int  m_Count;

  int m_Size;
};

template < typename T > 
Stack::Stack( int size )
{
  m_Size = size;
  m_aData = new T[m_Size];

  Clear();
}

template < typename T > 
Stack::~Stack()
{
  delete[] m_aData;
}

template < typename T > 
void Stack::Clear()
{
  m_Count = 0;
}

template < typename T > 
int Stack::Count()
{
  return m_Count;
}

template < typename T >
bool Stack::IsEmpty()
{
  return 0 == m_Count ? true : false;
}

template < typename T > 
int Stack::GetStackSize()
{
  return m_Size;
}

template < typename T > 
bool Stack::push( T data )
{
  // 저장할 수 있는 개수를 넘는지 조사한다.
  if( m_Count >= m_Size )
  {
    return false;
  }

  // 저장 후 개수를 하나 늘린다.
  m_aData[ m_Count ] = data;
  ++m_Count;

  return true; 
}

template < typename T > 
T Stack::pop()
{
  // 저장된 것이 없다면 0을 반환한다.
  if( m_Count  < 1 )
  {
    return 0;
  }

  // 개수를 하나 감소 후 반환한다.
  --m_Count;
  return m_aData[ m_Count ];
}

의 코드를 보면 알듯이 클래스 안에 정의를 했던 것과의 차이점은 클래스 멤버 정의를 할 때 템플릿 선언하고 클래스 이름에 템플릿 파라메터를 적어 줍니다.

클래스 선언과 정의를 각각 다른 파일에 하려면

일반적인 클래스의 경우 크기가 작은 경우를 제외하면 클래스의 선언과 정의를 서로 다른 파일에 합니다. 

클래스 템플릿의 경우는 일반적인 방법으로는 그렇게 할 수가 없습니다. 클래스 멤버 정의를 선언과 다른 파일에 하려면 멤버 정의를 할 때 'export'라는 키워드를 사용합니다. 의 GetStackSize()에 export를 사용하면 아래와 같이 됩니다.

template < typename T > 
export int Stack::GetStackSize()
{
  return m_Size;
}

그러나 export라는 키워드를 사용하면 컴파일 에러가 발생합니다. 이유는 현재 대부분의 C++ 컴파일러에서는 export라는 키워드를 지원하지 않습니다. export를 아직 지원하지 못하는 이유는 이것을 지원하기 위해 필요로 하는 노력은 컴파일러를을 새로 만들 정도의 노력을 필요로 할 정도로 어렵다고 합니다. 현재까지도 대부분의 컴파일러 개발자들은 구현 계획을 세우지도 않고 있으며 일부에서는 구현에 반대하는 의견도 있다고 합니다. 

그럼 클래스 템플릿의 선언과 정의를 서로 다른 파일에 할 수 있는 방법은 없을까요? 약간 편법을 사용하면 가능합니다. 

inline이라는 의미를 가지고 있는 '.inl' 확장자 파일에 클래스 구현하고 이 .inl 파일을 헤더 파일에서 포함합니다. (참고로 .inl 파일을 사용하는 것은 일반적인 방식은 아니고 일부 라이브러리나 상용 3D 엔진에서 간혹 사용하는 것을 볼 수 있습니다). 

의 Stack 클래스 템플릿의 선언과 정의를 다른 파일로 하는 예의 일부를 아래에 보여드리겠습니다.

// stack.h 파일
template<typename T> 
class Stack
{
public:

  // 초기화 한다.
  void Clear();
 
};

#include "stack.inl"

// stack.inl 파일

template < typename T > 
void Stack::Clear()
{
  m_Count = 0;
}

이것으로 클래스 템플릿에 대한 설명은 다 한 것 같습니다. 함수 템플릿에 대한 글을 이미 보셨으면 템플릿에 대한 어느 정도 이해를 가지고 있을 테니 어렵지 않게 이해를 할 수 있으리라 생각합니다만 저의 부족한 글 때문에 어렵지 않았을까라는 걱정도 조금합니다. 

글을 그냥 보고 넘기지 마시고 직접 코딩을 해 보시기를 권장합니다. 본문에 나오는 예제들은 모두 코드 길이가 짧은 것이라서 직접 코딩을 하더라도 긴 시간은 걸리지 않을 것입니다. 

다음회부터는 본격적으로 STL에 대한 설명에 들어갑니다. 전 회에서 이야기 했듯이 STL은 템플릿으로 만들어진 것입니다. 아직 템플릿의 유용성을 느끼지 못한 분들은 STL에 대해서 알게 되시면 템플릿의 뛰어남을 알게 되리라 생각합니다.

출처 : http://www.hanb.co.kr/

제공: 한빛 네트워크
저자: 최흥배
이전기사:

• About STL : C++ STL 프로그래밍(1)

함수 템플릿

두 값을 비교하는 함수를 만들어야 됩니다.

앞서 제가 하는 일을 이야기했습니다. 네, 온라인 게임을 만들고 있습니다. 게임에서 구현해야 되는 것에는 캐릭터 간에 HP를 비교하는 것이 필요합니다. 그래서 두 개의 int 타입을 비교하는 Max라는 이름의 함수를 하나 만들었습니다.

int Max( int a, int b );

일을 다 끝낸 후 다음 기획서를 보니 캐릭터와 NPC가 전투를 하는 것을 구현해야 되는데 여기에는 경험치를 비교하는 기능이 필요합니다. 구현해야 되는 것은 위에서 만든 Max 함수와 같습니다. 그래서 그것을 사용하였습니다. 

< List 1 >

#include 
using namespace std;

int Max( int a, int b )
{
  return a > b ? a : b;
}

void main()
{
  int Char1_HP = 300;
  int Char2_HP = 400;
  int MaxCharHP = Max( Char1_HP, Char2_HP );
  cout << "HP 중 가장 큰 값은" << MaxCharHP << "입니다." << endl << endl;
  
  float Char1_Exp = 250.0f;
  float Char2_Exp = 250.57f;
  float MaxCharExp = Max( Char1_Exp, Char2_Exp );
  cout << "경험치 중 가장 큰 값은" << MaxCharExp << "입니다." << endl << endl;
}

앗, 체력(HP)을 저장하는 변수의 타입은 int인데, 경험치를 저장하는 변수의 타입은 int가 아닌 float 타입니다. 

 

당연하게 경험치를 비교하는 부분은 버그가 있습니다.
앞에 만들었던 Max와는 다르게 비교하는 변수의 타입이 float인 것이 필요하여 새로 만들었습니다. 

< List 2 >

float Max( float a, float b )
{
  return a > b ? a : b;
}

함수 오버로딩에 의해 경험치를 비교할 때는 int 타입의 Max가 아닌 의 float 타입을 비교하는 Max가 호출되어 버그가 사라지게 되었습니다. 

이제 경험치 비교는 끝나서 다음 기획서에 있는 것을 구현해야 합니다. 이번에는 돈을 비교하는 것이 있습니다. 그런데 돈을 저장하는 변수의 타입은 __int64입니다. __int64는 비주얼 C++에서만 사용할 수 있는 64비트 정수 타입입니다. __int64 타입을 비교하는 것은 앞에서 만든 int 타입의 Max나 float 타입의 Max로 할 수 없습니다. 함수에서 사용하는 변수의 타입만 다를 뿐 똑같은 것을 또 만들어야 됩니다.

__int64 Max(__int64 a, __int64 b )
{
  return a > b ? a : b;
}

현재까지만 하더라도 이미 똑같은 로직으로 구현된 함수를 3개나 만들었는데, 게임에서 사용하는 캐릭터의 정보는 HP, 경험치, 돈 이외에도 더 많습니다. 저는 앞으로 Max 함수를 몇 개 더 만들어야 할지 모릅니다. Max 함수의 구현을 고쳐야 한다면 모든 Max 함수를 찾아야 합니다. 함수 오버로딩은 문제를 해결하지만, 코드가 커지고 유지보수는 어렵게 만듭니다. 

프로그래밍에서 유지보수는 아주 중요합니다. 왜냐하면, 프로그래밍은 언제나 변경이 가해지기 때문입니다. 유지보수를 편하게 하는 가장 간단한 방법은 유지보수 할 것을 줄이는 것입니다.

Max 함수를 하나로 만들고 싶습니다. 어떻게 해야 될까요?

앗, 혹시 모른다고요? 제가 이 앞에 템플릿에 대해 설명을 할 때 이런 말을 하지 않았나요?
'템플릿을 사용하면 타입에 제약을 받지 않는 로직을 기술 할 수 있습니다'
네, 템플릿을 사용하면 됩니다. 

함수 템플릿 Max를 만들자 

아래의 코드는 템플릿을 사용하여 Max 함수를 구현 한 것입니다. 

< List 3 >

#include 
using namespace std;

// 템플릿으로 만든 값을 비교하는 Max 함수
template 
T Max(T a, T b )
{
  return a > b ? a : b;
}


void main()
{
  int Char1_HP = 300;
  int Char2_HP = 400;
  int MaxCharHP = Max( Char1_HP, Char2_HP );
  cout << "HP 중 가장 큰 값은" << MaxCharHP << "입니다." << endl << endl;
  
  float Char1_Exp = 250.0f;
  float Char2_Exp = 250.57f;
  float MaxCharExp = Max( Char1_Exp, Char2_Exp );
  cout << "경험치 중 가장 큰 값은" << MaxCharExp << "입니다." << endl << endl;
}

실행한 결과는 다음과 같습니다. 

 

네 이번에는 경험치 비교가 정확하게 이루어졌습니다.
템플릿을 사용하게 되어 이제는 불필요한 Max 함수를 만들지 않아도 됩니다.. 

List 3 코드에서 template으로 만든 함수를 '함수 템플릿'이라고 합니다. 

함수 템플릿을 정의하는 방법은 아래와 같습니다. 

 

템플릿을 사용하면 Generic Programming을 할 수 있다
라고 앞서 이야기 했는데 위의 Max 함수 템플릿을 보고 좀 이해를 하셨나요?
혹시나 해서 그림으로 조금만 더 설명하겠습니다. 

 

암소를 총칭(Generic)화하면 동물이라고 할 수 있습니다.
Max 함수 템플릿에서는 함수의 반환 값과 함수 인자인 a 와 b의 타입인 int 나 float를 T로 Generic화 하였습니다. 

함수 템플릿과 컴파일

하나의 Max 함수 템플릿을 만들었는데 어떻게 int 타입의 Max와 float 타입의 Max를 사용할 수 있을까요? 비밀은 컴파일하는 과정에 있습니다. 컴파일할 때 템플릿으로 만든 것은 템플릿으로 만든 함수를 호출하는 부분에서 평가합니다. 가상 함수처럼 실행시간에 평가하는 것이 아닙니다. 

컴파일을 할 때(compile time) 함수 템플릿을 평가하므로 프로그램의 성능에 해가 되는 것은 없습니다. 

컴파일할 때 평가를 하면서 문법적으로 에러가 없는지 검사합니다. 만약 에러가 있다면 컴파일 에러를 출력합니다. 에러가 없다면 관련 코드를 내부적으로 생성합니다. 

List 3을 예로 들면, void main()의 다음 부분을 컴파일하면 Max를 호출할 때 사용한 인자의 변수의 타입이 Max에서 정의 한 문법에 틀리지 않는지 체크한 후 int 타입을 사용하는 Max 함수의 코드를 만듭니다.

int MaxCharHP = Max( Char1_HP, Char2_HP );

이후 다음 부분에서 Max를 만나면 이번에도 위의 int 때와 같이 문법 체크를 한 후 에러가 없다면 float를 사용하는 Max 함수 코드를 만듭니다.

float MaxCharExp = Max( Char1_Exp, Char2_Exp );

Max가 만들어지는 과정을 나타내면 아래와 같습니다. 모든 타입에 대해 Max 함수를 만드는 것은 아닙니다. 코드에서 사용한 타입에 대해서만 Max 함수가 만들어집니다. 

 

참고로 이렇게 만들어지는 코드는 소스 코드에 만들어지는 것이 아니고 프로그램의 코드 영역에 만들어집니다. 컴파일 타임에 함수 템플릿을 평가하고 관련 코드를 만들기 때문에 템플릿을 많이 사용하면 컴파일 시간이 길어질 수 있으며, 각 타입에 맞는 코드를 만들어내므로 실행 파일의 크기도 커질 수 있습니다.

Max 함수 템플릿에 개선점이 없을까요?

힌트를 드린다면 Max의 두 인자 값은 함수 내부에서 변경되지 않습니다. 그리고 인자의 타입은 C++의 기본형뿐만이 아닌 크기가 큰 타입을 사용할 수도 있습니다. 

생각나셨나요? C++ 기초 공부를 차근차근 쌓아 올린 분이라면 알아차렸으리라 생각합니다. 

정답은 Max 함수 템플릿을 만들 때 템플릿의 인자에 const와 참조를 사용하는 것입니다. Max 함수는 함수의 내부에서 함수의 인자를 변경하지 않습니다. 그러니 함수에 const를 사용하여 내부에서 변경하는 것을 명시적으로 막고 Max 함수를 사용하는 사람에게 알리는 역할을 합니다. 

C++에서 함수 인자의 전달을 빠르게 하는 방법은 참조로 전달하는 것입니다. 위의 Max 함수는 int나 float 같은 크기가 작은 타입을 사용하였기 때문에 참조로 전달하는 것이 큰 의미는 없지만, 만약 구조체나 클래스로 만들어진 크기가 큰 변수를 사용할 때는 참조로 전달하는 것이 훨씬 빠릅니다. 앞에 만든 Max 함수 템플릿을 const와 참조를 사용하는 것으로 바꾸어 보았습니다. 

< List 4 >

template 
const T& Max(const T& a, const T& b )
{
  return a > b ? a : b;
}

class T 라는 것을 본적이 있나요?

함수 템플릿을 만들 때 'typename'을 사용했습니다. 그러나 좀 오래된 C++ 책에서 템플릿에 대한 글을 본 적이 있는 분은 'class'를 사용한 것도 본 적이 있을 것입니다. 

< List 5 >

template 
const T& Max(const T& a, const T& b )
{
  return a > b ? a : b;
}

typename과 class는 기능적으로 다른 것이 아닙니다. 템플릿이 표준이 되기 전에는 'class'를 사용했습니다. 그래서 표준화 이전이나 조금 지난 뒤에 나온 책에서는 'class'로 표기했습니다. 그리고 예전에 만들어진 C++ 컴파일러도 템플릿 인자 선언으로 'class'만 지원했습니다. 만약, C++ 표준화 전후에 만들어진 컴파일러에서는 'class'를 사용해야 합니다. 

현재의 컴파일러에서는 'class', 'typename' 둘 다 지원합니다. 하지만, 'class'보다 프로그래머에게 '타입'을 추상화한 것이라는 의미 전달을 명확하게 하는 typename을 사용합니다. class만 지원하는 오래된 C++ 컴파일러에서 컴파일 해야 하는 것이 아니면 꼭 'typename'을 사용하세요.

이제 Max 함수 템플릿에는 문제가 없을까요?

위에서 Max 함수 템플릿에 대해서 const와 참조로 개선을 했는데 이제 문제가 없을까요? 

그럼 아래의 코드는 문제가 없이 컴파일이 잘 될까요? 

< List 6 >

// List3의 Max 함수 템플릿을 사용합니다.
void main()
{
  int Char1_MP = 300;
  double Char1_SP = 400.25;
  double MaxValue1 = Max( Char1_MP, Char1_SP );
  cout << "MP와 SP 중 가장 큰값은" << MaxValue1 << "입니다." << endl << endl;
  
  double MaxValue2 = Max( Char1_SP, Char1_MP );
  cout << "MP와 SP 중 가장 큰값은" << MaxValue2 << "입니다." << endl << endl;
}

List 6을 컴파일 하면 다음과 같은 에러가 출력됩니다.

max.cpp
max.cpp(16) : error C2782: 'const T &Max(const T &,const T &)' 
        : 템플릿 매개 변수 'T'이(가) 모호합니다.
        max.cpp(6) : 'Max' 선언을 참조하십시오.
        'double'일 수 있습니다.
        또는      'int'
max.cpp(19) : error C2782: 'const T &Max(const T &,const T &)' 
        : 템플릿 매개 변수 'T'이(가) 모호합니다.
        max.cpp(6) : 'Max' 선언을 참조하십시오.
        'int'일 수 있습니다.
        또는      'double'

이유는 컴파일러는 사람이 아니어서 서로 다른 타입의 인자가 들어오면 템플릿의 파라메터 T를 사용한 함수의 인자 a와 b의 타입을 int로 해야 할지, double로 해야 할지 판단할 수가 없기 때문입니다. 이 문제는 어떻게 해결 해야 될까요?

typename을 하나가 아닌 복수 개 사용하면 됩니다.

위의 문제는 Max 함수를 정의할 때 typename을 하나만 사용해서 타입을 하나만 선언했습니다. 이제 typename을 여러 개 사용하면 위의 문제를 풀 수 있습니다. 

< List 7 >

template 
const T1& Max(const T1& a, const T2& b )
{
  return a > b ? a : b;
}

List 7의 함수 템플릿을 사용하면 Max 함수의 인자 타입을 int와 double 혹은 double과 int 타입을 사용해도 컴파일이 잘 됩니다. 그럼 제대로 실행 되는지 실행을 해 볼까요? 

 

앗, 실행 결과에 오류가 있습니다.

int Char1_MP = 300;
double Char1_SP = 400.25;
double MaxValue1 = Max( Char1_MP, Char1_SP );

이 코드는 300과 400.25를 비교합니다. 결과는 400.25가 나와야 하는데 400이 나와버렸습니다. 

이유는 List 7의 함수 템플릿의 반환 값으로 T1을 선언했기 때문에 int 타입과 double 타입을 순서대로 함수 인자에 사용하면 반환 값의 타입이 int형으로 되어 버리기 때문입니다. 이렇게 서로 다른 타입을 사용하는 경우에는 반환 값을 아주 조심해야 합니다. 그리고 위의 예에서는 함수 템플릿의 파라메터로 typename을 2개 사용했지만 그 이상도 사용할 수 있습니다. 

위의 Max 함수 템플릿 만족스럽나요?
저는 왠지 아직도 좀 불 만족스럽습니다.

Max( int, double);

실수를 하면 찾기 힘든 버그가 발생할 확률이 높습니다.
이것을 어떻게 풀어야 될까요?

함수 템플릿의 전문화 라는 것이 있습니다.

Max(int, double)을 사용하면 Max 함수 템플릿이 아닌 이것에 맞는, 특별하게 만든 함수를 사용하도록 합니다. 함수 템플릿의 전문화(Specialization)라는 특별한 상황에 맞는 함수를 만들면 함수 오버로드와 같이 컴파일러가 상황에 맞는 함수를 선택하도록 합니다. 

< List 8 >

#include 
using namespace std;

// 템플릿으로만든값을비교하는Max 함수
template 
const T1& Max(const T1& a, const T2& b )
{
  cout << "Max(const T& a, const T& b) 템플릿 버전 사용" << endl;
  return a > b ? a : b;
}

// 전문화시킨Max 함수
template <> 
const double& Max(const double& a, const double& b)
{
  cout << "Max(const double& a, const double& b) 전문화 버전 사용" << endl;
  return a > b ? a : b;
}

void main()
{
  double Char1_MP = 300;
  double Char1_SP = 400.25;
  double MaxValue1 = Max( Char1_MP, Char1_SP );
  cout << "MP와 SP 중 가장 큰 값은" << MaxValue1 << "입니다." << endl << endl;
  
  int Char2_MP = 300;
  double Char2_SP = 400.25; 
  double MaxValue2 = Max( Char2_MP, Char2_SP );
  cout << "MP와 SP 중 가장 큰 값은" << MaxValue2 << "입니다." << endl << endl;
}

위 코드를 실행한 결과는 아래와 같습니다. 

 

컴파일러는 프로그래머의 생각을 완전히 이해하지는 않습니다. 그래서 컴파일러가 어떠한 것을 선택할지 이해하고 있어야 됩니다. List 8은 double에 전문화 된 Max 함수를 만든 예입니다. 

[질문] Max(10.1, 20.4)를 호출한다면 Max(T, T)가 호출 될까요? 아님 Max(double, double)가 호출 될까요? 

답을 빨리 알고 싶을 테니 뜸 들이지 않고 결과를 바로 보여드리겠습니다. 

 

전문화 버전이 호출 되었습니다. 이유는 호출 순서에 규칙이 있기 때문입니다(최선에서 최악으로). 호출 순서는 다음과 같습니다.

1. 전문화된 함수와 맞는지 검사한다.
2. 템플릿 함수와 맞는지 검사한다.
3. 일반 함수와 맞는지 검사한다.

위의 순서를 잘 기억하고 전문화 함수를 만들어야 합니다. 잘못하면 찾기 힘든 버그를 만들 수가 있습니다. 이제 함수 템플릿에 대한 이야기는 거의 다 끝난 것 같습니다. 

아... 하나 더 있습니다. 

이때까지 한 것들은 타입만을 템플릿 파라메터로 사용했는데 꼭 타입만 함수 템플릿에 사용할 수 있는 것은 아닙니다.

난-타입(non-type) 함수 템플릿

온라인 게임에서는 특정한 이벤트가 있을 때는 캐릭터의 HP, 경험치, 돈을 이벤트 기념으로 주는 경우가 있습니다. HP와 경험치, 돈의 타입은 다르지만 추가 되는 값은 int 상수로 정해져 있습니다. 위와 같이 타입은 다르지만 상수를 더 한 값을 얻는 함수를 만들려면 어떻게 해야 될까요? 

이런 문제도 함수 템플릿으로 해결할 수 있습니다. 

함수 템플릿의 파라메터로 꼭 typename만이 아닌 값을 파라메터로 사용할 수도 있습니다. 

아래의 코드는 캐릭터의 HP, 경험치, 돈을 이벤트에서 정해진 값만큼 더 해주는 것을 보여줍니다. 

< List 9 >

#include <iostream>
using namespace std;

// 지정된 값만큼 더해준다.
template <typename T, int VAL>
T AddValue( T const& CurValue)
{
  return CurValue + VAL;
}

const int EVENT_ADD_HP_VALUE  = 50;    // 이벤트에 의해 추가 될 HP 값
const int EVENT_ADD_EXP_VALUE  = 30;    // 이벤트에 의해 추가 될 경험치
const int EVENT_ADD_MONEY_VALUE  = 10000;    // 이벤트에 의해 추가 될 돈

void main()
{
  int Char_HP = 250;
  cout << Char_HP <<"에서 이벤트에 의해" << AddValue<int, 
       EVENT_ADD_HP_VALUE>(Char_HP) << " 로 변경" <<endl;

  float Char_EXP = 378.89f;
  cout << Char_EXP <<"에서 이벤트에 의해" << AddValue<float, 
       EVENT_ADD_EXP_VALUE>(Char_EXP) << " 로 변경" <<endl;

  __int64 Char_MONEY = 34567890;
  cout << Char_MONEY <<"에서 이벤트에 의해" << AddValue<__int64,   
       EVENT_ADD_MONEY_VALUE>(Char_MONEY) << " 로 변경" <<endl;
}

실행 결과는 다음과 같습니다. 

 

앞에서 사용했던 함수 템플릿 사용 방법과 좀 틀려서 생소할 수도 있겠네요. 

제가 위에 예로든 것은 난 타입 함수 템플릿을 사용해야 되는 당위성이 좀 떨어질 수도 있다고 생각합니다만 설명을 위해서 간단하게 예를 보여주기 위해서 라고 변명해 봅니다. ^^;; 

난 타입을 사용하는 템플릿은 다음 회에 이야기 할 클래스 템플릿에서도 또 다시 이야기 할 예정이니 잘 기억하고 있으시기를 바랍니다. 또 난 타입을 잘 사용하면 템플릿 메타 프로그래밍을 할 때 큰 도움이 됩니다. 템플릿 메타 프로그래밍에 대해서는 다음에 설명해 드리겠습니다.

출처 : http://www.hanb.co.kr/

STL이 무엇인지 알고 계십니까?

C++를 주 프로그래밍 언어로 사용하고 계신 분들은 알고 있으리라 생각합니다. STL은 C++ 언어의 '표준 템플릿 라이브러리 (Standard Template Library) '의 약자입니다. 

STL을 간단하게 말하자면 일반적으로 많이 사용될 수 있는 자료구조와 알고리즘 모음 라이브러리가 말할 수 있습니다. 

STL은 C++ 언어가 처음 만들어질 때부터 있었던 것이 아니고 1998년에 C++ 표준이 정해지기 전인 1993년 말 무렵에 Alex Stepanov가 C++ 언어의 창시자인 Bjarne Stroustrup에게 보여준 후 준비 기간을 걸쳐서 1994년에 표준 위원회에 초안이 통과됩니다. 

참고로 C++ 표준은 1989년에 시작되어 1998년 9월에 마무리되었습니다.

STL은 어떻게 만들었을까요?

답은 위에 STL의 실제 이름에 포함 되어 있습니다. 좀 더 힌트를 드린다면 세 개의 단어 중 중간에 있는 것입니다. 

네, 템플릿(Template)으로 만들어 진 것입니다. 

STL을 이해하려면 STL을 만들 수 있게 해준 C++의 템플릿에 대한 이해는 필수입니다. 또, 템플릿은 C++를 더욱 강력하게 사용하는 데 꼭 필요합니다.

C++ 언어를 공부한 사람은 템플릿에 대해 잘 알고 있을까요?

예전에 C++을 잠시 공부했던 분이나 근래에 공부하고 있는 분 중 아직 C++ 책을 한, 두 권 본 정도라면 템플릿이라는 단어가 생소할 수 있습니다. 

위에 언급했듯이 템플릿은 C++이 세상에 나오면서 같이 나온 것이 아니고 1994년 무렵에야 세상에 조금씩 소개되다가 1998년에 C++ 표준이 정립되고서야 C++ 언어의 한 부분으로서 인정되었습니다. 

1994년까지는 템플릿을 지원하는 C++ 컴파일러가 없었고, MS의 C++ 툴로 유명한 Visual C++도 버전 6에서는 템플릿을 완벽하게 지원하지 못했으면 Visual Studio .NET 2000 에서부터 제대로 지원을 하게 되었습니다(아직도 템플릿 기능을 100% 완벽하게 지원하지는 못합니다.). 2000년도 이전에 나온 C++ 입문서를 보면 템플릿에 대하여 빠뜨린 것이 꽤 많습니다. 

근래 나오는 입문서에서도 빠져 있기도 하며 또 보통 C++ 입문서에서는 가장 뒷부분에 나오다 보니 공부를 하다가 중간에 포기하는 분들은 클래스라는 것은 알아도 템플릿은 잘 모릅니다. 

개인적으로 C 언어를 생각하면 포인터가 떠오르고, C++ 언어를 생각하면 클래스와 템플릿이 떠올라집니다. 이유는 C 언어나 C++ 언어를 배울 때 정확하게 이해하기 가장 어려웠던 것이고 제가 배웠던 다른 언어들에 비해 크게 달랐던 것이기 때문입니다. 

포인터는 처음 배울 때 문법적인 사용 방법이 잘 이해가 안 돼서 어려웠지만, 클래스나 템플릿은 문법적인 사용 방법이 어려운 것이 아니고 이것들이 프로그램 설계와 관계된 것들이라 사상 부분을 이해하기 어려웠습니다.

객체 지향 프로그래밍(OOP) C++

C++ 언어를 소개할 때 가장 먼저 이야기하는 것이 객체지향이라는 것입니다. 현대 언어들은 거의 다 OOP 베이스의 언어이던가 지원을 하고 있습니다. 

C 언어와 C++ 언어는 이름이 비슷하듯이 비슷한 부분이 많습니다. C 언어로 프로그래밍할 때는 절차 지향적 프로그래밍을 하게 됩니다. C++도 절차 지향 프로그래밍을 할 수 있습니다. 그러나 제대로 된 C++ 프로그래밍을 하려면 객체 지향 프로그래밍을 해야 합니다. 보통 C 언어를 배운 후 바로 이어서 C++를 배울 때는 객체 지향 프로그래밍(Object-Oriented Programming)에 대한 이해가 부족합니다. 그래서 C 언어로 프로그래밍할 때와 같은 절차 지향 프로그래밍을 하여 이른바 'C++를 가장한 C 프로그래밍'을 한다는 소리를 듣기도 합니다. C++ 언어로 객체 지향 프로그래밍을 할 수 있는 것은 C 언어에는 없는 클래스가 있기 때문입니다. 

[질문] C++로 할 수 있는 프로그래밍 스타일은 절차적 프로그래밍, 객체 지향 프로그래밍만 있을까요?
[답] 아니오. Generic Programming 도 가능합니다.

Generic Programming 이라는 것을 들어 보셨나요?

제가 프로그래밍을 배울 때는 일반적으로 C++ 언어를 배우기 전에 C 언어를 공부했습니다. C 언어를 처음 공부했던 시기가 제 기억으로는 1994년쯤입니다. 그 당시의 다른 초보 프로그래머들처럼 포인터의 벽에 부딪혀 좌절하고, 도망(?)가서 3D Studio라는 그래픽 툴을 공부하다가 제가 할 것이 아니라는 생각에 포기하고, 1995년에 다시 C 언어를 공부하였고 이후 바로 C++ 언어를 공부했습니다. 

이때도 OOP라는 단어는 무척 자주 들었고 C++로 프로그래밍을 잘한다는 것은 OOP를 잘한다는 것과 같은 뜻이었습니다. 

대학을 다닐 때부터 제 용돈의 많은 부분은 프로그래밍 책을 사는 데 사용되었습니다. 그중에서 저는 C++ 언어 책을 꽤 많이 구매하여 보았습니다(다만, 제대로 이해한 책은 별로 없었습니다. -_-;;; ). 

책에서는 언제나 OOP 단어는 무수히 많이 보았지만, Generic Programming이라는 단어를 그 당시에 본 기억이 없습니다. 제가 Generic Programming이라는 단어를 알게 된 것은 2001년 무렵입니다. C++ 언어를 공부한 지 거의 6년이 되어서야 알게 되었습니다. 

아마 지금 공부하시는 분들도 Generic Programming이라는 단어는 좀 생소할 것입니다. 

Generic Programming은 한국에서는 보통 '일반적 프로그래밍'이라고 이야기 합니다. 저도 처음에는 그렇게 들었습니다. 

그러나 이것은 잘못된 표현이지 않을까 생각합니다. 영어 사전을 보면 Generic 이라는 것은 '총칭(總稱)적인' 이라는 뜻도 있는데 이것이 '일반적'이라는 단어보다 더 확실하며 제가 2004년에 일본에서 구입한 "C++ 설계와 진화(Bjarne Stroustrup 저)"라는 일본 번역서에도 Generic은 총칭으로 표기하고 있습니다. 

그럼 Generic Programming은 무엇일까요? 

네이버 사전에서 Generic 이라는 단어를 검색하면, 

3【문법】 총칭적인
the generic singular 총칭 단수 《보기:The cow is an animal.》 

라는 부분이 있습니다. 보기의 영문을 저의 짧은 영어 실력으로 번역을 하면 '암소는 동물이다' 입니다. 소는 분명히 고양이나 개와는 다른 동물이지만 '동물'이라는 것으로 총칭할 수 있습니다. 

대체 C++언어에서 무엇을 '총칭'화 할까요? 

제가 만드는 프로그램은 Windows 플랫폼에서 실행되는 '온라인 게임 서버' 프로그램입니다. 온라인 게임 서버를 만들 때는 어떤 기능이 있어야 되는가를 정한 후 클래스를 만듭니다. 클래스는 아시는 바와 같이 멤버 변수와 멤버 함수로 이루어져 있습니다. 그리고 멤버 함수도 그 내용은 저의 생각에 의해 변수들이 조작으로 되어 있습니다. 

'암소는 동물이다'라는 식으로 C++ 언어에서 총칭을 하는 것은 변수의 타입(type)을 총칭화 하는 것입니다.

• 템플릿을 이용하면 총칭화된 타입을 사용하는 클래스와 함수를 만들 수 있습니다.
• 템플릿을 사용하면 타입에 제약을 받지 않는 로직을 기술 할 수 있습니다.
• Generic Programming을 하기 위해서는 템플릿이 꼭 필요합니다.

STL이 무엇으로 만들어졌나요? 네 템플릿으로 만들어졌습니다. STL은 Generic Programming으로 만들어진 가장 대표적인 예입니다. 

긴 설명은 그만하고 코드를 볼까요? 

제 나름대로 템플릿을 이해하는 데 도움이 되었으면 해서 이런저런 이야기를 했는데 과연 도움이 되었는지 모르겠네요. 아마 설명만 듣고서는 템플릿에 대해 명확하게 이해를 하지 못하리라 생각합니다. 우리 프로그래머들은 정확하게 이해하려면 코드를 봐야겠죠? 템플릿은 크게 함수 템플릿과 클래스 템플릿으로 나눌 수 있습니다. 

다음 시간에는 함수 템플릿에 대해서 이야기하겠습니다.

출처 : http://www.hanb.co.kr/

int
util_add_comma_to_num(const char *str, char *buf, int buflen)
{
    int len;
    int shift;

    /* count given string */
    len = strlen(str);
    shift = -len;

    assert( buflen >= (len + len/3 +1));

    while (*str)
    {
        *buf++ = *str++;
        if (++shift && (shift % 3) == 0)
            *buf++= ',';
    }

    *buf = '\0';

    return 0;
}

출처 : http://kldp.org/node/38269

출처 : http://allwiz.egloos.com/viewer/2803607

루프 최적화란 루프의 반복 회수를 줄이는 것을 말할 것입니다. 왜냐하면, 루프와 같은 분기 명령(JMP)이 많이 발생하면 할 수록 시스템의 성능을 저하될 것이기 때문입니다. 제 경우 현재 개발중인 프로그램에서 검색, 삽입, 수정, 삭제 처리를 위해 루프가 많은 구조다 보니, 이 루프들을 어떻게 효율적으로 줄일 수 있을까? 고민하다가 Duff's Device를 발견하게되었습니다.

1. Duff's Device
Duff's Device는 1983년 루카스필름에서 일하던 Tom Duff가 애니메이션 재생시 생기는 병목현상을 해결하기 위해 만들었다고 합니다. 그 당시에도 많은 논란이 있었다고 합니다만, 이 코드를 처음 본 제 느낌은 '우앗!' 이었습니다. 그리고 가까운 시일 내에 좀 더 테스트를 해보겠지만, 적용된다면 일반 루프에 비해 훨씬 효율적일것이라 생각합니다.

1.1 일반적인 복사
아래의 함수는 nArrSrc int형 배열의 값을 nArrDest로 복사하는 함수입니다.

const int MAX_ARRAY_SIZE = 10;

void CopyArray(int* nArrSrc, int* nArrDest, int nCount)
{
    do
    {
        *nArrDest++ = *nArrSrc++;
    } while( --nCount > 0 );
}

...
int nArrSrc[MAX_ARRAY_SIZE];
int nArrDest[MAX_ARRAY_SIZE];
...
CopyArray(nArrSrc, nArrDest, MAX_ARRAY_SIZE);

위의 예는 정상적으로 작동합니다. 그런데 만약 nCount가 1000번 혹은 10000 번이라면 얘기는 조금 달라지게 될 것입니다. 즉, 앞서 말한바와 같이 루프는 성능을 저하시키는 한 요소이기 때문입니다

1.2 Duff's Device 적용
앞서 구현한 CopyArray 함수는 Duff's Device에 의해 다음과 같이 수정될 수 있습니다.

const int REPEAT_COUNT = 8;

void CopyArrayEx(int* nArrSrc, int* nArrDest, int nCount)
{
    switch( nCount % REPEAT_COUNT )
    {
    case 0 :
        do {
        *nArrDest++ = *nArrSrc++;
    case 7 :
        *nArrDest++ = *nArrSrc++;
    case 6 :
        *nArrDest++ = *nArrSrc++;
    case 5 :
        *nArrDest++ = *nArrSrc++;
    case 4 :
        *nArrDest++ = *nArrSrc++;
    case 3 :
        *nArrDest++ = *nArrSrc++;
    case 2 :
        *nArrDest++ = *nArrSrc++;
    case 1 :
        *nArrDest++ = *nArrSrc++;
        } while ( (nCount -= REPEAT_COUNT) > 0 );
    }
}

위의 코드를 보면, switch-case문을 마치 goto문 처럼 사용한 것을 보실 수 있는데, 이를 보고 개인적으로 놀랐습니다. 세상엔 참 머리 좋은 사람이 많구나 하고요. 또한 REPEAT_COUNT로 8을 사용하였는데, 이는 캐쉬 크기에 맞춘 작업으로 보입니다. 일반적으로 위와 같이 loop unrolling 기법을 사용할 때에는 루프를 무한정 늘리는 것이 아닌 캐쉬 크기에 맞춰 8 혹은 16배의 loop unrolling을 사용한다고 합니다.

※ 참고 자료
• http://www.lysator.liu.se/c/duffs-device.html
• http://en.wikipedia.org/wiki/Duff's_device 
• 여인춘, 프로그래밍 고수의 알고리즘 , 마이크로 소프트웨어 2006년 10월호, pp.298-pp.300, Loop unrolling
 

출처 :https://sites.google.com/site/changgugaebaljeongli/unity3d/geim-gineung

유도 미사일 구현 - iTween

게시자: Changgu Jeong, 2013. 4. 2. 오후 11:10