CString类

最新推荐文章于 2024-06-24 22:07:46 发布
最新推荐文章于 2024-06-24 22:07:46 发布
阅读量1.8k 收藏
点赞数
文章标签： system buffer delete destructor insert accessor
/* 
* 
*程序作者:harite
*Email:Harite.K@gmail.com
*程序名称:CString.h
*程序功能:CString类定义头文件
*程序说明:使用Editplus编写,Dev C++4.9.9.2&MinGW3.4.2与windows xp sp2下编译通过,不足之处请来信指出.
*Thank All The People
*/

#include <cstdio>
#include <cstring>
#include <iostream>

class CString
{
public:

/*声明构造函数 Begin*/
 CString();
 CString(const char *pStr);
 CString(CString &CStringSrc);
 CString(const char ch, const unsigned int uiRepeat = 1);
 CString(const char *pStr, unsigned int uiLen, unsigned int uiBegin = 0);
 CString(CString &CStringSrc, unsigned int uiLen, unsigned int uiBegin = 0);
 /*声明构造函数 End*/
 
 /*声明析构函数 Begin*/
 ~CString();
 /*声明析构函数 End*/

 /*声明成员函数 Begin*/
 unsigned int GetLength(void);
 char *GetBuffer(void);
 bool IsEmpty(void);
 void Empty(void);
 char GetAt(unsigned int uiIndex);
 void SetAt(unsigned int uiIndex, char ch);
 //用于比较的函数
 int Compare(const char *str);
 int Compare(CString &Str);
 int CompareNoCase(const char *str);
 int CompareNoCase(CString &Str);
 //字符串截取函数
 CString &Right(unsigned int uiLength);
 CString &Left(unsigned int uiLength);
 CString &Mid(unsigned int uiBegin);
 CString &Mid(unsigned int uiBegin, unsigned int uiLength);
 //大小转换函数
 CString &MakeUpper(void);
 CString &MakeLower(void);
 CString &MakeReverse(void);
 //字符串修饰(包括置换,删除,添加等)
 CString &Replace(char chOld, char chNew);
 CString &Replace(char *pOld, char *pNew);
 CString &Insert(unsigned int uiIndex, char ch);
 CString &Insert(unsigned int uiIndex, char *str);
 CString &Remove(char ch);
 CString &Delete(unsigned int uiIndex, unsigned int uiCount = 1);
 CString &TrimLeft(void);
 CString &TrimLeft(char ch);
 CString &TrimLeft(char *str);
 CString &TrimRight(void);
 CString &TrimRight(char ch);
 CString &TrimRight(char *str);
 //查找函数
 int Find(char ch, unsigned int uiBegin = 0);
 int Find(char *str, unsigned int uiBegin = 0);
 int ReverseFind(char ch);
 int FindOneOf(char *str);
 /*声明成员函数 End*/
 
 /*声明重载的操作符 Begin*/
 //作为成员函数
 CString& operator= (const char ch);
 CString&   operator= (const char *str);
 CString&   operator= (CString &Str);
 CString&     operator+=(const char ch);
 CString&   operator+=(const char *str);
 CString&   operator+=(CString &Str);
 const char& operator[](unsigned int n);
 //作为友元
 friend CString&operator+ (CString &Str1, CString &Str2);
 friend CString&operator+ (CString &Str, const char *str);
 friend CString&operator+ (const char *str, CString &Str);
 friend CString&operator+ (CString &Str, char ch);
 friend CString&operator+ (char ch, CString &Str);
 friend bool operator==(CString &Str1, CString &Str2);
 friend bool operator==(CString &Str, const char *str);
 friend bool operator==(const char *str, CString &Str);
 friend bool operator!=(const CString &Str, const CString &Str);
 friend bool operator!=(const CString &Str, const char *str);
 friend bool operator!=(const char *str, const CString &Str);
 friend bool operator< (const CString &Str1, const CString &Str2);
 friend bool operator< (const CString &Str, const char *str);
 friend bool operator< (const char *str, const CString &Str);
 friend bool operator> (const CString &Str1, const CString &Str2);
 friend bool operator> (const CString &Str, const char *str);
 friend bool operator> (const char *str, const CString &Str);
 friend bool operator<=(const CString &Str1, const CString &Str2);
 friend bool operator<=(const CString &Str, const char *str);
 friend bool operator<=(const char *str, const CString &Str);
 friend bool operator>=(const CString &Str1, const CString &Str2);
 friend bool operator>=(const CString &Str, const char *str);
 friend bool operator>=(const char *str, const CString &Str);
/*声明重载的操作符 End*/

private:

 char *pString; //指向存储空间的首地址
 CString &Trim(int mode, char ch);
};

/*声明重载的IO函数 Begin*/
std::ostream& operator<<(std::ostream &o, CString &Str);
std::istream& operator>>(std::istream &i, CString &Str);
/*声明重载的IO函数 End*/

219.149.12.*

3楼

/* 
* 
*程序作者:harite
*Email:Harite.K@gmail.com
*程序名称:CString.cpp
*程序功能:CString类实现文件
*程序说明:使用Editplus编写,Dev C++4.9.9.2&MinGW3.4.2与windows xp sp2下编译通过,不足之处请来信指出.
*Thank All The People
*/
#include "CString.h"

