STL

80년대의 Dr. Bjarne Stroustrup에 의해 개발된 이후로 C++ 언어는 커다랗고, 복잡한, 통신, 재정, 비즈니스, 임베디드 시스템, 컴퓨터 설계등의 프로젝트를 개발하는 전문적인 프로그래머들에 의해 널리 사용되어 왔다.  C++ 라이브러리의 표준은 C++을 보다 쉽게 배우게 도와줄 뿐 아니라, 다양한 플랫폼에서도 사용할 수 있게끔 해준다.  표준은 이식성과 안정성에 모두 기인한다. 믿을 수 있는 애플리케이션을 보다 빠르게 만들고 비용과 노력을 덜 들이면서 유지할 수 있는 것이 바로 STL인 것이다. 이번 호에서는 STL 프로그래밍 문제들에 대해 논의하고자 한다.  여기서 소개되는 각각의 특징들은 언어로 해결할 수 있는 특정한 타입의 문제들을 다룬다.  조금의 시간만 투자해 STL을 이해한다면, 이 이상의 언어는 없으리라 본다.

 

들어가기에 앞서

이번 호에서는 지난 호에서 약속했던 STL에 대해서 살펴보기로 한다.   우선 이 글은 STL(표준 템플릿 라이브러리)중 Rogue Wave 구현 라이브러리를 채택하여 사용하겠다. 이 제품에 대해서는 안심하고 사용할 수 있다. 이 STL은 ANSI 와 ISO에서 1998년 3월에 인가된 마지막 표준 C++안에 근거를 두고 있기 때문이다.  이 글에서 사용되는 예제는 정품에 들어있는 C++Builder 프로그래머 가이드와 STL 유저 가이드, 그리고 참고서적인 C++Builder4 Unleashed에서 사용된 것을 요약 정리한 내용이다.  이 글을 쓰는 데 가장 큰 도움을 준 사람은 Bruce Eckel (www.BruceEckel.com)로서 볼랜드 컨퍼런스에서 항상 C++ STL 세션을 도맡아 강의하는 사람이다.  물론, 컴파일러로는 C++Builder5로 사용하겠다. 이 글의 난이도는 중급 이상으로 초보자가 보기에는 조금 이해하기 힘들 내용들이다.

C++의 기능을 가장 잘 대변하는 언어는 STL(Standard Template Language)이라고 한다.   이 중간적 표현 수단은 컴퓨터상에서 해결할 수 없는 아주 복잡하고 커다란 문제들을 쉽게 그리고 유연하게 해결하는 컨테이너와 알고리즘화된 클래스들의 집합이다. 현재까지 나온 언어중 C++만큼 알고리즘을 최적화시켜 구현한 언어는 없다고 한다.  이 알고리즘은 실시간 컴퓨팅과 최적의 성능을 보장해주는 특징이다.  우리가 알고리즘을 매우 중시하는 이유는 바로 여기에 있다.

다음은 STL의 우수한 특징들을 나열한 예이다.

1) iostream 기능
2) 로케일 기능(현지 국어 표현)
3) 템플릿화된 문자열(string) 클래스
4) 복소수를 표현하기 위한 템플릿 복합(complex) 클래스
5) 수 배열을 처리하기 위해 최적화된 valarray 클래스
6) 기본 타입의 특별한 처리를 가능하게 해주는 통일화된 프레임웍
7) 메모리 운영 요소
8) 국가 문자군에 대한 확장 지원
9) 예외 처리 기능

주의해야 할 특징들

표준 C++ 라이브러리의 STL 의 위치는 객체 지향형 중심은 아니다. 객체 지향형 프로그래밍에 심취해 있는 여러분이라고 한다면, 데이터의 은닉성이나 오브젝트의 기능성같은 것들이 결핍되어 있다는 것을 쉽게 인식하게 될 것이다. 이와는 달리, STL은 작업하려고 하는 알고리즘을 데이터 구조체와 분리시킨다.
이 기능은 아주 작은 프로그램 소스 코딩을 할 경우, 상당한 장점을 제공해준다. 그리고 C++ 포인터를 사용한 알고리즘의 유용성이나 배열, 전통적인 오브젝트를 다루는 데 있어서 굉장히 탁월하다. 실행 속도에 있어서도 빠를 뿐 아니라 코딩의 양도 적다. 따라서, 문제를 직접적으로 해결하거나 혹은 꼭 들어맞는 해결책을 찾고자 하는 경우에는 STL을 함께 병행하는 것이 좋은 프로그래밍이라고 말할 수 있다.

