標准C++實現字符串類CString

// String.cpp: implementation of the CString class.
//
//////////////////////////////////////////////////////////////////////

#include "String.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>

#if defined(WIN32)
#include <windows.h>
#elif defined(linux)
#elif defined(_AIX)
#include <extension.h>
#else
#endif
#ifdef _xlC
#include <strings.h>
#endif
#include "macros.h"
#include "String.h"
using namespace clib;

// constructors

// allocate buffers
CString::CString(int iBufferNum)
{
m_pBuffer = new char[iBufferNum * STR_PAGE_SIZE]; //動態申請內存
m_nLength = 0; //長度
m_nSize = iBufferNum * STR_PAGE_SIZE; //字符串大小初始化為iBufferNum個4*1024
m_pDataStart = m_pDataEnd = m_pBuffer; //開始字符串指針全部指向m_pBuffer
}

// new one character
CString::CString(char c, int iBufferNum) //參數為字符c和iBufferNum，構造函數
{
char data[2], len = 2;

data[0] = c; //將c放在字符數組首位
data[1] = 0; //將字符數組data第二位置為0
if (len > iBufferNum * STR_PAGE_SIZE) //如果iBufferNum個4*1024小於3
{
m_pBuffer = new char[len + 1]; //為字符串類的主要字符串m_pBuffer動態申請內存空間
m_nSize = len + 1; //字符串大小為3
}
else
{
m_pBuffer = new char[iBufferNum * STR_PAGE_SIZE]; //字符串申請內存空間
m_nSize = iBufferNum * STR_PAGE_SIZE;
}

// copy data and set total length
CreateFromData(data, len); //根據字符數組data開始創建對象m_pDataStart和m_pDataEnd
}
// copy data from a null terminated string
CString::CString(const char *data, int iBufferNum)
{
long len = strlen(data);

if (len > iBufferNum * STR_PAGE_SIZE) //字符串的大小大於制定數量個4*1024
{
m_pBuffer = new char[len + 1]; // 動態申請內存空間
m_nSize = len + 1;
}
else
{
m_pBuffer = new char[iBufferNum * STR_PAGE_SIZE];
m_nSize = iBufferNum * STR_PAGE_SIZE;
}

// copy data and set total length
CreateFromData(data, len); //根據字符數組data開始創建對象m_pDataStart和m_pDataEnd
}

// copy data from a binary data
CString::CString(const char *data, long len, int iBufferNum) //構造函數的參數為字符串
{
if (len > iBufferNum * STR_PAGE_SIZE) //如果字符串的大小大於制定數量個4*1024
{
m_pBuffer = new char[len + 1]; // 動態申請內存空間
m_nSize = len + 1;
}
else
{
m_pBuffer = new char[iBufferNum * STR_PAGE_SIZE];
m_nSize = iBufferNum * STR_PAGE_SIZE;
}

// copy data and set total length
CreateFromData(data, len); //根據字符數組data開始創建對象m_pDataStart和m_pDataEnd
}

// destructor
CString::~CString(void)
{
SafeDestroy();
}

// destroy allocated memory space and init all pointers
void CString::SafeDestroy(void)
{
SAFEDELETE(m_pBuffer);
// Important for InitPointers()
m_nSize = 0;
Empty();
}

void CString::Empty(void)
{
#ifdef WIN32
ZeroMemory(m_pBuffer, m_nSize);
#else // Linux, AIX
memset(m_pBuffer, 0, m_nSize);
#endif
m_pDataStart = m_pDataEnd = m_pBuffer; //將該字符串的頭指針和尾指針全部指向字符串的頭部
m_nLength = 0; //字符串長度置為0
}

char *CString::GetData(void) const //獲得指向該字符串的頭部指針
{
return m_pDataStart;
}