using namespace std;

/*定义构造函数 Begin*/

//无参构造函数,默认分配1个char的空间
CString::CString(){
pString = new char[1];
 pString[0] = '/0';
}

//以pStr所指向的字符串构造CString对象
CString::CString(const char *pStr){
pString = new char[strlen(pStr)+1];
strcpy(pString, pStr);
}

//以一个CString类构造新的CString对象
CString::CString(CString &CStringSrc){
pString = new char[CStringSrc.GetLength()+1];
strcpy(pString, CStringSrc.pString);
}

//以一个字符ch构造CString对象,uiRepeat为字符ch重复次数,省略这个参数使uiRepeat为1
CString::CString(const char ch, const unsigned int uiRepeat){
pString = new char[uiRepeat+1];
 int i;
 for(i=0; i<uiRepeat; i++)
 pString[i] = ch;

 pString[i] = '/0';
}

//以指针pStr所指向的字符串为基础,提取其中从uiBegin位置开始的uiLength个字符,用于构造CString对象
CString::CString(const char *pStr, //接受的字符串
 unsigned int uiLength, //接受的字符长度
 unsigned int uiBegin){ //接受的开始位置,默认为0,即从pStr的第一个空间开始复制
  unsigned int uiLen = strlen(pStr);

 if(uiBegin>uiLen)
 uiBegin = uiLen;
 if(uiLength>uiLen-uiBegin)
 uiLength = uiLen-uiBegin;

 pString = new char[uiLength+1];

 strncpy(pString, pStr+uiBegin, uiLength);
 pString[uiLength] = '/0';
}

//以一个CString对象为基础,提取其缓冲区中从uiBegin位置开始的uiLength个字符,用于构造新的CString对象
CString::CString(CString &CStringSrc, //接受的CString对象
 unsigned int uiLength, //接受的字符长度
 unsigned int uiBegin){ //接受的开始位置,默认为0,即从pStr的第一个空间开始复制
 unsigned int uiLen = CStringSrc.GetLength();

 if(uiBegin>uiLen)
 uiBegin = uiLen;
 if(uiLength>uiLen-uiBegin)
 uiLength = uiLen-uiBegin;

 pString = new char[uiLength+1];

 strncpy(pString, CStringSrc.pString+uiBegin, uiLength);
 pString[uiLength] = '/0';
}
/*定义构造函数 End*/

/*定义析构函数 Begin*/
//CString类的析构函数,删除所使用的缓冲区
CString::~CString(){
if(pString){
delete []pString;
}
}
/*定义析构函数 End*/

/*定义成员函数 Begin*/
//无参数,返回pString所指向的缓冲区的大小,不包括'/0'
unsigned int CString::GetLength(void){
 return strlen(pString);
}

//无参数,返回pString指针,主要用于重载<<操作符
char *CString::GetBuffer(void){
 return pString;
}

//无参数,判断pString所指向的缓冲区是否为空,为空则返回true,否则返回false
bool CString::IsEmpty(void){
return GetLength()?false:true;
}

//无参数,将pString所指向的字符串置空
void CString::Empty(void){
if(pString){
delete []pString;
}
pString = new char[1];
 pString[0] = '/0';
}

//接受一个索引值uiIndex,返回pString[uiIndex],若uiIndex越界,则返回pString[GetLength()]
char CString::GetAt(unsigned int uiIndex){
if(uiIndex>=GetLength()){
uiIndex = GetLength()-1;
}

return *(pString+uiIndex);
}

//接受一个索引值uiIndex,将pString[uiIndex]置为ch,若uiIndex越界,则将pString[GetLength()]置为ch

219.149.12.*

4楼

void CString::SetAt(unsigned int uiIndex, char ch){
if(uiIndex>=GetLength()){
uiIndex = GetLength()-1;
}

pString[uiIndex] = ch;
}

//用于字符串比较
//返回与指针str所指字符串比较之后的结果,相同返回0,小于返回-1,大于返回1
int CString::Compare(const char *str){
return strcmp(pString, str);
}

//返回与对象Str比较之后的结果,相同返回0,小于返回-1,大于返回1
int CString::Compare(CString &Str){
return strcmp(pString, Str.pString);
}

//返回与指针str所指字符串比较之后的结果(忽略大小写),相同返回0,小于返回-1,大于返回1
int CString::CompareNoCase(const char *str){
char *tmp1 = new char[GetLength()+1];
strcpy(tmp1, pString);
tmp1 = strlwr(tmp1);

char *tmp2 = new char[strlen(str)];
strcpy(tmp2, str);
tmp2 = strlwr(tmp2);

int n = strcmp(tmp1, tmp2);

delete tmp1;
delete tmp2;

return n;
}