Standard C++ Library 을 직접 이용할 경우, 가장 큰 단점은 에러의 위험을 증대시키는 일이다. 예를 들면, 라이브러리 중 iterator 는 반드시 타입이 꼭 맞아야 하거나 허용되는 타입이어야만 한다. 다중 스레드에서의 iterator 는 공유 스레드가 되기전 반드시 래핑되어야만 한다. 템플릿  코드는 예상치 못하게 비대해질 수 있다. 라이브러리에 대한 경험과 자신이 가진 컴파일로 이러한 문제들을 해결할 수 있으리라 본다.

Tools.h++과의 관계

Rogue Wave 구현 Standard C++ Library은 Tools.h++을 사용할 수 있게끔 검증되어 있다. Rogue Wave 제품 Tools.h++ 버전 7.0 과 그 이후 버전은 객체 지향형 인터페이스와 함께 Standard C++ Library를 사용할 수 있게 되어 있다. 이것을 함께 사용할 경우, 양쪽 언어의 저 수준 포괄 프로그래밍과 객체 지향 프로그래밍이 모두 다 가능해진다.

Tools.h++ 는 STL에는 포함되어 있지 않은 시간, 날짜, 일반 수식 클래스, 확장 문자열, 오브젝트 지속성, 가상 스트링등을 포함하고 있다. Tools.h++ 프로페셔널 같은 경우 자바와의 호환성, 네트웍, 코바의 기능도 포함하고 있다.

템플릿 기본

템플릿에 처음 입문하는 사람이라면, 템플릿이란 것이 어떻게 동작되는 지 그리고 어떻게 사용하는 지 궁금할 것이다.  왜 클래스라는 개념 대신에 STL에서는 템플릿을 쓰는 것일까? 심지어는 마이크로소프트의 ATL(ActiveX Template Library)조차도 템플릿을 사용하고 있는 이유가 무엇일까?

템플릿(template)은 함수나 클래스들에 대한 무리(군)를 정의한다. 템플릿을 만들기위해서는, 키워드 template를 사용하여 함수나 클래스를 선언해야만 한다. 예를 들며, 다음의 것들은 모두 템플릿이다.

template <class T>
void example1(T t)
{
}

template <class T>
class example2
{
}

첫번째 예제는 함수, example1()의 군을 정의한 예이다. 군에 있는 각 함수는 몇몇 타입의 인자를 얻는다. 두번째 예제 example2는 템플릿 인자인 T를 취함으로써, 거의 무한한 클래스의 집합을 명시한다.

템플릿은 어떤 타입도 적용시킬 수 있는 포괄적(generic) 집합 코드를 제공한다. 컴파일러가 템플릿이 현재 사용되고 있다고 인식할 때, 특정한 인자화된 타입을 가진 코드의 인스턴스를 생성시킨다. 복사와 붙여넣기 연산을 자동으로 한다고 생각해보자. 다음의 코드는 컴파일러에게 두 가지 다른 함수를 생성시켜주는 코드이다. 각각의 이름은 example1()으로 되어 있다. 한 함수는 int를 받아들이고 다른 함수는 유저 정의의 myclass클래스를 받아들인다.

example1(30);
myclass b;
example1(b);

다음 예제는 세가지의 다른 클래스들을 생성하는 예이다. 클래스 템플릿은 example2 이다.

example2<int> aFooInt;
example2<Bar> aFooBar;
example2<Foo<Bar>> aFooFooBar;

지금은 템플릿이라는 것이 생소할 지 모른다. 괜찮다. 이 글을 통해 계속 진행해 가면서 나중에 천천히 알아보도록 하자. 지금으로서는 단지 템플릿은 각기 다른 타입의 변수를 가지고 작업할 수 있게끔 포괄적 코드를 정의해 줄 수 있다는 사실만 이해하면 된다.

함수 템플릿과 템플릿 함수

