6. String.h ÆÄÀÏ

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_

6.1. StringBuffer.h

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_

6.2. StringTokenizer.h

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_