int CString::CreateFromData(const char *data, long len) //根據data和長度len創建對象
{

Empty(); //清空

if (len <= 0)
return TRUE;

if (data == NULL)
return TRUE;

// actually, it's impossible
if (len > m_nSize)
return FALSE;

// copy data and set length
memcpy(m_pDataStart, data, len); //將字符數組復制給m_pDataStart指向內存空間
m_nLength = len;
m_pDataStart[m_nLength] = '\0';
m_pDataEnd = &(m_pDataStart[m_nLength]); //取得尾指針m_pDataEnd

return TRUE;
}

long CString::GetLength(void) const
{
return m_nLength;
}

int CString::IsEmpty(void) const
{
return !m_nLength;
}

int CString::Grow(int iBufferNum)
{
//unsigned char *pNewSpace = NULL;

if (iBufferNum <= 0)
return 0;
AssignNewSpace(m_nSize + iBufferNum * STR_PAGE_SIZE, 1); //分配新的內存空間，變為原來的兩倍，移動1倍
return 1;
}

int CString::Append(const char *pSrc, int iLen)
{
int total_len;
char *pNewStart = NULL;

if (iLen <= 0)
return 0;

total_len = m_nLength + iLen; //append後的總的字符串長度

// if some space avaliable, defrag it firstly.
if (m_nSize > total_len) //如果原來總內存空間長度大於append後的字符串長度
{
//如果原來剩余空閒空間小於新添加子字符串的長度，而且
if (m_nSize - (m_pDataEnd - m_pBuffer) < iLen && m_pDataStart - m_pBuffer > 0) //而且m_pDataStart在m_pBuffer的後面
{
Defrag(); //調節原來的字符串
}
}
else //如果原來總內存空間長小於append後的字符串長度，需要開辟新空間
{
// allocate new memory space and copy orignal data
AssignNewSpace(total_len + 1, 1); //分配新的內存空間，變為原來的兩倍，移動1倍
}

// get the merge point
pNewStart = m_pDataEnd; //將原來字符串的末尾指針轉變成新添加子串的開始指針
if (!pNewStart)
return 0;

// copy data and adjust some pointers
memcpy(pNewStart, pSrc, iLen); //將新添加串pSrc放置在原來串聯的末尾
m_nLength = total_len; //字符串的總長度變化
m_pDataStart[m_nLength] = 0; //新的字符串最後以為置為0
m_pDataEnd = &(m_pDataStart[m_nLength]); //讓m_pDataEnd指向新的字符串的末尾指針

return 1;
}
void CString::Defrag(void)
{
// Sure! 重新初始化原來字符串頭指針m_pDataStart，指向頭部
memmove(m_pBuffer, m_pDataStart, m_nLength); //將m_pDataStart復制給m_pBuffer
// adjust those related pointers
m_pDataStart = m_pBuffer; //m_pDataStart指向m_pBuffer
m_pDataStart[m_nLength] = 0;
m_pDataEnd = &(m_pDataStart[m_nLength]); //重新獲得原來的字符串尾指針m_pDataEnd
}

// Append another CString to this one

int CString::Append(CString *pNewStr)
{
char *pNewStart = NULL, *pSrc = NULL, *pDest = NULL;

int len = pNewStr->GetLength(); //新添加子串的長度
int total_len;

if (len <= 0)
return 0;

// const char *
pSrc = pNewStr->GetData(); //獲得要添加的字符串的頭指針
if (!pSrc)
return 0;

total_len = m_nLength + len; //新字符串的總長度 = 原來字符串長度 + 添加字符串長度

// if some space avaliable, defrag it firstly.
if (m_nSize - (m_pDataEnd - m_pBuffer) < len && m_pDataStart - m_pBuffer > 0)
{
Defrag();
}

// allocate new memory space
AssignNewSpace(total_len + 1, 1); // //根據total_len分配新的內存空間
// get the merge point
pNewStart = m_pDataEnd; //將原來字符串的末尾指針轉變成新添加子串的開始指針
if (!pNewStart)
return 0;

// copy data and adjust some pointers
memcpy(pNewStart, pSrc, len); //將新添加串pSrc放置在原來串聯的末尾
m_nLength = total_len;
m_pDataStart[m_nLength] = 0;
m_pDataEnd = &(m_pDataStart[m_nLength]); //讓m_pDataEnd指向新的字符串的末尾指針

return 1;
}