//返回与对象Str比较之后的结果(忽略大小写),相同返回0,小于返回-1,大于返回1
int CString::CompareNoCase(CString &Str){
char *tmp1 = new char[GetLength()+1];
strcpy(tmp1, pString);
tmp1 = strlwr(tmp1);

char *tmp2 = new char[Str.GetLength()+1];
strcpy(tmp2, Str.pString);
tmp2 = strlwr(tmp2);

int n = strcmp(tmp1, tmp2);

delete tmp1;
delete tmp2;

return strcmp(tmp1, tmp2);
}

//从右测开始取当前对象字符串,长度为uiLength
CString &CString::Right(unsigned int uiLength)
{
if(uiLength>=GetLength()){
Mid(0, uiLength);
return *this;
}
 Mid(this->GetLength()-uiLength, uiLength);
 return *this;
}

//从左侧开始取当前对象字符串,长度为uiLength
CString &CString::Left(unsigned int uiLength)
{
 Mid(0, uiLength);
 return *this;
}

//从左侧索引uiBegin开始取当前对象字符串
CString &CString::Mid(unsigned int uiBegin){
Mid(uiBegin, GetLength());
 return *this;
}

//从左侧索引uiBegin开始取当前对象字符串,共取uiLength个
CString &CString::Mid(unsigned int uiBegin, unsigned int uiLength)
{
 int iLen = GetLength();

 if(uiBegin>iLen)
 uiBegin = iLen;
 if(uiLength>(iLen-uiBegin))
 uiLength = iLen-uiBegin;

 char *tmp = new char[uiLength+1];

 strncpy(tmp, pString+uiBegin, uiLength);
 tmp[uiLength] = '/0';

 delete pString;
 pString = tmp;
 return *this;
}

//将当前对象中的字符串全部置为大写
CString &CString::MakeUpper(void){
pString = strupr(pString);
return *this;
}

//将当前对象中的字符串全部置为小写
CString &CString::MakeLower(void){
pString = strlwr(pString);
return *this;
}

//将当前对象中的字符串倒置
CString &CString::MakeReverse(void){
pString = strrev(pString);
return *this;
}

//替换对象字符串中的字符chOld为chNew
CString &CString::Replace(char chOld, char chNew){
for(int i = 0;i<GetLength();i++){
 if(GetAt(i)==chOld){
 SetAt(i, chNew);
 }
 }
 return *this;
}

//替换对象字符串中的字符串pOld为pNew
CString &CString::Replace(char *pOld, char *pNew){
unsigned int uiTmp;
while(true){
 uiTmp = Find(pOld);
 if(uiTmp==-1){
 break;
 }
 Delete(uiTmp, strlen(pOld));
 Insert(uiTmp, pNew);
}
return *this;
}

//删除对象字符串中的字符ch
CString &CString::Remove(char ch){
bool flag;

219.149.12.*

5楼


do{
flag = false;
for(int i = 0;i<GetLength();i++){
if(GetAt(i)==ch){
 Delete(i);
 flag = true;
 }
 }
}while(flag);

return *this;
}

//删除对象字符串中从索引uiIndex开始共uiCount个字符
CString &CString::Delete(unsigned int uiIndex, unsigned int uiCount){
 unsigned int uiLen = GetLength();

 if(uiIndex>=uiLen){
 return *this;
 }
 if(uiCount==0){
 return *this;
 }
 
 if(uiCount>uiLen-uiIndex){
 uiCount = uiLen-uiIndex;
 }

 char *tmp = new char[uiLen-uiCount+1];

 strncpy(tmp, pString, uiIndex);
 tmp[uiIndex] = '/0';
 strcat(tmp, pString+uiIndex+uiCount);

 delete pString;
 pString = tmp;
 return *this;
}

//在对象字符串索引为uiIndex的地方插入字符串str
CString &CString::Insert(unsigned int uiIndex, char *str){
 unsigned int thisLen = GetLength();
 unsigned int uiLen = strlen(str);

 if(uiIndex > thisLen){
 uiIndex = thisLen;
 }

 char *tmp = new char[thisLen + uiLen + 1];

 strncpy(tmp, pString, uiIndex);
 tmp[uiIndex] = '/0';
 strcat(tmp, str);
 strcat(tmp, pString+uiIndex);

 delete pString;

 pString = tmp;
 return *this;
}

//在对象字符串索引为uiIndex的地方插入字符ch
CString &CString::Insert(unsigned int uiIndex, char ch){
unsigned int thisLen = GetLength();

 if(uiIndex > thisLen){
 uiIndex = thisLen;
 }

 char *tmp = new char[thisLen+1+1];

 strncpy(tmp, pString, uiIndex);
 tmp[uiIndex] = ch;
 tmp[uiIndex+1] = '/0';
 strcat(tmp, pString+uiIndex);

 delete pString;

 pString = tmp;
 return *this;
}

//在对象字符串中,从索引uiBegin开始,返回ch第一次出现的位置,省略uiBegin使其为默认的0,未找到返回-1
int CString::Find(char ch, unsigned int uiBegin){
unsigned int uiTmp;
char *tmp = strchr(pString+uiBegin, ch);
if(tmp==NULL){
return -1;
}
uiTmp = GetLength()-strlen(tmp);
delete tmp;
return uiTmp;
}