2개의 정수형 인자를 받아 그 중에서 최대값을 리턴해 주는 함수 Max(x, y)를 작성한다고 가정하자. 이 코드는 아마도 다음과 같을 것이다.

int Max(int x, int y)
{
if (y > x)
return y;
else
return x;
}

이 함수는 정수형에 대해 우리가 예상한 결과를 잘 출력해 줄 것이다.  그런데, 두 개의 인자가 정수가 아닌, double 형 중 최대의 값을 찾을 필요가 있다면 어떻게 될 것인가? 이 함수의 인자들은 정수형을 사용하기때문에 double형  값을 처리를 못한다. 이 때는 Max() 함수에 부동형 처리를 하게끔 만들어 주어야 한다.

부동형 소수에 대해 제대로 처리하도록 만들기 위해서는 Max() 함수를 그대로 복사해서 인자의 int를 double 로 바꾸어 주기만 하면 된다.

이제 두 가지 버전의 Max() 함수를 처리할 수 있게 되었다. 이런식으로 처리하게 되면 원하는 인자 타입의 함수들은 반복적으로 생성시킴으로서 코드의 크기가 증가된다는 단점이 있다. 그러면 인자로서 AnsiString, Currency 오브젝트, 복합수를 다룰 수 있는 Max()가 있다면 얼마나 좋을까? 템플릿을 사용한다면 이러한 문제는 바로 해결될 수 있다.

C++ 템플릿 메커니즘은 어떠한 타입도 받아들이는 포괄 Max() 함수를 만들어 줄 수 있다. 그 인자가 정수형, 부동 소수형, 사용자 정의형이든 상관없다. 다음의 예제는 템플릿 버전의 Max() 함수를 만드는 방법을 설명해 준다.

template <class T>
T Max(T x, T y)
{
if (y > x)
return y;
else
return x;
}

앞에서 살펴본 함수 템플릿과 이 예제 템플릿 함수를 비교해 보자. 첫번째 라인이 template <class T>로 시작된다는 것과 Max() 함수의 인자가 int 대신 T로 바뀌었다는 점을 제외하고는 나머지는 똑같다. 컴파일러는 T 타입을 컴파일 시 원하는  타입의 인자로 바꾸어 준다. 정수형으로 전달하면, T는 정수형으로 바뀌고 double 형으로 전달하면 double로 바뀐다.

참고:

1) 템플릿 인자는 반드시 T가 될 필요는 없다. K가 되어도 좋다. 다만 습관상 T를 쓰는 것이다. 

2) 함수 템플릿(포괄 함수)는 템플릿 함수와 다르다.  템플릿 함수는 함수 템플릿 중에서 특별히 인스턴화된 함수를 의미한다.

우리의 목적은 인자의 다중 타입을 가지고 동작할 수 있는 Max() 함수를 만드는 일이었다. 템플릿 함수 Max()는 AnsiString, Currency 오브젝트 타입같은 것들에서는 잘 동작하나, 서수형 타입말고 오브젝트로 사용될 경우 임시 오브젝트를 생성/해제 하는 일을 막기 위해 참조(&)로 오브젝트를 전달하고 받는 것이 현명한 일이다. 다음의 코드는 이러한 임시 오브젝트 생성을 막아주는 보다 향상된 Max() 템플릿이다.

template <class T>
const T& Max(const T& x, const T& y)
{
if (y > x)
return y;
else
return x;
}

이제 이 템플릿 함수를 가지고 예제를 만들어 보자. 다음의 코드는 C++Builder5의 콘솔 마법사를 가지고 만든 프로그램이다.

// demo1 --------------------------------------------
#include <condefs.h>
#include <iostream>
#pragma hdrstop

using std::cout;
using std::endl;

template <class T>
const T& Max(const T& arg1, const T& arg2)
{
if (arg2> arg1)
return arg2;
else
return arg1;
}

#pragma argsused
int main(int argc, char* argv[])
{
cout << Max(15, 5) << endl;
cout << Max('a', 'b') << endl;
cout << Max<int>(15, 'b') << endl;
cout << Max("한국","북한") <<endl;
return 0;
}

여기서 세번째 함수에서 정수형과 문자형의 비교가 있는 데 Max<int>를 해 준 것은 강제적으로 모든 인자에 대해 정수형으로 바꿔주는 의미를 내포하고 있다.