// Adjust start and end pointer of its buffer

// Get one character at give position

char CString::GetAt(int nIndex) const
{
if (nIndex >= m_nLength)
return -1;
if (nIndex < 0)
return -1;

return m_pDataStart[nIndex];
}

// return single character at zero-based index
char CString::operator[](int nIndex) const
{
if (nIndex >= m_nLength)
return -1;

return m_pDataStart[nIndex];
}

// return pointer to const string
CString::operator LPCTSTR() const //將該字符串轉變為const char*字符串常量
{
return (const char*)m_pDataStart;
}

// duplicate a string
CString *CString::Duplicate(int iBufferNum) const
{
CString *pCStr = NULL;

pCStr = new CString(m_pDataStart, m_nLength, iBufferNum);

return pCStr;
}

// copy from another CString
const CString& CString::operator=(CString& stringSrc) //賦值操作符
{
long len = stringSrc.GetLength(); //取得stringSrc字符串長度

if (len >= m_nSize) //如果空間大小不夠
{
AssignNewSpace(len + 1, 0); // don't copy orignal data //將會申請一塊新的內存空間
}

// copy data and adjust pointers
Empty(); //清空
memcpy(m_pDataStart, stringSrc.GetData(), len); //將字符串stringSrc復制給新的m_pDataStart
m_pDataStart[len] = 0;
m_pDataEnd = &(m_pDataStart[len]); //獲得新的m_pDataEnd
m_nLength = len;

return *this;
}

// set string content to single character
CString &CString::operator=(char c) //賦值操作符，將字符賦給字符串
{
if (m_nSize < 2) // c + '\0' length //如果內存空間不足
{ // it needs to realloc space, but we use new and delete pair
SafeDestroy();
m_pBuffer = new char[2]; //重新申請內存
m_nSize = 2;
//TODO, I don't check the value of this pointer, unkown result. :)
}
m_pDataStart = m_pBuffer; //獲得頭指針
m_pDataStart[0] = c;
m_pDataStart[1] = 0;
m_pDataEnd = &(m_pDataStart[1]); //獲得尾指針
m_nLength = 1;

return *this;
}

// Set one character at give position

void CString::SetAt(long pos, char ch)
{
if (pos < m_nLength)
m_pDataStart[pos] = ch;

return;
}

// Get the string started from give position

void CString::GetManyChars(char *buf, long pos, long len) const
{
if (buf == NULL)
return;

if (pos >= m_nLength)
return;

if (pos + len > m_nLength)
len = m_nLength - pos;

if (len > 0)
memcpy(buf, m_pDataStart + pos, len); //將 m_pDataStart + pos開始長為len的子串復制給buf
}

// Compare itself with a new string, case-sensitive

int CString::Compare(const char *pNewStr) const
{
if (pNewStr == NULL)
return -1;

return strcmp(m_pDataStart, pNewStr);
}

// Compare itself with a new string, case-ignored
int CString::CompareNoCase(const char *pNewStr) const
{
if (pNewStr == NULL)
return -1;

#ifndef WIN32
return strcasecmp(m_pDataStart, pNewStr);
#else
return stricmp(m_pDataStart, pNewStr);
#endif
}

// find a character start from a give position
int CString::Find(int ch, long pos) const
{
char *p = NULL;

if (ch < 0)
return -1;

if (ch > UCHAR_MAX)
return -1;

if (pos < 0)
return -1;

if (pos >= m_nLength)
return -1;

p = (char*)memchr(m_pDataStart + pos, ch, m_nLength - pos);

if (!p)
return -1;
return p - m_pDataStart;
}