//在对象字符串中,从索引uiBegin开始,返回字符串str第一次出现的位置,省略uiBegin使其为默认的0,未找到返回-1
int CString::Find(char *str, unsigned int uiBegin){
unsigned int uiTmp;
char *tmp = strstr(pString+uiBegin, str);
if(tmp==NULL){
return -1;
}
uiTmp = GetLength()-strlen(tmp);
delete tmp;
return uiTmp;
}

//反向查找字符ch,并返回在其在对象字符串中的索引位置,未找到返回-1
int CString::ReverseFind(char ch){
CString tmp(*this);
tmp.MakeReverse();
if(Find(ch)==-1){
return -1;
}
return GetLength()-1-tmp.Find(ch);
}

//查找str所指向的字符串包含的字符,返回第一次出现的索引值,未找到返回-1
int CString::FindOneOf(char *str){
for(int i = 0;i<strlen(str);i++){
if(Find(str[i])==-1){
continue;
}else{
return Find(str[i]);
}
}

return -1;
}

//去除对象字符串左侧的字符ch
CString &CString::TrimLeft(char ch){
Trim(1, ch);
return *this;
}

//去除对象字符串左侧的换行,空格,制表字符
CString &CString::TrimLeft(void){
Trim(1, '/n');
Trim(1, ' ');
Trim(1, '/t');
return *this;
}

//去除对象字符串左侧的位于str所指向的字符串中的字符
CString &CString::TrimLeft(char *str){
for(int i = 0;i<strlen(str);i++){
Trim(1, str[i]);
}
return *this;
}


219.149.12.*

6楼

//去除对象字符串右侧的换行,空格,制表字符
CString &CString::TrimRight(void){
Trim(2, '/n');
Trim(2, ' ');
Trim(2, '/t');
return *this;
}

去除对象字符串右侧的字符ch
CString &CString::TrimRight(char ch){
Trim(2, ch);
return *this;
}

//去除对象字符串右侧的位于str所指向的字符串中的字符
CString &CString::TrimRight(char *str){
for(int i = 0;i<strlen(str);i++){
Trim(2, str[i]);
}
return *this;
}

//1代表LEFT,2代表RIGHT
CString &CString::Trim(int mode, char ch){
 unsigned int uiBegin = 0;
 unsigned int uiEnd = GetLength()-1;

 if(mode==1){
 while(pString[uiBegin]==ch && uiBegin<=uiEnd)
 uiBegin++;
 }else if(mode==2){
 while(pString[uiEnd]==ch && uiEnd>=uiBegin)
 uiEnd--;
 }else{
 return *this;
 }

 unsigned int uiLen = uiEnd-uiBegin+1;
 char *tmp = new char[uiLen+1];
 strncpy(tmp, pString+uiBegin, uiLen);
 tmp[uiLen] = '/0';

 delete pString;
 pString = tmp;
 return *this;
}
/*定义成员函数 End*/

/*定义重载的运算符 Begin*/
CString& CString::operator=(const char ch){
 if(pString){
 delete pString;
 }

 pString = new char[2];
 pString[0] = ch;
 pString[1] = '/0';

 return *this;
}

CString& CString::operator=(const char *str){
 if(pString){
 delete pString;
 }
 
 pString = new char[strlen(str)+1];
 strcpy(pString, str);
 
 return *this;
}

CString& CString::operator=(CString &Str){
 if(pString){
 delete pString;
 }
 
 pString = new char[Str.GetLength()+1];
 strcpy(pString, Str.pString);
 
 return *this;
}

CString& operator+(CString &Str, const char *str){
 CString *tmp = new CString(Str);
 *tmp += str;
 return *tmp;
}

CString& operator+(const char *str, CString& Str){
 CString *tmp = new CString(str);
 *tmp+=Str;
 return *tmp;
}

CString& operator+(CString &Str1, CString &Str2){
 CString *tmp = new CString(Str1);
 *tmp += Str2;
 return *tmp;
}

CString& operator+(CString &Str, char ch){
CString *tmp = new CString(Str);
*tmp+=ch;
return *tmp;
}

CString& operator+(char ch, CString &Str){
CString *tmp = new CString;
*tmp+=ch;
*tmp+=Str;
return *tmp;
}

CString& CString::operator+=(const char ch){
 char *tmp = pString;
 int thisLen = this->GetLength();

 pString = new char[thisLen + 2];

 strcpy(pString, tmp);
 pString[thisLen] = ch;
 pString[thisLen+1] = '/0';

 if(tmp){
 delete tmp;
 }

 return *this;
}

CString& CString::operator+=(const char *str){
 char *tmp = pString;

 pString = new char[strlen(tmp) + strlen(str) + 1];

 strcpy(pString, tmp);
 strcat(pString, str);

 if(tmp){
 delete tmp;
 }
 
 return *this;
}

CString& CString::operator+=(CString &Str){
 char *tmp = pString;
 pString = new char[strlen(tmp) + Str.GetLength() + 1];

 strcpy(pString, tmp);
 strcat(pString, Str.pString);

 if(tmp){
 delete tmp;
 }
 
 return *this;
}