출력 결과값)

15

b

98

북한

매크로와 템플릿

여기쯤 오면 생각할 수 있는 것이 "왜 Max() 매크로를 쓰면 안되지?"일 것이다. 다음과 같이 Max()에 대해 매크로 함수를 정의한다고 하자.

#define Max(a, b) ((a) > (b))? (a) : (b)

하지만, 매크로는 예상가능한 코드나 유지보수가능한 코드를 생산해내지 못한다. 매크로의 최대 단점은 실제 함수처럼 행동하지 않는다는 점이다. 다음의 코드를 보자.

#define Max(a, b) ((a) > (b))? (a) : (b)

int main()
{
  int i =0;
  int j= 0;
  cout << Max(i, ++j) << endl;
  cout << i << endl;
  cout << j <<endl;
  return 0;
}

이 코드에서 J는 매크로에서 두 번 증가되었다. 이 매크로를 실행시키면, j는 1의 값이 아니라 2의 값을 가진다. 매크로는 다음과 같은 여러가지 문제점들이 있다.

-매크로를 처리하기 위해서는 특별한 전처리기 문법이 필요하다. 이것은 에러가 많고 별로 좋지 않다.

-매크로는 예상치 못한 결과를 일으킬 뿐 아니라, 다른 부작용도 초래한다.

-매크로는 디버깅도 어렵다.

그래서, 템플릿을 사용하는 것이 바람직하다. 템플릿은 예상된 결과를 출력해주며, 강력한 타입 안전성 위주로 동작한다. 매크로보다 디버깅도 쉽다.

팁 : 매크로를 사용하는 이유는 프로그램의 수행속도를 더 빠르게 하는 것이긴 하지만, 템플릿에서도 inline을 써서 매크로처럼 수행속도를 빠르게 할 수도 있다.

template <class T>
inline T Max(T x, T y)
{
if (y > x)
return y;
else
return x;
}

클래스 템플릿

C++ 템플릿 메카니즘은 함수 템플릿뿐만 아니라 클래스 템플릿도 지원한다. 사실, 클래스 템플릿은 오브젝트 지향의 이점과 템플릿의 포괄성을 모두 합해줄 수 있는 것이기 때문에 훨씬 강력하다.

클래스 템플릿을 이용하면 많은 문제들을 해결할 수 있다. 스택, 큐, 리스트들을 오브젝트를 명시하지 않고 컨테이너 클래스로 만들 수 있다. 또한 스마트 포인터와 자동 포인터로 포인터의 생성, 운영, 삭제과정을 단순화시킬 수 있다. 그러면 예제를 하나 살펴보자.

// Demo2 ----------------------------------------

#include <condefs.h>

#include <iostream>

#pragma hdrstop

 

using std::cout;

using std::endl;

 

template <class T>

class Container

{

 private:

    T m_t;

 public:

 Container(const T& t):m_t(t){}

 void dosomething(){cout <<"뭔가 처리하고..."<<m_t<<endl;}

};

 

#pragma argsused

int main(int argc, char* argv[])

{

 Container<int> c1(15);

 Container<char *> c2("안녕 친구");

 c1.dosomething();

 c2.dosomething();

 return 0;

}

 

출력 결과값)

뭔가 처리하고…15

뭔가 처리하고…안녕 친구

컨테이너 클래스는 아주 간단한 템플릿 클래스이다. m_t라는 하나의 멤버 변수를 저장하고 이 타입은 이 템플릿이 인스턴화되기 전까지는 알 수 없다. main()함수는 두 개의 Conatiner 클래스를 사용하고 있다. 정수와 문자열, 즉 m_t는 상황에 맞게 정수형이 되기도 하고 문자열이 되기도 한다.

코드 내부를 살펴 보면 클래스 선언부안에 Container 클래스의 멤버 함수를 직접 정의하였다.  이것이 의미하는 바는 멤버 함수는 인라인 함수가 될 수 있다는 것을 의미한다. 물론, 밖에서 이 함수를 정의할 수도 있다. 다음의 예는 이것을 보여준다.

 

template <class T>
class Container
{
private:
T m_t;
public:
Container(const T& t);
void dosomething();
};

template <class T>
Container<T>::Container(const T& t):m_t(t)
{
}

