C++ Programming HOW-TO정지용이 문서는 C++에 관한 URL과 C++ online 책에 대한 링크, C++ 프로그래밍 팁 등을 포괄적으로 제공한다. 이 문서는 C++에서 겪는 다양한 메모리 관련 문제를 해결해주는 Java와 비슷한 library도 제공한다. 이 library를 이용하면, java 소스코드를 C++로 컴파일 할 수도 있다. 이 문서는 "C++ 언어의 집"역할을 한다.
이 문서에서 제공되는 정보는 C++ 언어를 적절히 사용하고 모든 운영체제 - 리눅스, MS-DOS, BeOS, Apple Macintosh OS, Microsoft Windows 95/98/NT/2000, OS/2, IBM OSes (MVS, AS/400 등..), VAX VMS, Novell Netware, 유닉스-like OS들(Solaris, HPUX, AIX, SCO, Sinix, BSD 등..)과 기타 C++을 지원하는 모든 운영체제(아마도 세상의 거의 모든 운영체제가 이에 속할 것이다) - 에 적용하는 것을 도와줄 것이다. | 고친 과정 |
|---|
| 고침 41.8 | 2002-03-31 | 고친이 정지용 | | 수정판 번역 | | 고침 5.0 | 2000-06-15 | 고친이 김지희, 윤주철 | | 최초 번역 |
(이 문서의 최신판은 http://milkyway.bounceme.net/HOWTO/cpphowto/C++Programming-HOWTO.html 에서 구할 수 있다) 이 문서의 목적은 C++에 관한 URL과 C++ online 책에 대한 링크, C++ 프로그래밍 팁 등을 포괄적으로 제공하는 것이다. 또한, 이 문서는 Java 스타일의 String class, string tokenizer, 메모리 함수등 일반적인 C++ 프로그램에서 널리 쓰일 수 있는 많은 함수들을 제공한다.
C++ 과 Java는 오늘날 많은 소프트웨어 프로젝트에서 쓰이고 있다. 프로그래머는 C++과 Java를 번갈아가며 쓰게될 것이고, 이 Java 스타일의 class가 매우 유용함을 알게 될 것이다.
이 library와 C++ 표준 라이브러리의 사용법을 알려줄 다양한 예제가 제시될 것이다. 이 문서는 C++에 대한 교과서가 아니며, 이에 대해서는 이미 몇가지 좋은 on-line 책들이 있다.
C++이 꽤 오랜시간동안 사용되어왔기 때문에, 매우 많은 수의 C++ 문서/글/튜토리얼이 인터넷상에 존재한다.
만약 당신이 C++을 처음 접하는 것이고, C++ 프로그램을 짜 본 적이 없다면, 13절장에 링크되어 있는 on-line C++ 책을 먼저 읽어보거나, Amazon 이나 barnes과 같은 곳에서 C++ 책을 사 볼 것을 추천한다. 누군가가 말했듯 - C/C++ 언어는 OS나 디바이스드라이버, 빠른 응답을 필요하는 real-time 프로그램등을 만드는 시스템 엔지니어나 쓰라고 하고,
당신은 2002년보다 컴퓨터가 몇백만배 빨라질 2005년을 생각하면 Java나 PHP-scripting을 써야한다.
하드웨어 는 점점 싸면서도, 빨라진다.
C++은 가장 강력한 언어들 중 하나이고, Java나 PHP-scripting 같은 것이 나타났지만, 앞으로도 오랜 시간동안 쓰이게 될 것이다.
실시간의 매우 빠른 응답을 필요하는 프로그램에는 C나 C++이 사용된다.
C++은 매우 빠르게동작하고,
실제로 Java보다 10배에서 20배 정도 빠르다 .
Java는 C++에서 "파생된" 언어이다.
Java의 단 하나의 문제점은 바로 - "Java 는 느리다!!"는 것이다.
VM위에서 도는 Java 바이트코드는 컴파일된 실행코드보다 느리고,
JIT(Just-In-Time) 컴파일러 위에서 더 빠르게 돌기는 하지만, 여전히 C++보다는 느리다.
최적화 된 C/C++ 프로그램은 JIT 나 그 이전의 컴파일러로 컴파일 된 Java 코드보다
약 3 에서 4배 정도 빠르다!!
그렇다면, 왜 사람들이 Java를 쓰는가? 이는 Java가 순수한 객체지향을 지원하고, Java의 자동화된 메모리 관리로 인해 프로그래밍하기가 쉬우며,
프로그래머들이 직접 메모리 관리하기를 싫어하기 때문이다.
이 문서는 C++의 메모리 관리를 자동화하여 훨씬 사용하기 쉽게 하고자 했다.
여기서 나오는 library는 C++을 Java 만큼 쉽게 느끼게 해줄 것이고, C++이 Java와 경쟁할 수 있도록 해줄 것이다. 수동적인 메모리 관리를 위해 C++ 프로그램 디버깅의 대부분 시간이 소모된다.
이 문서는 디버깅 시간을 줄이기 위한 몇가지 아이디어와 팁을 줄 것이다. 언제 C++을 써야하고 언제 Java/PHP를 써야하는가? 아래와 같은 경우엔 C++을 써라:
실행속도와 성능이 매우 중요한 프로그램을 만들 때. 만드는 프로그램의 사용자 수가 많을 때. C++은 컴파일-링킹-디버깅 사이클이 필요하기 때문에, 프로그램 개발에 더 많은 시간이 소요된다.
따라서 사용자수가 충분히 많을 때에나 적당하다. 실행파일을 만들기 위해 많은 수의 object파일을 링크하는 것은 꽤 시간이 걸린다.
(링크하는데 걸리는 시간을 줄이기 위해 archive나 라이브러리, 공유 라이브러리를 사용할 수도 있다.) C++프로그래밍 경험이 많을 때.
Java/PHP를 써야할 경우:
(C/C++로 작성되는 것에 비해서) 실행속도와 성능이 중요하지 않을 때. 생산 비용을 낮추기 위해 - 컴파일-링크 사이클이 없기 때문에, Java/PHP는 C++보다 개발이 빠르다. 빠른 개발이 필요할 때. 코드 유지보수를 쉽게 하기 위해. C++ 을 유지보수하는 것이 Java나 PHP-scripting 보다 훨씬 어렵다. Java와 PHP-scripting은 미래이다, 하드웨어의 속도는 분자와 원자, 원자보다 작은 크기의 컴퓨터 도입과 함께 급등할 것이다.
미래의 컴퓨터는 오늘날 컴퓨터의 수조배의 성능을 가질 것이다. 미래에 하드웨어 성능이 진보함과 함께, Java나 PHP-script의 느린 실행 속도는 중요치 않게 될 것이다.
오늘날 당신이 쓰는 컴퓨터(현재는 2002년이다.)는 엄청나게 느리고, 기어가고 있으며, 충분히 빠르지 못하다.
NOTE: Java 컴파일러 (JIT 나 다른 것들)에 많은 진보가 있었다. Java 프로그램은 GNU GCJ http://gcc.gnu.org/java로 컴파일 될 수 있다.
GCJ는 간편하고, 최적화되어있으며, 진보적인 Java 프로그래밍 언어를 위한 컴파일러이다.
GCJ는 Java source 코드를 머신 코드로 바로 컴파일 할 수도 있고, Java 바이트코드(class file)로 컴파일 할 수도 있다. GCJ 정보:
언어의 선택은 어려운 일이다. 여기엔 너무나 많은 고려할 사항이 있다 - 개발자,
사람의 능력, 비용, 툴들, 정책 (국가의 정치 정책까지도), 사업가나 회사들에 대한
영향까지.
기술적인 이유로는 최적의 언어일지라도 단순히 정치적인 결정으로 인해 선택되지
못할 수도 있다. David Wheeler의 언어 비교를 보자.
Ada 비교 차트.
Ada가 93%, Java는 72%, C++은 68% C는 53%을 각각 받았다.
C++과 Java는 점수면에서는 비슷하다 (4% 차이).
Ada의 개발 비용은
Stephen F. Zeigler에 따르면 C++의 반절이다.
Ada95는 아래에서 구할 수 있다 -
C++ 컴파일러는 C 컴파일러보다 훨씬 복잡하고, C++은 C보다 약간 느리게 동작할
수 있다.
C 컴파일러는 충분히 오랬동안 잘 쓰여져왔다. 몇몇 시스템에서, 당신은 생성된 코드를 최적화 하기 위해 몇가지 옵션을 쓸 수
있다. 오늘날, C는 주로 운영체제나 디바이스 드라이버, 빠르게 작동해야하는 프로그램을
쓰기 위해 로우레벨 시스템 프로그래밍에 쓰인다. Note: 이 HOWTO에 제공되는 String,
StringBuffer, StringTokenizer class를 이용하여 C++ 코드를 Java와 완전히 똑같이
쓸 수 있다. 이 문서의 일부는 C++로 Java class를 흉내냄으로써 C++과 Java의 차이를 줄이고자 했다.
C++과 Java를 왔다갔다하는 Java 프로그래머들은 이 String class를 좋아할 것이다. 만약 C++의 작성-컴파일-디버깅-컴파일 싸이클이 싫다면, web 개발이나 일반적이 프로그래밍에 쓰일 수 있는 PHP같은 script 언어를 알아보아라.
PHP나 PERL같은 script언어는 빠른 어플리케이션 개발을 가능하게 한다. PHP는 몇가지 객체지향을 위한 특징도 갖고 있다. PHP HOWTO는
http://doc.kldp.org/wiki.php/LinuxdocSgml/PHP-HOWTO 에서 볼 수 있고, 더 자세한 정보는 PHP 공식 홈페이지를 참고하면 된다.
C++은 C를 포함하기 때문에, C의 *나쁜* 점들을 모두 갖고 있다.
메모리의 수동 할당과 해제는 지루하고, 에러를 만들어내기 일쑤이다. ( 9.3절 를 보라). C 프로그래밍에서는 다음과 같은 것들로 인해 메모리 릭이나 오버플로우가 매우 흔하다.
Datatype char * and char[]
String functions like strcpy, strcat, strncpy, strncat, etc..
Memory functions like malloc, realloc, strdup, etc.. |
char *와 strcpy의 사용은
"오버플로우",
"경계침범에러(fence past errors)", "메모리 오염(memory corruption)",
"다른변수 침범(step-on-others-toe)" 이나 "메로리 릭(memory leaks)" 등의 끔찍한 메모리 문제를 일으킨다.
메모리 문제는 매우 디버깅이 힘들고, 따라서 고치기는데 많은 시간이 든다.
메모리 문제는 프로그래머의 생산성을 떨어뜨린다. 이 문서는 C++의 이러한 단점을
해결하기 위해 고안된 여러가지 방법들을 통해, 프로그래머의 생산성을 높이는데 도움을
주고자 한다.
메모리 관련 버그는 잡기 힘들고, 경험많은 프로그래머들도 메모리 관련 문제를 고치는 데는
며칠에서 몇주가 걸린다.
메모리 버그는 몇달동안 코드 속에 숨어서 갑작스런 프로그램 정지를 일으킬 수 있다.
char * 와 C/C++에서의 포인터
사용으로 인한 메모리 버그는 디버깅과 프로그램 정지로 인해 매년 20억 달러에 해당하는
시간의 소모를 일으킨다.
만약 C++에서
char * 과 포인터
를 사용한다면, 그리고 특히 프로그램의 크기가 10,000 줄이 넘어가는 상황이라면, 매우 힘든 일이 될 것이다. 따라서, 아래의 것들이 C-style에서의 문제점을 극복하기 위해 제안되었다.
앞에 나올 수록 더 좋은 것이다.
포인터 대신 레퍼런스를 사용한다. (이 HOWTO에 주어진) Java 형식의 class를 사용하거나, C++ 표준라이브러리의 string class를 사용한다. C++에서의 문자 포인터(char *) 사용은 String class를 사용하지 못할 때로 그 사용을 제한한다. 만약 C++에서의 문자 포인터(char *)를 사용하고 싶지 않을 때는, extern 연계를 이용하는 (char *)를.
"C의 char *"를 사용하기 위해서는, C 프로그램을 다른 파일에 넣고,
연계명시 문 extern "C" 를 이용하여
C++ 프로그램에 링크한다 -
extern "C" {
#include <some_c_header.h>
}
extern "C" {
comp();
some_c_function();
} |
extern "C" 는 연계 명시이고, 양 중괄호로 둘러싸인
블록안의 모든 내용이 C++이 아닌 C의 연계 방법을 사용한다는 말이다. 'String 클래스'는 메모리 할당과 해제를 위해 생성자와
파괴자를 이용하고,
ltrim, substring 등등과 같은
함수를 제공한다. 또한 관련된 7절 를 사용하는 C++ 컴파일러에서 찾아보아라.
string 클래스는 표준 C++ 라이브러리의 일부이고, 여러가지
문자열 관련 함수를 제공한다. C++ 'string 클래스' 와 'String 클래스'
라이브러리가 많은 문자열 함수를 제공하기 때문에, 직접 문자열 함수를 쓰기 위해
문자 포인터를 사용할 필요성이 거의 없다.
또한, C++ 프로그래머는 항상 'malloc'이나 'free'대신 'new', 'delete'를 사용해야 한다. 두 문자열 클래스는
char * 나 char []가 할 수 있는 모든 일을
할 수 있다.
그리고 더 좋은 점은 메모리 문제나 메모리 할당에 대해 전혀 걱정할 필요가 없다는 것이다.
ISO와 ANSI에 의해 채택된 현재의 C++ 표준은 1997년에 처음 완성되었다.
아직 모든 컴파일러가 이를 따르고 있지 않고, 모든 특징들이 다 지원되지는
않는 다는 것이다. - 표준에 맞는 컴파일러를 쓰는 것은 매우 중요하다.
MS Windows는 C++개발로 꽤 유명하기 때문에, 이 문서에 주어진 String class
라이브러가 잘 작동하고, Windows XP/2000/NT/95/98/ME 등 모든 버전에서 잘
작동한다.
MS Windows를 위한 C++ 컴파일러 :
이 문서의 String 클래스는 위에 언급된 모든 컴파일러로 테스트 되었고,
MS Visual C++ v6.0, Borland C++ v5.2, Borland C++ v5.5.1, Bloodshed 컴파일러에서
잘 동작한다.
GNU 세계에서는 GCC(GNU Compiler Collection)를 사용하는 것이 가장 좋은 선택이다.
GCC는 대부분의 리눅스 배포판, FreeBSD, 기타 Unix 클론들에 들어있다.
GCC 홈페이지는 http://gcc.gnu.org이다.
최신버전의 GCC(3.0)은 가장 표준을 잘 준수한 컴파일러 중 하나이다.
문자열 class는 프로그래밍에서 가장 중요한 것들 중 하나이고, 문자열 조정을
위해 매우 많이 쓰인다.
문자열 class는 여러가지가 있고, 물론 이들을 상속받음으로써 자신만의
문자열 class를 만들 수도 있다.
위에 말한 것 같이, 하나 혹은 여러 class를 상속받아 자신만의 문자열 class를
만들 수도 있다. 여기서는 표준 C++ 라이브러리의 string class와 부록 A의
String class 를 상속받음으로써 다중상속을 이용한 문자열 class를 만들어 볼
것이다. 우선 예제 파일 'string_multi.h'를 23절 에서 다운로드 받아라. 이 파일은 다음과 같다 :
// ******************************************************************
// String class와 표준 라이브러리의 "string" class를 상속받음으로써
// 직접 문자열 class를 만들어보는 예시를 위한 프로그램
// ******************************************************************
#ifndef __STRING_MULTI_H_ALDEV_
#define __STRING_MULTI_H_ALDEV_
#include <string>
#include "String.h"
#include "StringBuffer.h"
#ifdef NOT_MSWINDOWS
#else
using namespace std; // MS Visual C++ compiler Version 6.0 에서 필요함.
#endif
// 중요! : C++에서는 생성자, 파괴자, 복사 연산자가 같이 상속되지 않는다.
// 따라서 만약 =, + 등의 연산자가 base class에 정의되어 있고, base
// class의 생성자를 이용한다면, 반드시 같은 역할을 하는 생성자를
// 상속받는 class에도 만들어주어야 한다.
// 아래에 주어진 mystring(), mystring(char [])를 보아라.
//
// 또한 atmpstr이 mystring으로 선언되었다고 할 때, atmpstr + mstr
// 과 같이 연산자를 쓸 때, 실제로 불리는 것은 atmpstr.operator+(mstr)이다.
class mystring:public String, string
{
public:
mystring():String() {} // =, + 연산자를 위해 필요하다
mystring(char bb[]):String(bb) {} // =, + 연산자를 위해 필요하다
mystring(char bb[], int start, int slength):String(bb, start, slength) {}
mystring(int bb):String(bb) {} // + 연산자를 위해 필요하다
mystring(unsigned long bb):String(bb) {} // + 연산자를 위해 필요하다
mystring(long bb):String(bb) {} // + 연산자를 위해 필요하다
mystring(float bb):String(bb) {} // + 연산자를 위해 필요하다
mystring(double bb):String(bb) {} // + 연산자를 위해 필요하다
mystring(const String & rhs):String(rhs) {} // + 연산자를 위해 필요한 Copy Constructor
mystring(StringBuffer sb):String(sb) {} // Java와의 호환을 위해
mystring(int bb, bool dummy):String(bb, dummy) {} // StringBuffer class를 위해
int mystraa; // mystring의 최적화
private:
int mystrbb; // mystring의 최적화
};
#endif // __STRING_MULTI_H_ALDEV_ |
모든 프로그램과 예제는 이 문서의 부록에 주어진다.
String class와 라이브러리, 예제 프로그램을 하나의 tar zip 압축파일로
묶어놓은 링크가 다음과 같다.
혹 String class를 믿을 수 없을 수도 있다.
이를 해결하기 위해, 저자의 String class를 검증할 과학적인 방법이 있다.
현대 컴퓨터 공학자들은 소프트웨어를 검증하기 위해 머리가 아닌 CPU를 쓴다.
사람의 머리는 너무 느리기 때문에 테스트와 검증을 위해서는 컴퓨터의 힘을
빌리는 것이 좋다. 프로그램
example_String.cpp
으로 가서 'Source code for C++' 를 선택해라.
( 부록 A 에도 주어진다.
23절
) 위 프로그램은 수백만번의 테스트를 자동으로 할 수 있는 테스트 모듈을
갖고 있다. String class에 이 테스트를 해본다면, String class가
견고하고
완벽한 프로그램임을 알 수 있을 것이다. 직접 50000반복으로 테스트 해보았더니
오류없이 잘 동작하였다.
또한, 어떠한 메모리 릭도 발견할 수 없었다.
테스트는 리눅스에서 /usr/bin/gtop, UNIX top 명령어,
KDEStart->System->KDE System Guard
and KDEStart->System->Process management 등을 사용하여 cpu와 메모리를
체크하며 이루어졌다. 나는 반복횟수 를 천만번이나 그 이상으로 놓고 테스트
해보기를 추천한다. 반복횟수가 클수록 신뢰성은 더욱 높아질 것이다!!
테스트를 돌려놓고 밥을 먹으러 다녀오면 결과를 볼 수 있을 것이다!!
이 String class는 표준 C++ 라이브러리의 string class와 다르다는데 주의하라.
이 특별한 String class는 직접 만들어진 것이고, Java 프로그래머들이 C++을
쉽게 사용하도록 하기 위해 만들어졌다. 만약 당신이 C++과 더 익숙하다면
표준 C++ 라이브러리에 제공되는 진짜 string class 를 사용 하는 것이 좋다. String class를 사용하기 위해, 23절의
"example_String.cpp" 예제 프로그램과 23절의
String class를 보아라. 'String class' 는 char와 char * 타입을 완벽하게 대신할
수 있다.
'String class'를 char 처럼 사용할 수도 있고,
여러가지 다양한 기능도 사용할 수 있다.
23절 에 주어진 makefile에서 만들어지는 'libString.a'를
링크해야하고, C++ 라이브러리가 위치한 모든 곳의 라이브러리를 /usr/lib 나 /lib
디렉토리에 라이브러리를 복사해넣어야 한다.
'libString.a'를 사용하기 위해서는, 다음과 같이 컴파일하라.
다음에 주어진 예제 코드를 보라.
String aa;
aa = "Creating an Universe is very easy, similar to creating a baby human.";
// 프로그램에서 aa.val()을 'char *' 같이 사용할 수 있다.
for (unsigned long tmpii = 0; tmpii < aa.length(); tmpii++)
{
//fprintf(stdout, "aa.val()[%ld]=%c ", tmpii, aa.val()[tmpii]);
fprintf(stdout, "aa[%ld]=%c ", tmpii, aa[tmpii]);
}
// 실제로 'char *'로 사용하면..
for (char *tmpcc = aa.val(); *tmpcc != 0; tmpcc++)
{
fprintf(stdout, "aa.val()=%c ", *tmpcc);
} |
'String class'
는 아래와 같은 연산자를 제공한다 :-
연산자를 사용하는 예제를 보자.
String aa;
String bb("Bill Clinton");
aa = "put some value string"; // assignment operator
aa += "add some more"; // Add to itself and assign operator
aa = "My name is" + " Alavoor Vasudevan "; // string cat operator
if (bb == "Bill Clinton") // boolean equal to operator
cout << "bb is equal to 'Bill Clinton' " << endl;
if (bb != "Al Gore") // boolean 'not equal' to operator
cout << "bb is not equal to 'Al Gore'" << endl; |
String class에서 제공되는 함수들은 Java 의 String class와
같은 이름을 갖는다.
함수 이름과 동작은 Java의 String class와 완전히똑같다.
StringBuffer class역시 제공된다.
이들은 Java와 C++간의 포팅을 쉽게 할 것이다 (잘라내기 & 붙여넣기와 최소한의 코드 조정
만을 필요로 할 것이다).
Java의 함수에 들어있는 코드를 C++의 멤버함수로 복사하기만 하면 될 것이고,
최소한의 변경만으로도 C++에서 잘 컴파일 될 것이다.
또다른 이점은 Java와 C++을 모두 사용하는 개발자들이 둘 간의 문법이나 함수 이름을
따로따로 기억할 필요가 없어진다는 것이다. 예를들어 integer를 문자열로 바꾸는 것을 보면,
String aa;
aa = 34; // '=' 연산자가 int를 string으로 바꾼다.
cout << "The value of aa is : " << aa.val() << endl;
aa = 234.878; // '=' 연산자가 float를 string으로 바꾼다.
cout << "The value of aa is : " << aa.val() << endl;
aa = 34 + 234.878;
cout << "The value of aa is : " << aa.val() << endl;
// 출력은 '268.878'일 것이다.
// casting이 필요하다.
aa = (String) 34 + " Can create infinite number of universes!! " + 234.878;
cout << "The value of aa is : " << aa.val() << endl;
// 출력은 '34 Can create infinite number of universes!! 234.878'일 것이다. |
String class의 함수이름에 대한 자세한 내용은
23절 를 참고해라. 같은 String.h파일이 다음 섹션에도
나올 것이다.
만약 String class의 이름이 맘에 들지 않는다면, "typedef"
를 이름을 바꾸기 위해 사용할 수 있다. String.h를 include하는 모든 파일에 다음의 내용을 넣어라 :
// String이라는 이름이 맘에 들지 않는다면, 다음과 같이 바꾸어라.
typedef String StringSomethingElseIwant;
// 이제 코드는 다음과 같이 될 것이다.
int main()
{
StringSomethingElseIwant aa_renstr;
aa_renstr = "I renamed the String Class using typedef";
// .....
} |
example_String.cpp
에 가서 'Source code for C++'을 선택해라.
다른 같은 이름을 가진 class와 이름이 겹치는데, 두 class를 모두 사용하고
싶다면, 다음과 같은 방법을 써라.
String.h를 include하는 모든 파일에 다음의 내용을 넣어라.
#define String String_somethingelse_which_I_want
#include "String.h"
#undef String
#include "ConflictingString.h" // 이것도 String이란 class이다.
// 코드 내용..
int main()
{
String_somethingelse_which_I_want aa;
String bb; // 이것은 겹치는 String class이다.
aa = " some sample string";
bb = " another string abraka-dabraka";
.......
} |
전처리기가 모든 String을 "String_somethingelse_which_I_want"
으로 바꿀 것이고, String의 정의를 없앨 것이다.
undef 다음 부터는 "String" class를 정의하는 겹치는 string class header가 오게 된다.
C++과 Java는 많은 소프트웨어 프로젝트에서 같이 쓰인다.
C++과 Java를 왔다갔다하는 프로그래머들에게는 이 문자열 class가 매우 유용할 것이다. C++ (혹은 다른 객체지향 언어)에서는, "class 데이터구조"(혹은 인터페이스)
만 읽으면 그 class를 사용할 수 있다. 인터페이스만 이해하면 되지, 인터페이스의
구현까지는 알 필요가 없는 것이다.
String class의 경우, String.h 파일에 있는 String class만 읽고 이해하면 된다.
String class를 쓰기 위해 구현(String.cpp)을 모두
읽을 필요는 없는 것이다.
객체지향 class들은 시간을 절약하게 해주고, 구현의 내용을
교묘하게 숨겨준다. ( 객체지향인 Java에도 이와 같은 역할을 하여 구현 내용을 숨겨주는
'interface' 란 것이 있다. ) 아래의 내용은 String.h 파일이고,
23절을 참고해라.
//
// Author : Al Dev Email: alavoor[AT]yahoo.com
// string class나 String class를 써라.
//
// 메모리 릭을 막기 위해 - 문자 변수를 관리하기 위한 문자 class
// char[]나 char *보다는 String class나 string class를 써라.
//
#ifndef __STRING_H_ALDEV_
#define __STRING_H_ALDEV_
// 프로그램이 커질 수록 iostream을 사용하지 말아라.
#ifdef NOT_MSWINDOWS
#include <iostream>
#else
#include <iostream.h> // 하위호환성을 위해. C++ 표준은 .h가 없다.
#endif // NOT_MSWINDOWS
#include <stdio.h> // File과 sprintf()를 위해
//#include <list.h> // list
// MS Windows 95 VC++과 Borland C++ 컴파일러인 경우 -
// d:\program files\CBuilder\include\examples\stdlib\list.cpp 와 include\list.h
// 을 보라.
//#include <list> // for list
//using namespace std;
const short INITIAL_SIZE = 50;
const short NUMBER_LENGTH = 300;
const int MAX_ISTREAM_SIZE = 2048;
//class StringBuffer;
// 나는 이 문자열 class를 Linux (Redhat 7.1)와 MS Windows Borland C++ v5.2 (win32)
// 에서 컴파일 / 테스트 해보았다.
// 또한, MS Visual C++ compiler에서도 작동할 것이다.
class String
{
public:
String();
String(const char bb[]); // + 연산자를 위해 필요
String(const char bb[], int start, int slength); // 문자들의 부분집합
String(int bb); // + 연산자를 위해 필요
String(unsigned long bb); // + 연산자를 위해 필요
String(long bb); // + 연산자를 위해 필요
String(float bb); // + 연산자를 위해 필요
String(double bb); // + 연산자를 위해 필요
String(const String & rhs); // + 연산자를 위해 필요한 copy constructor
//String(StringBuffer sb); // Java와의 호환성을 위해
// - 그러나 MS windows에서는
// 컴파일되지 않고, core dump를 일으킨다.
String(int bb, bool dummy); // StringBuffer class를 위해 필요
virtual ~String(); // virtual로 선언하여 상속받은 class의 소멸자가
// 불리도록 한다.
char *val() {return sval;} // sval을 public으로 하는 것은 위험하므로
// Java의 String을 흉내낸 함수들
unsigned long length();
char charAt(int where);
void getChars(int sourceStart, int sourceEnd,
char target[], int targetStart);
char* toCharArray();
char* getBytes();
bool equals(String str2); // == 연산자를 참조하라
bool equals(char *str2); // == 연산자를 참조하라
bool equalsIgnoreCase(String str2);
bool regionMatches(int startIndex, String str2,
int str2StartIndex, int numChars);
bool regionMatches(bool ignoreCase, int startIndex,
String str2, int str2StartIndex, int numChars);
String toUpperCase();
String toLowerCase();
bool startsWith(String str2);
bool startsWith(char *str2);
bool endsWith(String str2);
bool endsWith(char *str2);
int compareTo(String str2);
int compareTo(char *str2);
int compareToIgnoreCase(String str2);
int compareToIgnoreCase(char *str2);
int indexOf(char ch, int startIndex = 0);
int indexOf(char *str2, int startIndex = 0);
int indexOf(String str2, int startIndex = 0);
int lastIndexOf(char ch, int startIndex = 0);
int lastIndexOf(char *str2, int startIndex = 0);
int lastIndexOf(String str2, int startIndex = 0);
String substring(int startIndex, int endIndex = 0);
String replace(char original, char replacement);
String replace(char *original, char *replacement);
String trim(); // 오버로딩 된 trim을 참조하라.
String concat(String str2); // + 연산자를 참조
String concat(char *str2); // + 연산자를 참조
String concat(int bb);
String concat(unsigned long bb);
String concat(float bb);
String concat(double bb);
String reverse(); // 오버로딩 된 다른 reverse()를 참조
String deleteCharAt(int loc);
String deleteStr(int startIndex, int endIndex); // Java의 "delete()"
String valueOf(char ch)
{char aa[2]; aa[0]=ch; aa[1]=0; return String(aa);}
String valueOf(char chars[]){ return String(chars);}
String valueOf(char chars[], int startIndex, int numChars);
String valueOf(bool tf)
{if (tf) return String("true"); else return String("false");}
String valueOf(int num){ return String(num);}
String valueOf(long num){ return String(num);}
String valueOf(float num) {return String(num);}
String valueOf(double num) {return String(num);}
// 이 파일의 아래에 주어진 StringBuffer를 참고하라.
// ---- 여기까지 Java를 흉내낸 함수들 -----
//////////////////////////////////////////////////////
// Java에는 없는 추가적인 함수들
//////////////////////////////////////////////////////
String ltrim();
void ltrim(bool dummy); // 직접적으로 object를 변화시킨다.
String rtrim();
void rtrim(bool dummy); // 직접적으로 object를 변화시킨다.
// chopall 참고.
void chopall(char ch='\n'); // 맨 뒤의 ch를 없앤다. rtrim 참고.
void chop(); // 맨 뒤의 문자를 없앤다.
void roundf(float input_val, short precision);
void decompose_float(long *integral, long *fraction);
void roundd(double input_val, short precision);
void decompose_double(long *integral, long *fraction);
void explode(char *separator); // token()과 오버로딩 된 explode()참조
String *explode(int & strcount, char separator = ' '); // token()참조
void implode(char *glue);
void join(char *glue);
String repeat(char *input, unsigned int multiplier);
String tr(char *from, char *to); // character들을 바꾼다(translate).
String center(int padlength, char padchar = ' ');
String space(int number = 0, char padchar = ' ');
String xrange(char start, char end);
String compress(char *list = " ");
String left(int slength = 0, char padchar = ' ');
String right(int slength = 0, char padchar = ' ');
String overlay(char *newstr, int start = 0, int slength = 0, char padchar = ' ');
String at(char *regx); // regx의 첫번째 match
String before(char *regx); // regx 앞의 string
String after(char *regx); // regx 뒤의 string
String mid(int startIndex = 0, int length = 0);
bool isNull();
bool isInteger();
bool isInteger(int pos);
bool isNumeric();
bool isNumeric(int pos);
bool isEmpty(); // length() == 0 과 같은 상태
bool isUpperCase();
bool isUpperCase(int pos);
bool isLowerCase();
bool isLowerCase(int pos);
bool isWhiteSpace();
bool isWhiteSpace(int pos);
bool isBlackSpace();
bool isBlackSpace(int pos);
bool isAlpha();
bool isAlpha(int pos);
bool isAlphaNumeric();
bool isAlphaNumeric(int pos);
bool isPunct();
bool isPunct(int pos);
bool isPrintable();
bool isPrintable(int pos);
bool isHexDigit();
bool isHexDigit(int pos);
bool isCntrl();
bool isCntrl(int pos);
bool isGraph();
bool isGraph(int pos);
void clear();
int toInteger();
long parseLong();
double toDouble();
String token(char separator = ' '); // StringTokenizer와 explode()를 참조
String crypt(char *original, char *salt);
String getline(FILE *infp = stdin); // putline() 참조
//String getline(fstream *infp = stdin); // putline() 참조
void putline(FILE *outfp = stdout); // getline() 참조
//void putline(fstream *outfp = stdout); // getline() 참조
void swap(String aa, String bb); // aa를 bb로 바꾼다
String *sort(String aa[]); // String의 array를 sort한다
String sort(int startIndex = 0, int length = 0); // string 내의 character들을 sort
int freq(char ch); // ch가 들어있는 횟수를 센다
void Format(const char *fmt, ...);
String replace (int startIndex, int endIndex, String str);
void substring(int startIndex, int endIndex, bool dummy); // object를 직접 바꾼다
void reverse(bool dummy); // object를 직접 바꾼다
String deleteCharAt(int loc, bool dummy); // object를 직접 바꾼다
String deleteStr(int startIndex, int endIndex, bool dummy);
void trim(bool dummy); // object를 직접 바꾼다
String insert(int index, String str2);
String insert(int index, String str2, bool dummy); // object를 직접 바꾼다
String insert(int index, char ch);
String insert(int index, char ch, bool dummy); // object를 직접 바꾼다
String insert(char *newstr, int start = 0, int length = 0, char padchar = ' ');
String dump(); // od -c 와 같이 string을 dump한다.
// Java의 StringBuffer를 위해 필요한 것들
void ensureCapacity(int capacity);
void setLength(int len);
void setCharAt(int where, char ch); // charAt(), getCharAt() 참고
// Java의 Integer class, Long, Double class를 위해 필요
int parseInt(String ss) {return ss.toInteger();}
int parseInt(char *ss)
{String tmpstr(ss); return tmpstr.toInteger();}
long parseLong(String ss) {return ss.parseLong();}
long parseLong(char *ss)
{String tmpstr(ss); return tmpstr.parseLong();}
float floatValue() {return (float) toDouble(); }
double doubleValue() {return toDouble(); }
char * number2string(int bb); // String(int) 참고
char * number2string(long bb); // String(long) 참고
char * number2string(unsigned long bb); // String(long) 참고
char * number2string(double bb); // String(double) 참고
///////////////////////////////////////////////
// 겹치는 함수 이름들
///////////////////////////////////////////////
// char * c_str() // val() 을 대신사용
// bool find(); // regionMatches() 를 대신사용
// bool search(); // regionMatches() 를 대신사용
// bool matches(); // regionMatches() 를 대신사용
// int rindex(String str2, int startIndex = 0); lastIndexOf() 을 대신사용
// String blanks(int slength); // repeat() 를 대신사용
// String append(String str2); // concat() 이나 + operator 을 대신사용
// String prepend(String str2); // + operator을 대신사용 append()참고
// String split(char separator = ' '); // token(), explode() 나 StringTokenizer class 를 대신사용
bool contains(char *str2, int startIndex = 0); // indexOf() 를 대신사용
// void empty(); is_empty() 를 대신사용
// void vacuum(); clear() 를 대신사용
// void erase(); clear() 를 대신사용
// void zero(); clear() 를 대신사용
// bool is_float(); is_numeric(); 을 대신사용
// bool is_decimal(); is_numeric(); 을 대신사용
// bool is_Digit(); is_numeric(); 을 대신사용
// float float_value(); toDouble(); 을 대신사용
// float tofloat(); toDouble(); 을 대신사용
// double double_value(); toDouble(); 을 대신사용
// double numeric_value(); toDouble(); 을 대신사용
// int int_value(); toInteger() 를 대신사용
// int tonumber(); toInteger() 를 대신사용
// String get(); substring() 이나 val() 을 대신 사용. 그러나 Java 스타일의 substring이 더 좋다
// String getFrom(); substring() 이나 val() 을 대신 사용. 그러나 Java 스타일의 substring이 더 좋다
// String head(int len); substring(0, len) 을 대신사용
// String tail(int len); substring(length()-len, length()) 를 대신사용
// String cut(); deleteCharAt() 이나 deleteStr() 을 대신사용
// String cutFrom(); deleteCharAt() 이나 deleteStr() 을 대신사용
// String paste(); insert() 를 대신사용
// String fill(); replace() 를 대신사용
// char firstChar(); // substring(0, 1); 을 대신사용
// char lastChar(); // substring(length()-1, length()); 를 대신사용
// String findNext(); token(), explode() 이나 StringTokenizer class 를 대신사용
// begin(); iterator. operator [ii]를 대신사용
// end(); iterator. operator [ii]를 대신사용
// copy(); assignment = 연산다를 대신 사용, String aa = bb;
// clone(); assignment = 연산자를 대신 사용, String aa = bb;
// void putCharAt(int where, char ch); setCharAt() 을 대신사용
// void replaceCharAt(int where, char ch); setCharAt() 을 대신사용
// char getCharAt(int where); CharAt() 을 대신사용
// void parseArgs(int where, char ch); StringTokensizer class, token() 이나 explode() 를 대신사용
// void truncate(); trim(), rtrim(), chop() 이나 chopall() 을 대신사용
// 숫자를 string으로 변환 : notostring(), int2str, long2str은 number2string()을 사용
// 연산자들...
String operator+ (const String & rhs);
friend String operator+ (const String & lhs, const String & rhs);
String& operator+= (const String & rhs); // 레퍼런스를 이용하면 더 빠를 것이다.
String& operator= (const String & rhs); // 레퍼런스를 이용하면 더 빠를 것이다.
bool operator== (const String & rhs); // 레퍼런스를 이용하면 더 빠를 것이다.
bool operator== (const char *rhs);
bool operator!= (const String & rhs);
bool operator!= (const char *rhs);
char operator [] (unsigned long Index) const;
char& operator [] (unsigned long Index);
friend ostream & operator<< (ostream & Out, const String & str2);
friend istream & operator>> (istream & In, String & str2);
bool String::operator< (const char *rhs) const; // map & vector 를 위한 유용한 method
bool String::operator< (const String & rhs) const; // map & vector 를 위한 유용한 method
//do later: static list<String> explodeH; // list head
protected:
char *sval; // sval을 public으로 하는 것은 위험하다.
void verifyIndex(unsigned long index) const; // Win32에서의 warning때문에 inline이 아니다.
void verifyIndex(unsigned long index, char *aa) const;// Win32에서의 warning때문에 inline이 아니다.
void _str_cat(char bb[]);
void _str_cat(int bb);
void _str_cat(unsigned long bb);
void _str_cat(float bb);
void _str_cpy(char bb[]);
void _str_cpy(int bb); // itoa
void _str_cpy(unsigned long bb);
void _str_cpy(float bb); // itof
private:
// Note: 모든 private 변수와 함수는 _ (밑줄)로 시작한다.
//static String *_global_String; // add 연산에서 필요
//inline void _free_glob(String **aa);
bool _equalto(const String & rhs, bool type = false);
bool _equalto(const char *rhs, bool type = false);
String *_pString; // 내부에서 사용하는 임시 포인터
char *_pNumber2String; // 내부에서 사용하는 임시 포인터
inline void _allocpString();
inline void _allocpNumber2String();
inline void Common2AllCstrs();
inline void _reverse();
inline void _deleteCharAt(int loc);
inline void _deleteStr(int startIndex, int endIndex);
inline void _trim();
inline void _ltrim();
inline void _rtrim();
inline void _substring(int startIndex, int endIndex);
void _roundno(double input_dbl, float input_flt, short precision, bool type);
};
// 전역변수는 String.cpp 에서 정의된다
#endif // __STRING_H_ALDEV_ |
C++ 과 Java는 많은 소프트웨어 프로젝트에서 동시에 쓰인다.
C++과 Java를 왔다갔다하는 프로그래머에게 이 stringbuffer class는 매우 유용할 것이다.
//
// Author : Al Dev Email: alavoor[AT]yahoo.com
//
#ifndef __STRINGBUFFER_H_ALDEV_
#define __STRINGBUFFER_H_ALDEV_
// Java의 StringBuffer 를 모방한 것
// 이 class는 Java의 code를 최소한의 수정만으로도
// C++에서 동작하도록 하기 위해 만들어졌다.
// Note: C++로 코딩하는 동안은 이 StringBuffer
// class를 *쓰지 말아라*.
// 이 class는 오직 Java 코드를 cut/paste하는 경우를
// 위해서 쓰여진 것이다.
class StringBuffer: public String
{
public:
StringBuffer();
~StringBuffer();
StringBuffer(char *aa);
StringBuffer(int size);
StringBuffer(String str);
int capacity();
StringBuffer append(String str2);
// operator + 참조
//{ *this += str2; return *this;} // 이 code는 core dump를 일으킨다
StringBuffer append(char *str2);
StringBuffer append(int bb);
StringBuffer append(unsigned long bb) ;
StringBuffer append(float bb) ;
StringBuffer append(double bb) ;
StringBuffer insert(int index, String str2);
StringBuffer insert(int index, char ch);
StringBuffer reverse();
// Java의 "delete()"에 해당. (delete는 C++의 keyword이므로 사용하지 못한다)
StringBuffer deleteStr(int startIndex, int endIndex);
StringBuffer deleteCharAt(int loc);
StringBuffer substring(int startIndex, int endIndex = 0);
void assign(char *str);
private:
StringBuffer *_pStringBuffer;
inline void allocpStringBuffer();
inline void Common2AllCstrs();
};
#endif // __STRINGBUFFER_H_ALDEV_ |
C++ 과 Java는 많은 소프트웨어 프로젝트에서 동시에 쓰인다.
C++과 Java를 왔다갔다하는 프로그래머에게 이 stringtokenizer class는 매우 유용할 것이다.
//
// Author : Al Dev Email: alavoor[AT]yahoo.com
//
#ifndef __STRINGTOKENIZER_H_ALDEV_
#define __STRINGTOKENIZER_H_ALDEV_
// Java의 StringBuffer 를 모방한 것
// Java의 코드를 C++에서 혹은 그 반대로 컴파일하는 것이
// 가능하게 만들어졌다.
class StringTokenizer: public String
{
public:
StringTokenizer(String str);
StringTokenizer(String str, String delimiters);
StringTokenizer(String str, String delimiters, bool delimAsToken);
~StringTokenizer();
int countTokens();
bool hasMoreElements();
bool hasMoreTokens();
String nextElement(); // Java에서는 "Object"type을 return한다.
String nextToken();
String nextToken(String delimiters);
private:
int CurrentPosition; // 현재 string에서의 index
int TotalTokens;
int RemainingTokens;
char * ListOfDl; // delimiters(구분자)들의 list
char * WorkStr; // 임시 작업 string
char * OrigStr; // 지나온 original string
bool DlFlag; // 구분자인지를 나타내는 flag
inline void vPrepWorkStr(char *delimiters = NULL);
};
#endif // __STRINGTOKENIZER_H_ALDEV_ |
위에 언급된 String class (S가 대문자인 것에 주의!)는 Java를 사용하는 사람들을
위한 것인 반면, 표준 C++ 라이브러리에서 제공되는 "진짜" string class를 주목할
필요가 있다. string class는 C에서의 가장 큰 문제점 중 하나인 문자배열의 단점을 극복하기 위해
만들어졌다. 문자배열이 무척 빠르긴 하지만, 많은 단점을 갖고 있다.
문자배열은 많은 버그의 원인이고, 이를 parsing하는 일은 굉장히 귀찮은 일이다. string class는 문자열을 파싱하고, 조정하는데 필요한 좋은 인터페이스를 제공하고,
STL과도 호환가능하다. 즉, 모든 STL의 알고리즘을 사용할 수 있다.
실제로 문자열은 vector<char>
( 문자들을 위한 container 혹은 진보된 문자배열 )
로 취급될 수 있다. 다음의 사이트에서 참고할만한 것들을 얻을 수 있다:
string을 만드는 것은 쉽다.
Creating a string is easy:
#include <string>
#include <iostream>
using namespace std;
int main()
{
string str("Hello World!"); // 혹은 string str = "Hello World!";
cout << str << endl;
}
|
이 코드는 "str'란 string을 만들고, "Hello
World!' 라는 내용을 넣을 것이다.
그리고 cout을 사용하여 표준출력(stdout)으로 출력할 것이다.
(이제부터 모든 헤더와 namespace 관련부분은 생략할 것이다.) 문자열의 부분을 구하는 것 역시 쉽다 :
string str("Hello Universe!");
string start = str.substr(0, 5);
string end = str.substr(5); |
여기서는 첫 6글자를 string "start"에, 나머지는
"end"에 들어갈 것이다. 문자열의 길이를 얻기 위해서는, 아래와 같이 하면 된다.
string str("How long is this string?");
cout << "Length of string is: " << str.size() << endl; |
혹은 이와 정확히 똑같은 역할을 하는 length() 를 써도 된다.
문자열을 찾는 것은 문자배열보다 훨씬 쉽다. string class는 문자열을 찾는데
효율적인 멤버 함수들을 제공한다.
모든 멤버함수는 string::size_type 을 return한다.
표 1. 문자열 검색 멤버 함수 | 멤버 함수 | 작동 | | | find() | 주어진 부분문자열이 처음으로 나타나는 곳을 찾는다 | | | find_first_of() | find()와 같으나 주어진 문자가 처음으로 나타나는 위치를 찾는다 | | | find_last_of() | find first of()와 같으나, 주어진 문자가 마지막으로 나타나는 위치를 찾는다 | | | find_first_not_of() | find first of() 과 같으나 주어진 문자가 아닌 첫 문자가 처음으로
나타나는 위치를 찾는다 | | | find_last_not_of() | find last of() 과 같으나 주어진 문자가 아닌 문자를 찾는다. | | | rfind() | find()와 같으나, 찾는 방향이 반대이다. (뒤쪽부터 찾는다) | | | | | |
가장 흔한 상황은 문자열을 찾는 것이고, 이는
find() 함수를 사용하면 된다.
string str("Hello, can you find Ben?");
string::size_type position = str.find("Ben");
cout << "First occurence of Ben was found at: " << position << endl; |
이 코드는 'Ben'에 대해 대소문자를 구별하는 검색을 하고,
시작위치를 'position'에 string::size_type 타입으로 넣는다.
리턴하는 값이 int가 아니라 특별히 고안된 string::size_type 타입이라는데 주의하라. find_first_of()
함수는 실제적인 예가 필요할 것이다.
아래와 같은 상황을 보자.
string s = "C++ is an impressive language.";
string::size_type pos = s.find_first_of(" .");
while (pos != string::npos) {
cout << "Found space or dot at: " << pos << endl;
pos = s.find_first_of(" .", pos + 1);
} |
find_first_of()함수를 쓰면,
우리는 첫번째 인자의 모든 문자를 찾게 되고,
따라서 여기서는 스페이스(' ') 혹은 점('.')을 찾게 된다. 프로그램을 컴파일해서 어떻게 출력되는지 보아라.
문자열을 가지고 자주 하게되는 작업 중 하나는, 어떤 구분자를 가지고 토큰들로
나누는 것이다 (tokenize). tokenizer는 문자열을 find()를 계속 부르는 일 없이
쉽게 조그만 조각들로 쪼갤 수 있도록 해준다. C에서는, 아마도 문자 배열에 대해
strtok() 란 함수를 썼을 것이지만,
문자열에 대해서는 이러한 함수가 없다. 따라서 직접 이런 함수를 만들어야 겠지만,
몇가지 해결책이 있다. The advanced tokenizer:
void Tokenize(const string& str,
vector<string>& tokens,
const string& delimiters = " ")
{
// 맨 첫 글자가 구분자인 경우 무시
string::size_type lastPos = str.find_first_not_of(delimiters, 0);
// 구분자가 아닌 첫 글자를 찾는다
string::size_type pos = str.find_first_of(delimiters, lastPos);
while (string::npos != pos || string::npos != lastPos)
{
// token을 찾았으니 vector에 추가한다
tokens.push_back(str.substr(lastPos, pos - lastPos));
// 구분자를 뛰어넘는다. "not_of"에 주의하라
lastPos = str.find_first_not_of(delimiters, pos);
// 다음 구분자가 아닌 글자를 찾는다
pos = str.find_first_of(delimiters, lastPos);
}
} |
tokenizer는 다음과 같이 쓰일 수 있다.
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
vector<string> tokens;
string str("Split me up! Word1 Word2 Word3.");
Tokenize(str, tokens);
copy(tokens.begin(), tokens.end(), ostream_iterator<string>(cout, ", "));
} |
위의 코드는 Tokenize 함수를 사용하는 예로서, 첫번째 인자인
str를 쪼갠다. 그리고 우리가 세 번째 인자를 주지
않았기 때문에 디폴트로 설정된 " "(spacebar)를 구분자로 사용한다.
그리고 모든 element는 tokens 벡터에 들어가게 될 것이다. 마지막으로 표준 출력에 벡터 전체를 copy()함으로써 벡터의 내용을 화면으로
볼 수 있을 것이다. 또다른 접근 방법은 stringstream을 사용하는 것이다. C++에서 stream은 특수한
기능이 하나 있는데, 이는 공백(whitespace)를 만날 때까지 읽기를 계속한다는 것이다.
따라서 아래의 코드는 공백을 기준으로 문자열을 나누고자 할 때 잘 동작할 것이다.
#include <vector>
#include <string>
#include <sstream>
using namespace std;
int main()
{
string str("Split me by whitespaces");
string buf; // 버퍼 string
stringstream ss(str); // string을 stream에 넣는다
vector<string> tokens; // word들을 넣을 vector
while (ss >> buf)
tokens.push_back(buf);
} |
이제 stringstream은 출력 연산자(>>)를 사용 하여 문자열을 buf
에 공백을 만날 때마다 넣는다.
buf는 이를 차례대로 벡터에 push_back() 한다.
그리고 이제 tokens 벡터는 str 에
들어있는 모든 단어를 갖게 된다.
C++ 과 Java는 많은 소프트웨어 프로젝트에서 동시에 쓰인다.
C++과 Java를 왔다갔다하는 프로그래머에게 이 File class는 매우 유용할 것이다. 운영체제의 파일을 관리할 때, File class가 필요할 것이다. 이 class는
Java의 File class를 모방한 것으로, C++ 프로그래밍에서 매우 유용할 것이다.
C++에서 이 class를 사용하면, 파일이 존재하는지(exists()),
디렉토리가 존재하는지(exists()),
파일의 길이는 어떤지(length()) 등을 알 수 있다. 이 class가 표준 C++ 라이브러리에는 없는 좋은 기능들을 갖고 있다는 데 주목해라.
그러나 여러가지 다른 동작을 해주어야 하는 fstreams(iostreams)과 헷갈리지는 말아라.
C에서는, 메모리의 할당과 해제를 위해 malloc()과 free()를 비롯한 malloc()계열의 함수를
쓰지만, 다들 단점을 갖고 있다.
그래서 C++ 은 메모리를 다루기 위한 연산자들을 도입했고, 이들은
new 와 delete이다.
이 연산자들은 실행시에 힙(heap - 혹은 자유 공간)으로부터 메모리를 할당, 해제한다. C++에서는 정말로 꼭 malloc()이나 free()만을 써야하는 상황이 아니라면 언제나
new 와 delete를 써야한다.
그러나 주의할 점은, 이 두 가지를 섞어서 쓰면 안된다는 것이다.
malloc()으로 얻은 메모리를 delete로 해제할 수는 없고, 반대로 new로 얻은 메모리를
free()시킬 수도 없다.
C++에서의
delete 와 new
연산자는 C의 malloc, free보다 낫다. 따라서 malloc과 free 대신 new와 zap(delete)를
쓰도록 하는 것이 좋다. delete 연산자가 좀 더 깔끔하게
사용되게 하기위해 다음과 같은 Zap() inline 함수를 만들자.
다음과 같이 zap()을 정의하자.
// x가 NULL인지 체크하기 위해 assert를 사용하였다.
// 이는 프로그램의 "논리적" 에러를 미리 잡아내기 위한 것이다.
// delete가 NULL인 경우에도 잘 동작하긴 하지만, assert를
// 사용함으로써 좀 더 일찍 에러를 잡아낼 수 있다.
// Zap을 template을 사용하여 정의하자.
// delete대신 zap을 사용하면 더 깔끔할 것이다.
template <class T>
inline void zap(T & x)
{
{assert(x != NULL);}
delete x;
x = NULL;
}
// C++에 두 가지 delete 연산자의 용법이 있는 이유는 C++ 에게
// 한 객체에 대한 포인터와 객체의 배열에 대한 포인터를 구별하도록
// 말해주는 방법이 필요하기 때문이다.
// delete연산자는 프로그래머에게 "[]"를 쓰게함으로써 이를 구별한다.
// 따라서 우리는 포인터의 배열을 지우기 위한 zaparr 함수를 다음과 같이 정의할 수 있다
template <class T>
inline void zaparr(T & x)
{
{assert(x != NULL);}
delete [] x;
x = NULL;
} |
zap()함수는 포인터를 delete시키고 NULL로 세팅한다.
이는 똑같은 delete 포인터에 대해 여러번의 zap()이
불려서 프로그램이 망가지는 것을 방지한다.
다음의 zap_example()함수를 보아라.
example_String.cpp
'Source code of C++'을 클릭해라.
// example_String.cpp에서 zap_example()를 보라.
zap(pFirstname);
//zap(pFirstname); // pFirstname이 NULL이므로 코어 덤프가 일어나지 않는다.
//zap(pFirstname); // pFirstname이 NULL이므로 코어 덤프가 일어나지 않는다.
zap(pLastname);
zap(pJobDescription);
int *iiarray = new int[10];
zaparr(iiarray); |
뭐 특별한 것이 있는 것은 아니고, 이것은 단지 반복적인 코드를 줄이고
타이핑하는 시간을 아껴주며 프로그램을 좀 더 읽기 좋게 만들어주는 것 뿐이다.
C++ 프로그래머들은 자주 delete한 pointer를 NULL로 세팅하는 것을 잊는다.
그리고 이는 코어덤프와 오작동으로 이어질 수 있다.
zap()은 이러한 문제를 자동으로 처리해준다.
zap()에 타입 캐스팅을 할 필요는 없다. 만약 위 zap()함수에서 에러가 난다면,
다른 데서 시작된 에러일 것이다. 또한
9.2절
, my_realloc() 과 my_free() 이
malloc(), realloc() 그리고 free() 대신 쓰여야 한다.
이들은 훨씬 깔끔하고, 여러가지 체크도 해준다.
예를들어,
9.2절 과
my_free() 함수를 사용하는 "String.h" 파일을 보라. 주의 :
'new'로 할당된 메모리를 해제하기 위해 free()를 쓰거나, malloc()으로 할당된
메모리를 해제하기 위해 'delete'를 쓰지 말아라. 그렇지 않으면
결과를 예측할 수 없는 에러에 빠질 것이다. example_String.cpp 에서 'Source code of C++' 를 클릭한다음, zap함수의 예를 보아라.
malloc과 realloc 을 최대한 사용하지 말고, new 와
9.1절(delete)을 사용해라.
그러나 때로는 C++에서 C 스타일의 메모리 할당을 사용해야 할 필요도 있다.
이 때는 my_malloc() ,
my_realloc() ,
my_free() 을 사용해라.
이 함수들은 적절한 할당과 초기화를 해주고, 메모리 문제를 예방해준다.
또한 이 함수들은 DEBUG모드에서 메모리 할당을 추적해주고, 프로그램 실행
전후에 총 메모리 사용량을 표시해준다. 이는 메모리 릭이 있는지를
알려줄 것이다. my_malloc 과 my_realloc은 다음과 같이 정의되었다.
이는 약간의 메모리를 더 할당해서 (SAFE_MEM = 5) 초기화시키고,
메모리를 할당할 수 없으면 프로그램을 종료한다.
'call_check(), remove_ptr()' 함수는 DEBUG_MEM 가 makefile에서
((void)0) (이는 NULL을 의미한다)으로 지정되어있을 때에만 작동한다.
이는 총 메모리 사용량을 추적할 수 있게 해준다.
void *local_my_malloc(size_t size, char fname[], int lineno)
{
size_t tmpii = size + SAFE_MEM;
void *aa = NULL;
aa = (void *) malloc(tmpii);
if (aa == NULL)
raise_error_exit(MALLOC, VOID_TYPE, fname, lineno);
memset(aa, 0, tmpii);
call_check(aa, tmpii, fname, lineno);
return aa;
}
char *local_my_realloc(char *aa, size_t size, char fname[], int lineno)
{
remove_ptr(aa, fname, lineno);
unsigned long tmpjj = 0;
if (aa) // aa != NULL
tmpjj = strlen(aa);
unsigned long tmpqq = size + SAFE_MEM;
size_t tmpii = sizeof (char) * (tmpqq);
aa = (char *) realloc(aa, tmpii);
if (aa == NULL)
raise_error_exit(REALLOC, CHAR_TYPE, fname, lineno);
// do not memset memset(aa, 0, tmpii);
aa[tmpqq-1] = 0;
unsigned long kk = tmpjj;
if (tmpjj > tmpqq)
kk = tmpqq;
for ( ; kk < tmpqq; kk++)
aa[kk] = 0;
call_check(aa, tmpii, fname, lineno);
return aa;
} |
my_malloc 의 모든 구현을 보려면
23절
에서
23절
의 헤더파일을 보면 된다. my_malloc 과 my_free 를 쓰는 예는 다음과 같다.
char *aa;
int *bb;
float *cc;
aa = (char *) my_malloc(sizeof(char)* 214);
bb = (int *) my_malloc(sizeof(int) * 10);
cc = (float *) my_malloc(sizeof(int) * 20);
aa = my_realloc(aa, sizeof(char) * 34);
bb = my_realloc(bb, sizeof(int) * 14);
cc = my_realloc(cc, sizeof(float) * 10); |
my_realloc 에서 data type을 cast 할 필요가 없는 것에 주의해라.
이는 인자로 받은 변수의 타입에 맞춰서 리턴값을 보내기 때문이다.
The my_realloc 함수는 char *, int *, float * 타입으로 오버로딩
되어있다.
C/C++에서 가비지 콜렉션은 표준에서 지원되지 않고, 따라서 메모리를 직접
할당, 해제하는 것이 어렵고 복잡하며 에러를 내기 쉽다.
가비지 콜렉션(GC:Garbage Collection) 은
구현하는 방법이 여러가지가 있고, 각 프로그램마다 적용될 수 있는 방법이
다르기 때문에 C++ 표준의 일부가 될 수 없었다.
전산학자들은 많은 GC 알고리즘을 개발했고, 이들은 각 문제분야에서만
적용될 수 있는 것들이었다.
즉, 모든 일반적인 문제에 적용될 수 있는 하나의 범용 GC알고리즘은 없다.
따라서 GC는 C++ 표준에 들어가지 못했다. 따라서 언제나 하는 일에 맞는
C++ 라이브러리를 많은 라이브러리들 중에서 고를 수 있다. 다음 C++
가비지 콜렉션(Garbage Collection)
사이트와
메모리 관리 사이트를 가보아라.
포인터는 일반적인 프로그램에서 꼭 필요한 것은 아니다.
Java와 같은 현대 언어에서는 포인터가 없다 (Java는 내부적으로만
포인터를 사용한다).
포인터는 프로그램을 어지럽고 읽기 힘들게 만든다. 최대한 포인터의 사용을 피하고, 대신 레퍼런스를 사용해라.
포인터는 정말 문제가 많고, 포인터 없이 프로그램을 쓰는 게 가능하다.
포인터는 레퍼런스를 쓸 수 없는 곳에서만 써야한다. 레퍼런스
는 별칭(alias)이다. 레퍼런스를 만들면, 이는 다른 객체(혹은 대상)에 다른 이름을
주는 것이다. 그 순간부터 레퍼런스는 대상의 다른 이름으로서 돌아가고,
레퍼런스에 행하는 모든 연산이 그 대상에 실제로 적용된다. 레퍼런스의 문법 :
타입을 선언할 때, 뒤에 레퍼런스 연산자 (&) 를 붙임으로써 레퍼런스를 선언할 수 있다.
레퍼런스는 반드시 만들어 질 때 초기화 되어야 한다.
다음의 예를 보자 -
int weight;
int & rweight = weight;
DOG aa;
DOG & rDogRef = aa; |
레퍼런스를 사용할 때 지킬 것 -
객체에 대한 다른 이름을 주고자 할 때 레퍼런스를 사용해라. 모든 레퍼런스는 초기화되어야 한다. 프로그램의 높은 효율과 퍼포먼스를 위해 레퍼런스를 사용해라 레퍼런스와 포인터를 보호하기 위해 가능한경우면 언제나
const를 사용해라.
레퍼런스를 사용할 때 하지 말아야 할 것 -
중요 : NULL인 객체에 대해 레퍼런스를 쓰지 말아라. 포인터의 주소를 나타내는 &와 레퍼런스 연산자를 헷갈리지 마라.
레퍼런스 연산자는 오직 선언부 (위에 나와있는 레퍼런스 사용법 참조) 에서만 쓰인다. 레퍼런스에 새로 값을 지정하려(즉, 변경하려) 하지 마라. 레퍼런스를 쓸 수 있다면 포인터를 쓰지 마라. 지역변수에 대한 레퍼런스를 리턴하지 마라. 레퍼런스가 스코프가 벗어난 변수를 가리키도록 하지 마라.
정확한 버그의 원인을 알아내는 것은 꽤나 성가신 일이지만,
여기에도 몇가지 테크닉이 있다.
표준출력으로 프린트하여 - 프로그램이 간단한 경우, 몇몇 변수들의 값을
프린트해보고, 어떤 값인지 본다 - 무엇이 잘못되었는지 찾기 디버거를 이용하기. 디버거는 breakpoint를 설정하고, 실행도중에 코드를
추적해볼 수 있도록 해준다. 대부분의 IDE는 디버거가 같이 있다.
GNU 시스템의 경우, gdb가 있다. 컴파일러에서 지원하는 옵션들을 사용하여 보다 많은 경고(warning)을 볼 수 있도록
해라. 예를들어 g++의 경우, -Wall 옵션을 사용해라.
디버깅에 도움이 되는 사이트 :
C++이나 C 프로그램을 디버깅하려면 23절 의 파일을 인클루드하고,
'Makefile'에 DEBUG_STR, DEBUG_PRT , DEBUG&_MEM을 디파인 해서
debug.h 의 함수들로 추적할 수 있도록 한다.
'-DDEBUG_STR' 등을 없앨 때, 디버깅 함수들은 ((void)0) (NULL을 의미)으로 세팅될
것이다. 따라서 최종 결과물에는 아무런 영향을 주지 않는다.
이 디버깅 함수들은 프로그램에 다양하게 적용될 수 있을 것이고, 결과물의 크기를
증가시키지는 않을 것이다. debug 루틴의 구현을 위해서는 23절 를 참조해라. 또한, 23절 에서 debug.h 와 디버깅 함수들을
이용한 예제 프로그램을 보아라. 23절 의 예를 보라.
C++로 프로그래밍을 할 때, 에디터나 IDE를 사용하는 것이 좋다. 대부분의
프로그래머는 자신이 좋아하는 것들을 갖게 마련이고, 어떤 것이 좋은지에
대해 거의 종교적인 믿음을 갖는다. 너는 내장 에디터와 컴파일러, 문서들과 기타 등등으로 모두 포함하는
IDE (Intergrated Development Environment : 통합 개발환경)를 사용할 수도 있다.
또는 몇몇 사람들이 그러는 것 처럼, 단순한 에디터만을 사용할 수도 있다.
C++ 개발을 위한 다음과 같은 IDE (Integrated Development Environment) tool이 있다.
IDE의 문제점은 이에 같이 들어있는 에디터의 기능이 매우 떨어진다는 것이다.
따라서 많은 사람들은 파워풀한 에디터를 원했고, 컴파일러와 함께 사용한다. 파워풀한 에디터로는 vim과 emacs를 들 수 있다.
둘 다 모두 많은 플랫폼에서 동작하고, 효율성을 높여줄 신택스 하이라이팅을
비롯한 여러가지 기능들을 갖고 있다. 다른 것으로는 UltraEdit(win32 only) 와 EditPlus(win32 only)가 있다.
C++ Beautifier HOWTO http://www.linuxdoc.org/LDP/HOWTO/C-C++Beautifier-HOWTO.html
( 한글번역 ) C++ 프로그램을 위한 버전관리 시스템 HOWTO (CVS HOWTO) http://www.linuxdoc.org/LDP/HOWTO/CVS-HOWTO.html 유용한 리눅스 사이트 http://www.milkywaygalaxy.freeservers.com
와 미러 사이트 -
angelfire,
geocities,
virtualave,
50megs,
theglobe,
NBCi,
Terrashare,
Fortunecity,
Freewebsites,
Tripod,
Spree,
Escalix,
Httpcity,
Freeservers.
C++에 대한 수백만의 온라인 문서/텍스트/참고자료 가이드 등이 존재한다. 이는 C++이 매우 오랫동안 쓰이고 있기 때문이다. 아마
Google, Yahoo, Lycos, Excite 등의 인터넷 검색엔진을 사용하면 도움이 될 것이다.
C++ 프로그래머를 위해 유용할 Java 책들 :
다음의 C++ 사이트들을 방문해보라 :-
인터넷에는 어마어마하게 많은 C++ 문서들이 있다.
Google, Yahoo, Lycos, Infoseek, Excite 같은 검색엔진에 가서
다음의 키워드를 넣어보아라.
'C++ tutorials'
'C++ references'
'C++ books'
Advanced 를 클릭해서
search by exact phrase를 선택함으로써
더 정확한 결과를 얻을 수 있을 것이다.
인터넷에는 많은 수의 온라인 튜토리얼이 있다. 검색엔진에서 'C++ tutorials'로
검색을 해봐라.
검색엔진에서 'C++ Reference' 로 검색을 해보아라.
C++에서 Java 형태의 API를 제공하는 다음 사이트들을 가보아라.
코딩 관습은 프로그램의 가독성과 유지보수를 위해 매우 중요한 요소이다.
또한 프로그래머의 생산성을 크게 향상시킨다.
이는 좋은 코딩 훈련을 위해 필요하다.
아래의 내용은 class 정의에 있어 제안된 것이다.
모든 public 변수들은 mFooVar과 같이 m 으로 시작해야 한다.
m 은 member를 의미한다. 모든 protected 변수들은 mtFooVar 와 같이
mt 로 시작해야하고, 메쏘드는 tFooNum() 와 같이 t로 시작해야 한다.
t 는 protected를 의미한다. 모든 private 변수들은 mvFooVar와 같이
mv 로 시작해야하고, 메쏘드들은
vFooLone() 와 같이 v로 시작해야 한다.
v 는 private 을 의미한다. 모든 public, protected, private 변수이름들은 m 다음에는 mFooVar 의 F같이 대문자로 시작해야한다. 모든 포인터 변수들은 다음과 같이 p로 시작해야 한다.
Public 변수 mpFooVar 과 메쏘드 FooNum() Protected 변수 mtpFooVar 와 메쏘드 tFooNum() Private 변수 mvpFooVar 와 메쏘드 vFooNum()
세계적으로 일관된 C++ 코딩 관습은 보다 프로그래밍을 잘 할 수 있도록 도와줄 것이다. 아래에 주어진 예제 코드에서
t 는 protected를,
v 는 private를,
m 는 member-variable 를,
p 는 pointer를
의미한다.
class SomeFunMuncho
{
public:
int mTempZimboniMacho; // OOP에서는 오직 임시 변수들만 public이어야 한다.
float *mpTempArrayNumbers;
int HandleError();
float getBonyBox(); // 변수에 접근하기 위한 함수
float setBonyBox(); // 변수에 접근하기 위한 함수
protected:
float mtBonyBox;
int *mtpBonyHands;
char *tHandsFull();
int tGetNumbers();
private:
float mvJustDoIt;
char mvFirstName[30];
int *mvpTotalValue;
char *vSubmitBars();
int vGetNumbers();
}; |
프로그램이 수백만 라인으로 커지게 되면, 위와 같은 관습을 매우 좋아하게
될 것이다. 단순히 mvFirstName 라는 변수이름을
본 것만으로도, 이것이 클래스의 멤버이고, private 변수라는 것을 알 수 있으므로
코드의 가독성은 올라가게 된다. 다음의 C++ 코딩 표준 URL들을 방문해보아라.
C++의 큰 단점은 조그만 변경을 할 때마다 항상 컴파일과 링크를 다시
해주어야 실행파일을 만들 수 있다는 것이다.
컴파일/링크/디버깅 사이클은 많은 시간이 걸리고 생산적이지 못하다.
현대의 CPU와 RAM은 매우 빠르고 싸지고 있으므로, 어떤 때는
하드웨어에 많은 돈을 투자하고, 개발을 위해서는 script 언어를 쓰는 것이
좋을 수도 있다.
PHP나 PIKE 같은 스크립트 언어는 링킹과 재컴파일 과정을 없앴고,
따라서 개발 과정을 단축시킬 수 있다. 메모리(RAM) 가격이 떨어지고, CPU 속도가 올라감에 따라
PHP나 PIKE같은 스크립트 언어의 인기는 폭발할 것이다.
PHP나 PIKE는 객체지향과 C/C++을 닮은 문법으로 인해 가장 널리 쓰이는 스크립트
언어가 될 것이다. PHP나 Pike C++ 스크립트 언어를 씀으로써 프로그래밍의 생산성은
다섯 배 나 증가할 것이다.
그리고 PHP나 PIKE는 '개념의 증명'을 위해 유용하고, 프로토타입을 빠르게 만들어낼
수 있다. PHP는 일반적인 프로그래밍이나 웹 프로그래밍에서 매우 인기를 얻고 있다.
PHP는 가까운 미래에 가장 널리 쓰이는 스크립트 언어가 될 것이다.
PHP 는 http://www.linuxdoc.org/HOWTO/PHP-HOWTO.html ( 한글번역 )
에 있다. The Pike 는 http://pike.roxen.com 와 http://www.roxen.com 에 있다. Roxen 웹서버는 순수하게 Pike로 쓰여져서, 얼마나 Pike가 강력한지 보여주고 있다.
Pike는 몇몇 작업에 대해서는 Java보다 빠르게 돌아가고, 메모리도 상당히
효율적으로 사용한다.
만약 상용 스크립트 언어를 원한다면,
SoftIntegration corporation ( http://www.softintegration.com ) 에서 'Ch scripting'을 보아라. Ch라 불리는 스크립트 언어 환경은 C를 포함하고, 높은 수준의 확장들과
C++을 비롯한 다른 언어들의 특징들을 포함한다. 따라서 한번 배우기만 하면
거의 모든 종류의 프로그래밍에 사용할 수 있다.
이 C호환 스크립트 언어 환경은 여러 플랫폼에서 한 프로그램을 이식가능하게
하는 중간 역할을 한다.
이식가능한 Ch 코드는 인터넷과 인트라넷을 통해 슈퍼컴퓨터부터 웍스테이션,
PC, 팜(Palm), PDA 를 비롯 컴퓨터의 범주에 속하지 않는 CNC 머신, 로봇,
TV, 냉장고 등 으로 퍼져 어디서나 안전하게 돌아갈 수 있다.
PHP는 웹문서를 처리하는 스크립트 언어로 매우 빠르게 진화했고, 객체지향을
지원한다. PHP는 'class'라는 키워드를 가지고 객체지향 스크립팅을 구현하고자 했다.
아마도 가까운 시일내에 PHP는 객체 지향 프로젝트를 위한 강력한 스크립트 언어로
빠르게 진화할 것이다. 가까운 미래에 PHP는 웹프로그래밍 뿐 아니라 일반적인
어플리케이션 프로그래밍에도 쓰이게 될 것이다.
웹과 일반 어플리케이션에 다른 언어를 쓰기 보다는 그냥 PHP만 쓰면 될 것이기
때문이다. PHP HOWTO :
http://www.linuxdoc.org/HOWTO/PHP-HOWTO.html ( 한글번역 .
Template 는 코드 재사용을 쉽게 만들어 generic 프로그래밍을 가능하게 하는 C++의 특징이다. 아래와 같은 간단한 예를 보자 :
#include <string>
#include <iostream>
void printstring(const std::string& str) {
std::cout << str << std::endl;
}
int main()
{
std::string str("Hello World");
printstring(str);
} |
printstring() 는 std::string
를 첫번째 인자로 받는다. 따라서 이는 오직 string만 프린트 할 수 있고,
문자배열(char array)을 프린트 하기 위해서는 함수를 오버로딩시키든가
새로운 이름의 함수를 만들어야 한다. 이는 함수의 구현이 중복되므로 좋지 않은 것이고,
유지보수하기가 힘들어지게 된다. template을 쓰면 우리는 코드를 재사용가능하게 만들 수 있다.
아래와 같은 함수를 보라 :
template<typename T>
void print(const T& var) {
std::cout << var << std::endl;
} |
컴파일러는 우리가 무슨 타입을 넘겨주든지 알아서 print
함수의 코드를 자동으로 만들어 줄 것이다.
이것이 template의 중요한 장점이다.
Java는 template이 없고, 따라서 Java에서의 generic 프로그래밍과 코드 재 사용은
더 힘들다. 레퍼런스 :
STL에 관한 다음 사이트들을 방문해보라 :
STL tutorials:
Main STL sites:
STL은 프로그래머에게 몇가지 유용한 데이터구조와 알고리즘을 제공한다.
이는 다음과 같은 것들이 있다.
컨테이너. 두 가지 타입이 있다 :
순차적(Sequential). 여기에는 vector, list, deque 등이 있다. 정렬된 조합(Associative). 여기에는 set, map, multiset, multimap 이 있다.
Iterator. 컨테이너의 내용을 살펴볼 수 있게 해주는 포인터 같은 것들이다. 일반적인(generic) 알고리즘들. STL은 컨테이너 타입에 대해 동작하는
여러가지 효과적으로 구현된 표준 알고리즘들
(예를들어 find, sort, merge 등)이 있다.
(몇몇 container들은 이 중 일부를 특별한 목적으로 멤버함수로 갖고 있다) Function obejct. function object는 operator()의 정의를 제공하는 class의 instance이다.
이는 이 object들을 함수 같이 사용할 수 있다는 것이다. Adaptors. STL은 다음과 같은 것들을 제공한다.
Allocators. 모든 STL 컨테이너 class는 프로그램이 사용하는 메모리 정보를 갖고 있기 위한
allocator class를 사용한다. 하지만 나는 이 부분은 생략할 것이다.
앞으로 vector, list, set 그리고 map 컨테이너의 사용법을 살펴볼 것이다.
이들을 사용하기 위해서는 내가 STL iterator에 대해 말할 수 있도록
iterator를 쓸 줄 알아야 할 것이다. 또 set과 map 컨테이너를 사용한다는 것은
내가 function object에 대해 뭔가 설명할 수 있도록 간단한 function object가
있어야 한다는 것이다.
STL이 지원하는 알고리즘에 대해서는 간단히 설명할 것이고, adoptor는
언급하지 않을 것이다. 몇몇 함수 인자의 타입에 대해서 이름이 바뀔 수 있다. 예를들어 대부분의 int
타입 인자들은 실제로는 size_type이라는 type을 갖고 이것이 적절한
기본 타입으로 tyepdef되는 형태에 의해 쓰인다. 만약 여러 함수들의 실제
인자 타입을 알고싶다면 작업하는 것에 대한 문서나 헤더파일을 참고해라. STL에서 제공되는 몇가지 유틸리티 class들이 있는데, 이 중 제일 중요한 것은
pair class이다. 이는 다음과 같이 정의되어있다.
template<class T1, class T2>
class pair {
public:
T1 first;
T2 second;
pair(const T1& a, const T2& b) : first(a), second(b) {}
}; |
그리고 쉽게 pair를 만들도록 다음과 같은 make_pair 함수가 제공된다 :
pair<T1,T2> make_pair(const T1& f, const T2&,s) |
또한 ==와 < 연산자도 있다. 이 template class에는 복잡한 것이 없고
그냥 사용하면 된다. 이를 이용하기 위해서는 #include 로 <utility>를
include하면 된다. pair는 여러곳에서 쓰일 수 있는데, 특히 set과 map class에서
많이 나타난다.
STL을 사용하기 위해서는 적절하게 헤더파일을 #include 해주어야 한다.
만약 컴파일러가 표준에 맞지 않는다면 약간 다를 수도 있지만,
표준에 맞는 컴파일러 (g++ 같은)는 다음과 같이 하면 된다 :
표준 C++ 라이브러리는 .h 를 뒤에 붙이지 않는 다는 것에
주의해라. 만약 옛버전의 혹은 좋지 않은 컴파일러를 사용하는데, 위와 같이 해서 include가
되지 않는다면 .h를 붙여서 시도해보아라.
하지만 그보다는 새로운 컴파일러를 구하는 게 더 나을 것이다.
컨테이너 class들은 서로 같은 이름을 갖는 멤버함수를 많이 갖는다.
이 함수들은 모든 class에 대해 똑같은 (혹은 매우 비슷한) 인터페이스를
제공한다 (그러나 물론 그 내부 구현은 다를 것이다). 아래의 표는
우리가 살펴볼 함수들을 나열한 것이다.
별표는 그 컨테이너 타입이 그 이름의 멤버 함수를 제공한다는 것이다.
표 2. 컨테이너 Class 인터페이스 | 연산자/함수명 | 목적 | vector | list | set | map | | == | 비교 | * | * | * | * | | < | 비교 | * | * | * | * | | begin | iterator | * | * | * | * | | | end | iterator | * | * | * | * | | size | 원소의 수 | * | * | * | * | | empty | 비었는지 | * | * | * | * | | front | 첫번째 원소 | * | * | � | � | | back | 마지막 원소 | * | * | � | � | | [ ] | 원소 접근 및 변경 | * | � | � | * | | | insert | 원소(들) 추가 | * | * | * | * | | push_back | 맨 뒤에 원소 추가 | * | * | � | � | | push_front | 맨 앞에 원소 추가 | � | * | � | � | | erase | 원소(들) 삭제 | * | * | * | * | | pop_back | 맨 뒤 원소 삭제 | * | * | � | � | | pop_front | 맨 앞 원소 삭제 | � | * | � | � | | | | |
만약 아래의 내용중 의문가는 부분이 있으면 (아마도 잇을 것이다),
조그만 테스트 프로그램을 하나 짜서 어떻게 돌아가는 지 알아볼 수 있을 것이다.
벡터는 C++의 배열과 비슷한, 하지만 이를 발전시킨 컨테이너이다.
특히, 벡터는 선언시에 얼마나 벡터가 커야할지를 알 필요가 없고,
push_back
함수를 이용하여 언제나 새로운 원소를 추가할 수 있다.
( 사실 insert
함수가 어디에든 새 원소들을 넣을 수 있게 해주지만, 이는 매우 비효율적이다.
만약 이를 자주 해야한다면 list를 대신 사용하는 것을 고려해보아라. )
벡터는 class template이므로, 선언시에 벡터가 갖게 될
객체의 타입을 선언해주어야 한다. 예를들어 다음과 같다.
vector<int> v1;
vector<string> v2;
vector<FiniteAutomaton> v3; |
위 내용은 v1을 int 값을 갖는 벡터로, v2를 string을 갖는 벡터로, v3를
FiniteAutomaton (아마도 미리 이런 타입이 선언되었을 것이다) 를 갖고 있는
벡터로 선언한다.
이 선언들은 벡터의 크기에 대해 전혀 알려주지 않고
( 구현에 따라 기본 벡터 사이즈가 있을 것이다. )
, 필요에 따라 얼마든지 늘려서 쓸 수 있다. 그러나 다음과 같이 선언함으로써 초기 크기를 정해줄 수도 있다.
이는 v4가 문자(char)의 벡터가 되고, 처음에는 26개의 글자를 가질 수 있다는 것이다.
또한, 벡터 안에 들어가는 수들을 초기화 하는 방법도 있는데, 이는 다음과 같다.
vector<float> v5(100,1.0); |
위 선언은 v5 가 100개의 1.0으로 초기화 된 실수값을
갖는 벡터임을 선언한다.
한번 벡터를 만든 후에는, size 함수를 써서 현재
벡터의 크기를 알아낼 수 있다.
이 함수는 아무 인자 없이 벡터에 들어있는 원소 수를 나타내는 integer를 리턴한다.
( 엄밀하게 말하자면
size_type 타입이 리턴되지만,
이것이 바로 integer로 바뀌어진다 )
그렇다면 다음의 작은 프로그램으로 무엇이 출력될까?
<vector-size.cpp>=
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v1;
vector<int> v2(10);
vector<int> v3(10,7);
cout << "v1.size() returns " << v1.size() << endl;
cout << "v2.size() returns " << v2.size() << endl;
cout << "v3.size() returns " << v3.size() << endl;
} |
벡터가 비었는지를 체크하기 위해서는, empty 함수를 쓰면 된다.
이것도 역시 아무 인자 없이 boolean 값을 리턴하는데, 비어있으면 true를,
비어있지 않으면 false를 리턴한다.
그렇다면 다음의 프로그램은 무엇을 프린트할까 (true는 1로, false는 0으로 프린트된다)?
<vector-empty.cpp>=
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v1;
vector<int> v2(10);
vector<int> v3(10,7);
cout << "v1.empty() has value " << v1.empty() << endl;
cout << "v2.empty() has value " << v2.empty() << endl;
cout << "v3.empty() has value " << v3.empty() << endl;
} |
벡터의 원소는 []연산자를 사용해서 접근할 수 있다. 따라서 모든
원소를 프린트하려면 다음과 같이 하면 된다.
vector<int> v;
// ...
for (int i=0; i<v.size(); i++)
cout << v[i]; |
(이는 원래의 배열을 사용하는 것과 매우 비슷하다). 또한, [] 연산자는 벡터 원소의 값을 바꾸기 위해서도 쓰일 수 있다.
vector<int> v;
// ...
for (int i=0; i<v.size(); i++)
v[i] = 2*i; |
front 함수는 벡터의 첫번째 원소를 리턴한다.
vector<char> v(10,'a');
// ...
char ch = v.front(); |
또한, front를 이용해서 첫번째 원소의 값을 바꿀 수도 있다.
vector<char> v(10,'a');
// ...
v.front() = 'b'; |
back 함수는 front와 같은 역할을 하지만, 벡터의 맨 마지막 원소를 리턴하는 것이
다르다.
vector<char> v(10,'z');
// ...
char last = v.back();
v.back() = 'a'; |
[]를 사용하는 간단한 예제를 보자.
<vector-access.cpp>=
#include <vector>
#include <iostream>
using namespace std;
int main()
{
vector<int> v1(5);
int x;
cout << "Enter 5 integers (seperated by spaces):" << endl;
for (int i=0; i<5; i++)
cin >> v1[i];
cout << "You entered:" << endl;
for (int i=0; i<5; i++)
cout << v1[i] << ' ';
cout << endl;
} |
위에 언급된 [] 외에도, 벡터의 원소에 접근하거나 바꿀 수 있는 방법이 몇가지 더 있다.
push_back은 새로운 원소를 벡터의 끝에 더할 것이다. pop_back은 벡터의 끝에서 원소를 하나 없앨 것이다. insert 는 하나 또는 여러개의 원소를 벡터의 원하는 위치에 삽입할 것이다. erase는 하나 또는 여러개의 원소를 원하는 위치에서 없앨 것이다.
그런데 insert나 erase는 벡터에서 오버헤드가 큰 연산임에 주의하라. 만약 insert나 erase를
써야한다면, 벡터 대신 list 데이터구조를 사용하는 것이 더 효율적일 것이다.
<vector-mod.cpp>=
#include <iostream>
#include <vector>
using namespace std;
int main()
{
vector<int> v;
for (int i=0; i<10; i++) v.push_back(i);
cout << "Vector initialised to:" << endl;
for (int i=0; i<10; i++) cout << v[i] << ' ' ;
cout << endl;
for (int i=0; i<3; i++) v.pop_back();
cout << "Vector length now: " << v.size() << endl;
cout << "It contains:" << endl;
for (int i=0; i<v.size(); i++) cout << v[i] << ' ';
cout << endl;
int a1[5];
for (int i=0; i<5; i++) a1[i] = 100;
v.insert(& v[3], & a1[0],& a1[3]);
cout << "Vector now contains:" << endl;
for (int i=0; i<v.size(); i++) cout << v[i] << ' ';
cout << endl;
v.erase(& v[4],& v[7]);
cout << "Vector now contains:" << endl;
for (int i=0; i<v.size(); i++) cout << v[i] << ' ';
cout << endl;
} |
위의 예에서는 벡터 v가 선언된 후, push_back을 사용하여 초기화 되었다.
그리고 pop_back으로 뒤의 몇 원소가 없어졌고,
배열이 하나 만들어져서 그 내용이 insert를 사용해서 v에 삽입되었다.
마지막으로 몇몇 원소들을 지우기 위해 erase가 사용되었다.
위에 사용된 함수들은 다음과 같은 인자들을 받는다.
위의 코드에 나와있듯이, pos가 가리키는 포지션 값은 원소가 삽입될 곳의 주소여야 한다.
마찬가지로 start와 end도 주소값이어야 한다. (사실 이것은 이들이 iterator이기 때문이다.
이에 대해서는 다음 장에서 더 살펴볼 것이다.)
벡터 v의 원소들을 차례대로 보는 가장 쉬운 방법은 위에 한 방법같이 하는 것이다.
|