// find a string start from a give position
int CString::Find(const char *str, long pos) const
{
long len;
char *p = NULL;

if (str == NULL)
return -1;

len = strlen(str);


if (len == 0)
return 0;

p = (char *)strstr(m_pDataStart + pos, str);

if (p == NULL)
return -1;
else
return p - m_pDataStart;
}

char *CString::GetBuffer(int nMinBufLength) //獲得該字符串頭指針，並且說明返回的內存空間最小值
{
Defrag();
if (nMinBufLength > m_nLength)
AssignNewSpace(nMinBufLength, 1);
return m_pDataStart;
}

void CString::ReleaseBuffer(int nNewLength)
{
return;
}

//Extracts the left part of a string.
CString CString::Left(int count) const
{
if (count < 0)
count = 0;
if (count >= m_nLength)
return *this;

CString dest(m_pDataStart, count); //調用構造函數新建一個
return dest;
}

//Extracts the right part of a string.
CString CString::Right(int count) const
{
if (count < 0)
count = 0;
if (count >= m_nLength)
return *this;

CString dest(&(m_pDataStart[m_nLength - count]), count);
return dest;
}

//Converts all the characters in this string to uppercase characters.
void CString::MakeUpper(void)
{
strupr(m_pDataStart);
}

//Converts all the characters in this string to lowercase characters.
void CString::MakeLower(void)
{
strlwr(m_pDataStart);
}

// TODO: check the space left in the two pading of the whole buffer

// trim the left spaces
void CString::TrimLeft(void) // //將字符串右邊的空格去掉
{
int start = 0;

while (isspace(m_pDataStart[start]) && start < m_nLength)
start ++;

if (start > 0)
{
m_pDataStart += start;
}
}

// trim the right spaces
void CString::TrimRight(void) //將字符串右邊的空格去掉
{
int end = m_nLength - 1;

while (isspace(m_pDataStart[end]) && end >= 0)
end --;

if (end < 0)
{
end = 0;
m_pDataEnd = &(m_pDataStart[end]);
}
else
{
m_pDataEnd = &(m_pDataStart[end]);

}

}

// trim both sides
void CString::Trim(void) // //將字符串的空格去掉
{
TrimLeft();
TrimRight();
}

int CString::Replace(const char *lpszOld, const char *lpszNew)
{
// can't have empty or NULL lpszOld
if (!lpszOld)
return 0;
int nOldLen = strlen(lpszOld); //獲得舊字符串的長度
if (nOldLen <= 0)
return 0;
int nNewLen = strlen(lpszNew); //獲得新字符串的長度

// loop once to figure out the size of the result string
int nCount = 0;
char *lpszStart = m_pDataStart;
char *lpszEnd = m_pDataEnd;
char *lpszTarget;
while (lpszStart < lpszEnd) //循環處理原有字符串
{
while ((lpszTarget = strstr(lpszStart, lpszOld)) != NULL) //如果在字符串lpszStart中發現子串lpszOld
{
nCount++; //子串數量+1
lpszStart = lpszTarget + nOldLen; //往後定位字符串lpszStart，從第一個子串後開始
}
lpszStart += strlen(lpszStart) + 1; //往後查找
}

// if any changes were made, make them
if (nCount > 0) //如果有重復的字符串
{
// allocate a new buffer (slow but sure)
int nNewLength = m_nLength + (nNewLen - nOldLen) * nCount; //覆蓋後總字符串的大小
AssignNewSpace(nNewLength + 1, 1); //為新的字符串分配內存空間
// then we just do it in-place
lpszStart = m_pDataStart; //重新初始化m_pDataStart，lpszStart，lpszEnd
lpszEnd = m_pDataEnd;

// loop again to actually do the work
while (lpszStart < lpszEnd) //循環處理原來的字符串
{
while ( (lpszTarget = strstr(lpszStart, lpszOld)) != NULL) //如果在字符串lpszStart中發現子串lpszOld
{
int nBalance = lpszEnd - (lpszTarget + nOldLen); //字符串lpszTarget後面的字符數量
memmove(lpszTarget + nNewLen, lpszTarget + nOldLen,
nBalance * sizeof(char)); //移走lpszTarget原來的字符串，並為lpszTarget重新設置為nNewLen大小內存
memcpy(lpszTarget, lpszNew, nNewLen * sizeof(char)); //將新字符串lpszNew覆蓋舊的子串lpszTarget
lpszStart = lpszTarget + nNewLen; //尋找目標字符串後移nNewLen
lpszStart[nBalance] = '\0';
}
lpszStart += strlen(lpszStart) + 1; //尋找目標字符串往後走
}
m_nLength = nNewLength;
}

return nCount;
}