template <class T>
void Container<T>::dosomething()
{
cout <<"뭔가 처리하고…"<<m_t<<endl;
}

클래스 선언부는 변하지 않았지만, 생성자와 함수 dosomething 내부는 옮겨지거나 약간씩 다르게 표현되었다. 템플릿 멤버 함수의 문법은 템플릿 함수와 거의 다른 게 없다. 여기서 Container<T>와 같이 인자를 반드시 써주어야 하는데 이 이유는 어떤 템플릿 클래스 함수가 멤버에 속하는 지 알려주기 위함이다.

STL 기본 개념

STL에서는 컨테이너와 컬렉션이라는 것을 빈번하게 사용한다.  두 개나 똑 같은 의미로, 순서적으로 된 오브젝트나 관계가 형성된 오브젝트를 놓는 장소를 의미한다.  심지어는 그 자체 오브젝트를 컨테이너 안에 놓을 수도 있다. 컨테이너 클래스들은 특별한 종류의 코드 재사용의 문제를 해결해 주는 수단이다.  컨테이너 클래스들은 굉장히 중요하기 때문에 OOP에서는 가장 근본이 되는 기본이 된다.  구현은new 라는 연산자를 사용해 포인터를 얻어 컨테이너안에 넣는 개념이다

다행히도, C++에서는 STL이라는 포괄 라이브러리를 제공해 여러가지 다양한 요구에 대해 충족시킬 수 있는 컨테이너들을 제공한다.  모든 요소에 대해 동일한 접근을 제공해 주기 위한 벡터(vector)라든지, 모든 아이템에 대해 동일한 삽입기능을 제공하는 연결 리스트라든지, 이 밖에도 집합, 큐, 해쉬 테이블, 트리, 스택 등을 제공한다.

간략하게 이 중 몇가지만 개념을 살펴보자.

1) vector 는 선형 시퀀스(순서적으로 처리되는)로서 내부의 아이템들을 난수적으로 빠르게 접근할 수 있으나 이 시퀀스 중간에 아이템들을 삽입하거나 추가 저장소를 할당할 때는 매우 느리다.

2) deque 도 선형 시퀀스이다.  이것은 벡터만큼 빠르게 난수 접근을 할 수 있지만, 새로운 저장소를 할당할 때는 무지하게 빠르다. 그리고, 양쪽 끝부분에서 아이템을 쉽게 추가할 수 있다.(벡터는 꼬리부분에서만 아이템을 추가할 수 있다.)

3) list 는 선형 시퀀스의 세번째 타입이다.  중간에서 아이템을 난수적으로 옮길때는 느리나 아이템을 삽입할 때는 매우 빠르다. list, deque, vector 은 모두 선형 시퀀스이지만 그들의 행위는 조금씩 다르다.  그래서 프로그램에서는 적절한 것으로 선택해 사용하는 것이 좋다.

 

Iterator

모든 컨테이너는 아이템을 넣거나 빼는 방법이 있다.  시퀀스로 된 컨테이너에서는 어떤 아이템을 삽입할 경우에는 끝에다 Push_Back()을 사용하고(deque 와 list 는 물론, 앞에서 삽입할 수 있는 push_front도 있다.), 관계로 된 STL에서 아이템을 추가할 경우에는 Insert() 를 사용한다. 그런데, 이러한 아이템을 가져오려면 어떻게 해야하는가?  vector 나 deque에서는 인덱스 operator[ ],를 사용하면 되지만 list.에서는 이것을 사용할 수 없다. 대부분의 경우는 컨테이너 내부에 그룹화된 아이템을 서로 비교하면서 조작한다.

이때 사용하는 유일한 해결책이 바로 Iterator를 사용하는 것이다. Iterator를 생성하기 위해 모든 컨테이너는 begin()으로 시작하고 end()로 끝난다.  다음은 Iterator를 사용하여 0부터 9까지 출력하는 예이다.

//Demo3  -------------------------------------

#include <condefs.h>

#include <set.h>

#include <iostream>

#pragma hdrstop

 

using std::cout;

#pragma argsused

int main(int argc, char* argv[])

{

  set<int> intset;

  for (int i=0;i <25; i++)

   for (int j=0;j < 10; j++)

       intset.insert(j);

  copy(intset.begin(), intset.end(),

       ostream_iterator<int>(cout, "\n"));

  return 0;

}

 

 