const char &CString::operator[](unsigned int n){
 if(n>=GetLength())
 n = GetLength()-1;
 return *(pString + n);
}

bool operator==(CString &Str, const char *str){
 return strcmp(Str.pString, str)==0;
}

bool operator==(const char *str, CString &Str){
 return strcmp(str, Str.pString)==0;
}

bool operator==(CString &Str1, CString &Str2){
 return strcmp(Str1.pString, Str2.pString)==0;
}

bool operator!=(const CString &Str, const char *str){
 return strcmp(Str.pString, str)!=0;
}

bool operator!=(const char *str, const CString &Str){
 return strcmp(str, Str.pString)!=0;
}

bool operator!=(const CString &Str1, const CString &Str2){
 return strcmp(Str1.pString, Str2.pString)!=0;
}

bool operator<(const CString &Str, const char *str){
 return strcmp(Str.pString, str)<0;
}

bool operator<(const char *str, const CString &Str){
 return strcmp(str, Str.pString)<0;
}

bool operator<(const CString &Str1, const CString &Str2){
 return strcmp(Str1.pString, Str2.pString)<0;
}

bool operator>(const CString &Str, const char *str){
 return strcmp(Str.pString, str)>0;
}

bool operator>(const char *str, const CString &Str){
 return strcmp(str, Str.pString)>0;
}

bool operator>(const CString &Str1, const CString &Str2) {
 return strcmp(Str1.pString, Str2.pString)>0;
}

bool operator<=(const CString &Str, const char *str) {
 return strcmp(Str.pString, str)<=0;
}

bool operator<=(const char *str, const CString &Str){
 return strcmp(str, Str.pString)<=0;
}

bool operator<=(const CString &Str1, const CString &Str2){
 return strcmp(Str1.pString, Str2.pString)<=0;
}

bool operator>=(const CString &Str, const char *str){
 return strcmp(Str.pString, str)>=0;
}

bool operator>=(const char *str, const CString &Str){
 return strcmp(str, Str.pString)>=0;
}

bool operator>=(const CString &Str1, const CString &Str2){
 return strcmp(Str1.pString, Str2.pString)>=0;
}

//IO流
ostream& operator<<(ostream &o, CString &Str){
 return o<<Str.GetBuffer();
}

istream& operator>>(istream &i, CString &Str){
 char tmp[256];
 i>>tmp;
 Str = tmp;
 return i;
}

219.149.12.*

7楼

/* 
* 
*程序作者:harite
*Email:Harite.K@gmail.com
*程序名称:main.cpp
*程序功能:演示自己实现的这个CString类的使用方法
*程序说明:使用Editplus编写,Dev C++4.9.9.2&MinGW3.4.2与windows xp sp2下编译通过,不足之处请来信指出.
*Thank All The People
*/
#include <cstdlib>
#include <iostream>
#include "CString.h"

using namespace std;

int main(int argc, char *argv[])
{
 CString s1;
 CString s2("I am harite.");
 CString s3(s2);
 CString s4('x', 12);
 CString s5("houhou~~ I like Music.", 13, 9);
 CString s6(s2, 6, 5);
 cout<<"使用CString()构造函数"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 cout<<"使用字符串I am harite.构造对象"<<endl<<s2<<endl<<"长度为:"<<s2.GetLength()<<endl;
 system("PAUSE");
 cout<<"使用一个已经存在的对象s2构造新的对象"<<endl<<s3<<endl<<"长度为:"<<s3.GetLength()<<endl;
 system("PAUSE");
 cout<<"使用字符x重复12次构造对象"<<endl<<s4<<endl<<"长度为:"<<s4.GetLength()<<endl;
 system("PAUSE");
 cout<<"提取字符串houhou~~ I like Music.从第9个索引位置开始共13个字符来构造对象"<<endl<<s5<<endl<<"长度为:"<<s5.GetLength()<<endl;
 system("PAUSE");
 cout<<"提取已经存在的对象s2/""<<s2<<"/",从第5个索引位置开始共6个字符来构造新对象"<<endl<<s6<<endl<<"长度为:"<<s6.GetLength()<<endl;
 system("PAUSE");
 s1 = "!!!It is my life...";
 cout<<"将字符串!!!It is my life...付给对象s1"<<endl<<s1.GetBuffer()<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1+="It is a new day";
 cout<<"加上字符串/"It is a new day/""<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1+='e';
 cout<<"再加上一个字符e"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.Delete(19, 16);
 cout<<"从第19个索引开始删除16个字符"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 cout<<"取上面这个对象字符串的第9个字符"<<endl<<s1.GetAt(9)<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.SetAt(9, '^');
 cout<<"将这个字符变为^"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.TrimRight('.');
 cout<<"去掉其右侧的."<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.Remove('^');
 cout<<"删除^字符"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.Insert(9, 'm');
 cout<<"插入一个m字符"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.Right(13);
 cout<<"从右侧截取此对象13个字符"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.MakeUpper();
 cout<<"变为大写字符"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.MakeLower();
 cout<<"变为小写字符"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.Replace('i', 'I');
 cout<<"将i变为I"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 s1.Replace("Is", "is");
 s1.Replace("lIfe", "life");
 cout<<"将Is变为is,lIfe变为life"<<endl<<s1<<endl<<"长度为:"<<s1.GetLength()<<endl;
 system("PAUSE");
 CString tmp1(s1);
 CString tmp2(s1);
 CString tmp3(s1);
 tmp1.Left(2);
 tmp2.Mid(2, 4);
 tmp3.Right(7);
 cout<<"将上面那个对象所含有字符串分为3段"<<endl<<tmp1<<endl<<"长度为:"<<tmp1.GetLength()<<endl<<tmp2<<endl<<"长度为:"<<tmp2.GetLength()<<endl<<tmp3<<endl<<"长度为:"<<tmp3.GetLength()<<endl;
 system("PAUSE");
 CString tmp;
 tmp = tmp1+tmp2+tmp3;
 cout<<"将3个对象用+连接后在=给一个新对象"<<endl<<tmp<<endl<<"长度为:"<<tmp.GetLength()<<endl;
 system("PAUSE");
 tmp.Empty();
 cout<<"将新对象置空"<<endl<<tmp<<endl<<"长度为:"<<tmp.GetLength()<<endl;
 system("PAUSE");
 cout<<"输入一个字符串(别带空格^):";
 cin>>tmp;
 cout<<"你输入的字符串为"<<endl<<tmp<<endl<<"长度为:"<<tmp.GetLength()<<endl;
 tmp.MakeReverse();
 cout<<"将其反置后为"<<endl<<tmp<<endl<<"长度为:"<<tmp.GetLength()<<endl;
 system("PAUSE");
 tmp.MakeReverse();
 cout<<"正常显示为"<<endl<<tmp<<endl<<"长度为:"<<tmp.GetLength()<<endl;
 system("PAUSE");
 int n = tmp.Find("harite");
 if(n!=-1){
 cout<<"其中含有字符串/"harite/""<<endl;
 }else{
 cout<<"其中含有字符串/"harite/""<<endl;
 }
 system("PAUSE");
 cout<<"使用[]操作符循环显示字符串内容"<<endl;
 for(int i = 0;i<tmp.GetLength();i++){
 cout<<tmp[i]<<endl;
 }
 system("PAUSE");
 return EXIT_SUCCESS;
}
///

 

 

 

 

 