// format a string
void CString::Format(char *fmt, ...)
{
char TmpBuffer[STR_PAGE_SIZE]; // TODO, should calculate this size dynamically.

va_list argList;
va_start(argList, fmt);
#ifdef WIN32
_vsnprintf(TmpBuffer, STR_PAGE_SIZE, fmt, argList); // just not overwrite something
#else
vsnprintf(TmpBuffer, STR_PAGE_SIZE, fmt, argList); // just not overwrite something
#endif
va_end(argList);
}

// copy string content from ANSI string (converts to TCHAR)
const CString& CString::operator=(const char *lpsz)
{
int len = strlen(lpsz);

if (m_nSize < len) // c + '\0' length
{ // it needs to realloc space, but we use new and delete pair
SafeDestroy();
m_pBuffer = new char[len + 1];
m_nSize = len + 1;
//TODO, I don't check the value of this pointer, unkown result. :)
}
m_pDataStart = m_pBuffer;
strcpy((char *)m_pDataStart, lpsz);
m_pDataStart[len] = 0;
m_pDataEnd = &(m_pDataStart[len]);
m_nLength = len;

return *this;
}

// concatenate a UNICODE character after converting it to TCHAR
const CString& CString::operator+=(const char *lpsz)
{
int len = strlen(lpsz);

if (m_nSize < m_nLength + len + 1)
{
AssignNewSpace(m_nLength + len + 1, 1); // allocate new space and move orignal data
}
Defrag();
memcpy(m_pDataEnd, lpsz, len);
m_pDataEnd += len;
*m_pDataEnd = 0;

return *this;
}

// concatenate a single character
const CString& CString::operator+=(char ch)
{
if (m_nSize < m_nLength + 1 + 1)
{
AssignNewSpace(m_nLength + 1 + 1, 1); // allocate new space and move orignal data
}
Defrag();
memcpy(m_pDataEnd, &ch, 1);
m_pDataEnd += 1;
*m_pDataEnd = 0;

return *this;
}

// concatenate from another CString
const CString& CString::operator+=(CString& string)
{
if (m_nSize < m_nLength + string.GetLength() + 1)
{
AssignNewSpace(m_nLength + string.GetLength() + 1, 1); // allocate new space and move orignal data
}
Defrag();
memcpy(m_pDataEnd, string.GetData(), string.GetLength());
m_pDataEnd += string.GetLength();
*m_pDataEnd = 0;

return *this;
}

void CString::AssignNewSpace(int iNewTotalSize, int iNeedMove)
{
char *pNewSpace = NULL; //新的字符串指針，初始化NULL

if (iNewTotalSize <= m_nSize) //確保新的內存空間大於原來的內存空間
return ;

// allocate new space
pNewSpace = new char [iNewTotalSize]; //pNewSpace動態申請內存空間
if (pNewSpace == NULL)
return ;

if (iNeedMove)
{
memcpy(pNewSpace, m_pDataStart, m_nLength + 1); //將原有字符串復制給新申請內存
}
SAFEDELETE(m_pBuffer); //安全刪除原有的字符串m_pBuffer
m_pBuffer = pNewSpace;
m_pDataStart = m_pBuffer;
m_pDataEnd = &(m_pDataStart[m_nLength]); //重置m_pBuffer，m_pDataStart，m_pDataEnd

// adjust new size
m_nSize = iNewTotalSize;
}