출력 결과값)

0

1

2

3

4

5

6

7

8

9

 

 

Vector

비록 STL 컨테이너가 값에 의해 오브젝트를 유지할지라도(컨테이너들은 그들 내부에 오브젝트 전체를 포함하고 있기때문에)  OOP방법으로 처리하려면 앞에서 처리한 방식이 결코 일반적인 방법이 아닐 것이다.  OOP에서처럼 처리하려면 대부분의 시간을 new 연산자를 사용해 힙상에 오브젝트를 만들어야 한다.  그리고 나서 베이스 클래스 타입에 upcast 해야만 한다.  나중에는 베이트 클래스에 대한 포인터로 이 오브젝트를 조작해야 한다.  이것이 좋은 이유는 다루는 오브젝트의 타입에 대해서 걱정할 필요가 없다는 점이다.  코드에 복잡성을 감소시켜주고 프로그램의 유지 보수성은 증대시켜준다.  upcasting 은 OOP에서는 다형성에 해당되기 때문에 컨테이너의 포인터들을 사용해서 이 일을 실현시킬 수 있다.

클래식  “shape” 예제를 하나 만들어 보자.

그림 1. Shape 예제 구성도

이 예제는 일련의 공통된 연산자를 가지고 있다.  그리고 타입 모양은 각각 다르다.  여기에서는 STL vector 를 사용하여 힙(Heap)에 생성된 다양한 형태의Shape 를 구현하다.

//Demo4 -------------------------------------------
#include <vector>
#include <iostream>
using namespace std;
 
class Shape {
public:
  virtual void draw() = 0;
  virtual ~Shape() {};
};
 
class Circle : public Shape {
public:
  void draw() { cout << "Circle::draw\n"; }
  ~Circle() { cout << "~Circle\n"; }
};
 
class Triangle : public Shape {
public:
  void draw() { cout << "Triangle::draw\n"; }
  ~Triangle() { cout << "~Triangle\n"; }
};
 
class Square : public Shape {
public:
  void draw() { cout << "Square::draw\n"; }
  ~Square() { cout << "~Square\n"; }
};
 
typedef std::vector<Shape*> Container;
typedef Container::iterator Iter;
 
int main(int argc, char* argv[])
{
  Container shapes;
  shapes.push_back(new Circle);
  shapes.push_back(new Square);
  shapes.push_back(new Triangle);
  for(Iter i = shapes.begin();
      i != shapes.end(); i++)
    (*i)->draw();
  // 
  for(Iter j = shapes.begin();
      j != shapes.end(); j++)
    delete *j;
 return 0;
}

 

Shape, Circle, Square, Triangle 의 생성은 비슷해야만 한다.   Shape 는 순수 추상형 베이스 클래스이다.(왜냐하면 pure specifier =0이기 때문이다.)  이것은 모든 타입의 shapes에 대한 인터페이스를 정의하고 있다.  상속받은 클래스들은 올바른 연산을 수행하기 위해서 가상(virtual ) 함수 draw( ) 를 재선언하고 있다.  이제는 각기 다른 모양의 Shape 오브젝트를 만들어야만 한다. STL 컨테이너에서는 물론, 편리상 이것을  typedef로 구현한다.

typedef std::vector<Shape*> Container;

벡터 Shape*에 대한 알리아스를 생성한다. 

typedef Container::iterator Iter;

그리고, typedef 는 vector<Shape*>::iterator 와 같은 것을 만들기위해 알리아스를 사용하다. 올바른 iterator를 만들기 위해 container 타입 명이 사용되어야 한다.  비록 각기 다른 타입의 iterator(forward, bidirectional, reverse 등)를 생산할 지라도 중첩된 클래스로 정의되어 있다.  이것들은 모두 똑같이 기본적인 인터베이스를 가지고 있다.  증가시키기 위해서는 ++를 사용하고,  현재 선택된 오브젝트를  만들기 위해  역참조(Dereference)할 수 있다.  또한, 시퀀스 끝부분에 있는 지 알아보기 위해서 검사해볼 수 있다.   이러한 일이 대부분의 작업중 약 90% 를 차지한다.   위의 예제에서 하는 작업이 바로 이런 일련의 일들을 수행한다.  컨테이너를 만들고, 각기 다른 Shape*로 이 컨테이너를 채운다.  Circle, Square, Rectangle 포인터로 발생한 upcast가 shapes 컨테이너에 추가된 것을 주목하자.  각각의 특별한 타입에 대해서는 모르지만 대신에 오직 Shape*만은 포함하기 때문에 포인터가 컨테이너에 추가되자마자 그 특정한 타입은 잃어버리게 되고 무명의 Shape*가 된다.  이것이 바로 우리가 원하는 결과다.  모든 것을 집어넣고 다형성의 특징으로 정렬하는 방법이다.