CSTRING类

[日期：2009-05-14]来源：中嵌信息  作者：chinaeda_news[字体：大 中 小]

CSTRING.H
// Dream House World Static Model
#ifndef __CSTRING__
#define __CSTRING__

#include <iostream.h>

class StringIndexOutOfBounds { };

class CSTRING
{
public:
CSTRING( const char *cstring = "" ); // Constructor
CSTRING( const CSTRING & str ); // Copy constructor
~CSTRING( ) // Destructor
{ delete [ ] buffer; }

const CSTRING & operator+= ( const int number ); // apend number
const CSTRING & operator= ( const CSTRING & rhs ); // Copy
const CSTRING & operator+=( const CSTRING & rhs ); // Append

const char *c_str( ) const // Return C-style CSTRING
{ return buffer; }
int length( ) const // Return CSTRING length
{ return strLength; }

char operator[]( int k ) const; // Accessor operator[]
char & operator[]( int k ); // Mutator operator[]

enum { MAX_LENGTH = 1024 }; // Maximum length for input CSTRING

private:
char *buffer; // storage for characters
int strLength; // length of CSTRING (# of characters)
int bufferLength; // capacity of buffer
};

ostream & operator<<( ostream & out, const CSTRING & str ); // Output
istream & operator>>( istream & in, CSTRING & str ); // Input
istream & getline( istream & in, CSTRING & str ); // Read line

bool operator==( const CSTRING & lhs, const CSTRING & rhs ); // Compare ==
bool operator!=( const CSTRING & lhs, const CSTRING & rhs ); // Compare !=
bool operator< ( const CSTRING & lhs, const CSTRING & rhs ); // Compare <
bool operator<=( const CSTRING & lhs, const CSTRING & rhs ); // Compare <=
bool operator> ( const CSTRING & lhs, const CSTRING & rhs ); // Compare >
bool operator>=( const CSTRING & lhs, const CSTRING & rhs ); // Compare >=

#endif // __CSTRING__

//CSTRING.CPP
// Dream House World Static Model
#include <string.h>
#include <stdio.h>
#include "CSTRING.h"


CSTRING::CSTRING( const char * cstring )
{
if( cstring == NULL )
cstring = "";
strLength = strlen( cstring );
bufferLength = strLength + 1;
buffer = new char[ bufferLength ];
strcpy( buffer, cstring );
}

CSTRING::CSTRING( const CSTRING & str )
{
strLength = str.length( );
bufferLength = strLength + 1;
buffer = new char[ bufferLength ];
strcpy( buffer,str.buffer );
}

const CSTRING & CSTRING::operator=( const CSTRING & rhs )
{
if( this != &rhs )
{
if( bufferLength < rhs.length( ) + 1 )
{
delete [ ] buffer;
bufferLength = rhs.length( ) + 1;
buffer = new char[ bufferLength ];
}
strLength = rhs.length( );
strcpy( buffer, rhs.buffer );
}
return *this;
}