//////////////////////////////////////////////////////////////////////////////
// concatenation

// NOTE: "operator+" is done as friend functions for simplicity
// There are three variants:
// CString + CString
// and for ? = TCHAR, LPCTSTR
// CString + ?
// ? + CString
void CString::ConcatCopy(const char *str1, int nSrc1Len, const char *str2, int nSrc2Len)
{
int nNewLen = nSrc1Len + nSrc2Len;

AssignNewSpace(nNewLen + 1, 0);

// append two string
Append(str1, nSrc1Len);
Append(str2, nSrc2Len);
}

// friend methods
// Class + Class
CString operator+(const CString& string1, const CString& string2)
{
CString s;

s.ConcatCopy(string1.GetData(), string1.GetLength(), string2.GetData(), string2.GetLength());
return s;
}

// Class + char
CString operator+(const CString& string, char ch)
{
CString s;
char str[2];

str[0] = ch;
str[1] = 0;
s.ConcatCopy(string.GetData(), string.GetLength(), str, 1);

return s;
}

// char + Class
CString operator+(char ch, const CString& string)
{
CString s;
char str[2];

str[0] = ch;
str[1] = 0;
s.ConcatCopy(string.GetData(), string.GetLength(), str, 1);

return s;
}

// Class + char *
CString operator+(const CString& string, const char *lpsz)
{
CString s;

s.ConcatCopy(string.GetData(), string.GetLength(), lpsz, strlen(lpsz));

return s;
}

// char * + Class
CString operator+(const char *lpsz, const CString& string)
{
CString s;

s.ConcatCopy(string.GetData(), string.GetLength(), lpsz, strlen(lpsz));

return s;
}

// Compare operators
bool operator==(const CString& s1, const CString& s2)
{
return (s1.Compare(s2.GetData()) == 0);
}
bool operator==(const CString& s1, const char* s2)
{
return (s1.Compare(s2) == 0);
}
bool operator==(const char* s1, const CString& s2)
{
return (s2.Compare(s1) == 0);
}

bool operator!=(const CString& s1, const CString& s2)
{
return (s1.Compare(s2.GetData()) != 0);
}
bool operator!=(const CString& s1, const char* s2)
{
return (s1.Compare(s2) != 0);
}
bool operator!=(const char* s1, const CString& s2)
{
return (s2.Compare(s1) != 0);
}

bool operator>(const CString& s1, const CString& s2)
{
return (s1.Compare(s2.GetData()) > 0);
}
bool operator>(const CString& s1, const char* s2)
{
return (s1.Compare(s2) > 0);
}
bool operator>(const char* s1, const CString& s2)
{
return (s2.Compare(s1) < 0);
}

bool operator<(const CString& s1, const CString& s2)
{
return (s1.Compare(s2.GetData()) < 0);
}
bool operator<(const CString& s1, const char* s2)
{
return (s1.Compare(s2) < 0);
}
bool operator<(const char* s1, const CString& s2)
{
return (s2.Compare(s1) > 0);
}

bool operator>=(const CString& s1, const CString& s2)
{
return (s1.Compare(s2.GetData()) >= 0);
}
bool operator>=(const CString& s1, const char* s2)
{
return (s1.Compare(s2) >= 0);
}
bool operator>=(const char* s1, const CString& s2)
{
return (s2.Compare(s1) <= 0);
}

bool operator<=(const CString& s1, const CString& s2)
{
return (s1.Compare(s2.GetData()) <= 0);
}
bool operator<=(const CString& s1, const char* s2)
{
return (s1.Compare(s2) <= 0);
}
bool operator<=(const char* s1, const CString& s2)
{
return (s2.Compare(s1) >= 0);
}