첫번째 for 루프 구문은 한 개의 iterator를 생성해 컨테이너에 대한 begin() 멤버 함수를 호출해 시퀀스의 앞부분에 놓는다.  모든 컨테이너는iterator 선택을 하기 위해 begin( ) 과  end( ) 멤버 함수가 있다.  제대로 했는 지 확인해보기 위해, end() 에 의해 만들어진 iterator에서 !=(같지 않다.) 인지 확인한다.  절대로  < 나 <= 를 사용해서는 안되고 오직  !=만을 사용한다.  다음과 같은 방식으로 루프를 돌리는 것이 가장 일반적인 방식이다.

for(Iter i = shapes.begin(); i != shapes.end(); i++)

이것이 의미하는 바는 “나를 이 시퀀스안에서  모든 아이템을 통해 돌려라!” 라는 뜻과 같다.

선택된 아이템 요소를 만들기 위해 iterator 로 어떻게 해야 할까?  *를 사용해 역참조(dereference)할 수 있다.  *은 실제로는 오버로드 연산자이다.  컨테이너가 가지고 있는 것이 무엇인지 역으로 알아내는 방법이다. 컨테이너는 Shape*를  가지고 있기 때문에  *i 와 같이 표현해야만 한다.  만약 Shape에 메시지를 보내려고 한다면,  ->으로 원하는 메소드를 가르킨다.

(*i)->draw();

이 코드가 하는 역할은 iterator가 선택한 Shape* 함수를 호출한다.  괄호를 해 주는 일이 좀 낯설게 보일는지 모르지만 이래야만 제대로된 순서의 평가를 출력하게 된다. 

파괴될 때 또는 포인터가 제거될 때, STL 컨테이너들은 그들이 포함한 포인터에 대해  delete 를 호출하지 못한다.  new를 사용해 힙상에 오브젝트를 생성하고 컨테이너에 그 포인터를 위치시키면 컨테이너는 그 포인터가 또 다른 컨테이너 내부에 있는 지 알지 못한다.  그래서 STL은 결코 이것에 대해서는 아무일도 처리 못하기때문에 모든 책임을 스스로 알아서 코딩으로 해결해야만 한다. 프로그램의 마지막 부분은  컨테이너 내부의 모든 오브젝트를 제거하기 위해 delete를 사용하였다.

출력 결과값>

Circle::draw

Square::draw

Triangle::draw

~Circle

~Square

~Triangle

 

이 프로그램이 단지 2개의 라인만을 사용하여 컨테이너의 타입들을 바꿀 수 있다는 사실이 매우 흥미로울 것이다.   이 글에서는 <list>,에 대해서는 예제를 풀어보지는 못했지만,  List라고 해서 vector라고해서 다른 것은 하나도 없다.  단지   첫번째typedef 에 다음과 같이 vector대신 list라고 바꿔주기만 하면 된다.

typedef std::list<Shape*> Container;

나머지는 똑같이 작성하면 된다.   List도 vector와 마찬가지로 시퀀스이기 때문에 거의 모든 함수를 동일하게 사용한다.  

IO 스트림 iterator