const CSTRING & CSTRING::operator+=( const CSTRING & rhs )
{
if( this == &rhs )
{
CSTRING copy( rhs );
return *this += copy;
}

int newLength = length( ) + rhs.length( );
if( newLength >= bufferLength )
{
bufferLength = 2 * ( newLength + 1 );

char *oldBuffer = buffer;
buffer = new char[ bufferLength ];
strcpy( buffer, oldBuffer );
delete [ ] oldBuffer;
}

strcpy( buffer + length( ), rhs.buffer );
strLength = newLength;
return *this;
}

const CSTRING & CSTRING::operator+=(const int number)
{
char temp[20];
sprintf(temp,"%d",number);
CSTRING num( temp );
*this += num;
return *this;
}

char & CSTRING::operator[ ]( int k )
{
if( k < 0 || k >= strLength )
throw StringIndexOutOfBounds( );
return buffer[ k ];
}

char CSTRING::operator[ ]( int k ) const
{
if( k < 0 || k >= strLength )
throw StringIndexOutOfBounds( );
return buffer[ k ];
}

ostream & operator<<( ostream & out, const CSTRING & str )
{
return out << str.c_str();
}

istream & operator>>( istream & in, CSTRING & str )
{
char buf[ CSTRING::MAX_LENGTH + 1 ];
in >> buf;
if( !in.fail( ) )
str = buf;
return in;
}

istream & getline( istream & in, CSTRING & str )
{
char buf[ CSTRING::MAX_LENGTH + 1 ];
in.getline( buf, CSTRING::MAX_LENGTH );
if( !in.fail( ) )
str = buf;
return in;
}

bool operator==( const CSTRING & lhs, const CSTRING & rhs )
{
return strcmp( lhs.c_str( ), rhs.c_str( ) ) == 0;
}

bool operator!=( const CSTRING & lhs, const CSTRING & rhs )
{
return strcmp( lhs.c_str( ), rhs.c_str( ) ) != 0;
}

bool operator<( const CSTRING & lhs, const CSTRING & rhs )
{
return strcmp( lhs.c_str( ), rhs.c_str( ) ) < 0;
}

bool operator<=( const CSTRING & lhs, const CSTRING & rhs )
{
return strcmp( lhs.c_str( ), rhs.c_str( ) ) <= 0;
}

bool operator>( const CSTRING & lhs, const CSTRING & rhs )
{
return strcmp( lhs.c_str( ), rhs.c_str( ) ) > 0;
}

