标准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);

}