이미 앞부분에서 출력 스트림에 대한 컨테이너의 내용을 보여주기 위해   ostream_iterator (출력 iterator) 을 copy( ) 함수를 사용해 살펴 보았었다. 이와 대응하는  istream_iterator (입력 iterator)가 존재한다.  이 스트림 iterator는 입력 스트림으로부터 특정한 타입의 오브젝트를 받아들일 수 있게 해 준다. ostream_iterator 와 istream_iterator 의 차이점은 출력 스트림의 경우 “끝부분”이라는 개념을 가지고 있지 않기 때문에 얼마든지 계속해서 아이템들을 쓸 수 있다.  그러나 입력 스트림의 경우는 파일의 끝부분이 존재하는 관계로 파일의 끝에 도달하면 일반적으로 종료되는 형태를 지닌다. istream_iterator 은 2개의 생성자가 있다.  하나는  istream 를 사용해 읽고자 하는 iterator 를 만든다.  그리고 다른 하나는 기본 생성자로 되어 있고 이것은 감시자 역할로서 오브젝트를 생성시켜준다.  다음 프로그램에서는 이러한 오브젝트의 이름을 end로 주었다.

// Demo5
#include "require.h"
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
using namespace std;
 
int main(int argc, char* argv[])
  ifstream in("test.txt");
  assure(in, "test.txt");
  istream_iterator<string> init(in), end;
  ostream_iterator<string> out(cout, "\n");
  vector<string> vs;
  copy(init, end, back_inserter(vs));
  copy(vs.begin(), vs.end(), out);
  *out++ = vs[0];
*out++ = "That's all, folks!";
return 0;

} ///:~

in 이 입력 끝에 다라렀을 때(파일의 끝부분까지 갔을 때) init 은 end 와 동일하게 되고 copy( ) 가 마지막으로 호출된다.

STL 알고리즘

알고리즘은 우리가 생각하는 함수처리적인 기능의 사고방식을 탈피해 컴퓨터의 수학적인 논리방식으로 접근해야 한다.  구현된 알고리즘은 일반 서적이나 참고서에 자세하게 나와 있으므로 이 글에서 구체적으로 설명하지는 않겠다.   하지만, STL에는 이미 상당수의 최적의 알고리즘 방식으로 구현된 것이 많이 있기 때문에 프로그래머로서는 이러한 알고리즘을 적절하게 잘 이용하면, 상상하지 못할만큼의 뛰어난 성능을 가진 애플리케이션을 만들 수 있다는 점을 강조하고 싶다.

이 글에서 소개하는 예제는 난수 발생시키는 간단한 STL 알고리즘 예제이다.

//Demo6 -------------------------------------

#include <algorithm>

#include <vector>

#include <iostream>

#include <functional>

#include <cstdlib>

#include <ctime>

using namespace std;

 

#pragma argsused

int main(int argc, char* argv[])

{

  const int sz = 10000;

  int v[sz];

  srand(time(0)); // 난수 생성자 Seed

  for(int i = 0; i < 300; i++) {

    // 함수에 벗겨진 포인터 사용하기

    generate(v, v + sz, std::rand);

    int count = count_if(v, v + sz,

      bind2nd(greater<int>(), RAND_MAX/2));

    cout << (((double)count)/((double)sz)) * 100

      << ' ';

   return 0;   }

}

 

 

결론

지금까지 초보자가 접하기에는 좀 어려운 주제인 STL에 대해 살펴보았다.  STL 그 자체는 너무다 방대한 내용이다.  구현된 라이브러리가 상용버전일 경우는 C++Builder5에서 제공되는 것보다 몇 배나 많으며 실무 프로젝트에 유용한 것들이 꽤 많다.  그래서, 이러한 내용을  이 짧은 글에서 다루기는 불가능하다. 그러나, 이 글에서 기본적으로 STL이 뭔가?라는 개념정도를 파악했다면, 나중에 본격적으로 STL 프로그래밍을 하는 데에는 그다지 어렵지 않으리라 본다. 

 

이번 호로서 C++Builder5에 대한 연재를 마치고자 한다.  지금까지 관심을 가져준 독자들에게 진심으로 감사를 드린다.

예제 다운로드

참고문헌

C++Builder4 Unleahsed, SAMS, Kent Reisdorph, Charlie Calvert.

The C++ Programming Language, 3rd edition, by Bjarne Stroustrup (Addison-Wesley 1997).

C++ Primer, 3rd Edition, by Stanley Lippman and Josee Lajoie (Addison-Wesley 1998).

C & C++ Code Capsules, by Chuck Allison (Prentice-Hall, 1998).

C++ Gems, Stan Lippman, editor. SIGS publications.

The Design & Evolution of C++, by Bjarne Stroustrup