bool operator>=( const CSTRING & lhs, const CSTRING & rhs )
{
return strcmp( lhs.c_str( ), rhs.c_str( ) ) >= 0;
}
evgd2288
关注
MFC中CString类常用函数介绍
Veis的博客
04-10 1458
CString类的介绍（宽字符形式介绍） 文章目录CString类的介绍（宽字符形式介绍）1、CString类原型2、常见构造函数的使用3、AppendFormat函数4、Compare和CompareNoCase函数5、Delete函数6、Find函数7、FindOneOf函数8、Format函数9、GetEnvironmentVariable函数10、Insert函数11、Left、Right...
自定义CString类
热门推荐
yi_ming_he的博客
07-11 1万+
问题描述：自定义一个CString类，包括获取字符串长度，字符串查找，字符串比较，字符串取子串等都自己来实现。参考代码：MyString.h文件#pragma once#include <iostream> #include <assert.h> #include <stdarg.h>class CMyString { friend std::ostream& operator<< (std
标准c++实现CString类和TCHAR
qq_30625217的博客
11-21 1647
程序要从windows下移植到linux下，CFlie类还好说，用到的地方比较集中，统一改成fstream就好，最坑的就数这个CString类了，分布在各个文件中，只好实现一个CString类。代码主要借鉴了网上的代码不是我重头写的，借鉴了好几个，就不列出出处了，如果你发现是你的代码请告诉我，我加上出处，谢了先！还有TCHAR也比较难搞，网上有大神给出了实现，我就直接粘过来用了，一并谢过！ CSt...
MFC---CString类（MFC常用类）
Frank---7的博客
06-24 761
CString类作为MFC的常用类，当之无愧。可以这样说，只要是从事MFC开发，基本都会遇到使用CString类的场合。因为字符串的使用比较普遍，而CString类又提供了对字符串的便捷操作，所以它给MFC开发人员带来了高的开发效率，受到了开发者的欢迎。大家使用VS2010的话，可能会见到CStringT，实际上它是一个操作可变长度字符串的模板类。CStringT模板类有三个实例：CString、CStringA和CStringW，它们分别提供对TCHAR、char和wchar_t字符类型的字符串的操作。
CString类简介
《好好先生》专栏
11-23 590
CString类 1.CString::IsEmpty BOOL IsEmpty( ) const; 返回值：如果CString 对象的长度为0，则返回非零值；否则返回0。 说明：此成员函数用来测试一个CString 对象是否是空的。 示例： 下面的例子说明了如何使用CString::IsEmpty。 // CString::IsEmpty 示例 CString s; ASSE
6_1、MFC常用类：CString类
qingttqing的博客
06-22 909
CString类为MFC的常用类。CStringT，实际上它是一个操作可变长度字符串的模板类。CStringT模板类有三个实例：CString、CStringA和CStringW，，它们分别提供对TCHAR、char和wchar_t字符类型的字符串的操作。
MFC中CString类都有哪些成员函数，分别什么作用，如何使用它们？
学无止尽，谨言慎行！
03-15 928
CString类在 MFC（Microsoft Foundation Classes）中提供了丰富的成员函数来操作和处理字符串。以下是一些主要的CString。
vc++02：CString类
lafea的博客
01-25 128
文章目录初始化基本操作 初始化 #include <atlstr.h> // or //#include <afx.h> CString a; CString str1(_T("abc")); CString str2 = _T("defg"); TCHAR szBuf[] = _T("kkk"); //TCHAR *szBuf = _T("qqq"); // or CString str3(szBuf); CString str4 = szBuf; CString str7
CString类详细介绍
kevin685264的博客
03-09 8262
CString类背景介绍 这是本人第一次写csdn博客，如果有写得不好的地方请各位大佬帮忙指出不足之处，本人定会谦虚请教。众所周知，MFC(微软基础类库)是基于Windows界面开发的，它封装了大部分的Windows API(应用程序接口)函数,由C格式的函数升级为类库。而CString字符串类是MFC中比较常用的一个类，CString类里封装了很多对字符串操作的成员函数。接下来讲解该类的成员函数...
CString类的使用
11-19
基于提供的信息，我们可以深入探讨`CString`类在MFC（Microsoft Foundation Classes）中的应用及其重要性。`CString`是MFC框架中用于处理字符串的核心类之一，尤其在处理文本数据时，它为开发者提供了大量的便利。 ...
CString类实现
09-23
**标题：** CString类实现 **正文：** `CString` 类是Microsoft的MFC（Microsoft Foundation Classes）库中一个非常重要的字符串处理类，它为C++程序员提供了方便、高效的字符串操作功能。`CString` 类在许多...
自实现CString类
04-08
//无参的构造//有参构造之字符串定义对象//有参构造之对象定义对象//有参构造之定义N个相同字符对象//有参构造之字符串一部分定义对象//赋值之字符串赋值//赋值之对象赋值//重载+...以及一些比较好用的字符类函数的实现
字符串操作类CString 类
12-15
`CString`类是Microsoft Visual C++的一个非常重要的字符串处理类，它提供了丰富的字符串操作方法，类似于C++标准库中的`std::string`。这个类在Windows环境下被广泛使用，但描述中提到，这个版本的`CString`实现了...
rhino grasshoper 框内物体排列（附视频）.gh
最新发布
10-18
【闭合线内物体按方向移动/排列】https://www.bilibili.com/video/BV1z1WfeSEWu?vd_source=b420114c993138474d2e93d83ead77a5
kwant-1.4.3-cp38-cp38-win_amd64.whl
10-18
kwant-1.4.3-cp38-cp38-win_amd64.whl
rhino grasshoper 景观椅（附视频）.gh
10-18
【rhino@grasshoper 曲线金属座椅景观案例（文件获取/见简介）】https://www.bilibili.com/video/BV1Dx4y147Lr?vd_source=b420114c993138474d2e93d83ead77a5
PCIe通义万问系列文档的第一部已整理完毕，含999个PCIe相关问答
10-18
《PCIe通义万问》系列文档旨在记录PCIe相关行业工程师们在PCIe协议学习、IP设计验证、产品测试及使用过程中遇到的问题、迸发的思考、进行的探讨及可能的解决方案，以期给遇到相同相似问题的同行们些许启发。文档涉及的技术方向主要为PCIe，也包含PCIe相关的CXL、UCIe及计算机体系结构相关内容。 本文档是《PCIe通义万问》系列文档之（一），含999个问题。问题内容有以下三个来源：MangoPapa（下称博主）的“PCIe每日一问一答”系列专栏；博主的博文留言及私信讨论；博主作为群主的“PCIe技术交流群”群聊内容。MangoPapa小助理、折叠、先杰、CR小队长、kangling共同完成了问答内容提取与归纳整理，噫嘘唏及慕荷负责文辞优化及编辑排版，上述人员及MangoPapa、JasonW、皮塞阿姨、席可儿参与了文档内容的审校。感谢以上人员的无私奉献。 本文档仅对讨论内容进行总结记录，不保证问题答案的正确性，部分问题只提供解决思路或讨论过程。术业有专攻，文内定有偏颇。如您发现谬误，一敬希原宥，二望乞点拨；如您持异见，欢迎来信讨论。如有需要，欢迎联系MangoPapa加入相关
深度解析： CString类在Unicode与ANSI环境下的使用
2. ** CString类** `CString`类是ATL/MFC库中的一个核心组件，它提供了丰富的字符串操作方法，如拼接（Append）、查找（Find）、替换（Replace）等。`CString`对象可以像C风格的字符数组一样使用，但比它们更安全且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值