1.常见的面试的时候经常被问到有关string的实现过程，其中包括拷贝构造函数，赋值函数，以及析构函数等，本次如下实现过程加了几个运算符的重载过程。
class String{
friend ostream& operator<< (ostream&,String&);//重载<<运算符
friend istream& operator>> (istream&,String&);//重载>>运算符
public:
String(const char* ptr = NULL); //通配构造函数
String(const String& str); //拷贝构造函数
String & operator=(const String & str);//=复制函数
String & operator+=();//+=元素符重载
bool operator==();//==运算符重载
size_t size() const; //获取字符的长度
const char* c_str();//转化成c字符串
~String(); //析构函数
private:
char* data; //实际字符串内容
size_t length; //字符串的长度
};
//通用构造函数
String::String(const char* ptr){
if(!ptr){
data = new char[1];
*data = '\0';
length = 0;
}else{
length = strlen(ptr);
data = new char[length + 1];
strcpy(data,ptr);
}
}
//拷贝构造函数，需要进行深拷贝
//使用方法:String s2(s1); 使用s1来初始化s2，调用该拷贝构造函数进行深拷贝
String::String(const String& str)
{
if(!str.data){
data = '\0';
}else{
length = strlen(str.data);
data = new char[length + 1];
strcpy(data,str.data);
}
}
//赋值函数
String& String::operator=(const String & str)//赋值构造函数
{
if(this != &str){
length = strlen(str.data);
data = new char[length + 1];
strcpy(data,str.data);
}
return *this; //自己赋值自身，直接返回该对象即可
}
//累加运算符,需要使用辅助空间来中转存储
String& String::operator+=(const String& str) //+=元素符重载
{
length += strlen(str.data);
char* tmp = new char[length + 1];
strcpy(tmp,data);
strcat(tmp,str.data);
delete []data;
data = NULL;
data = tmp;
return *this;
}
//比较函数
bool String::operator==(const String& str)//==运算符重载
{
if(strlen(str.data) != strlen(data)){
return false;
}
return strcmp(str.data,data) == 0? true:false;
}
//+操作符,将两个st1+str2生成一个新的string对象
//str3 = str1 + str2;
String& String::operator+(const String& str)
{
String newstr;
newstr.length = length + strlen(str.data);
newstr.data = new char[newstr.length + 1]; //开辟一块新空间
strcpy(newstr.data,data);
strcat(newstr.data,str.data);
return newstr;
}
//[]重载运算符
char String::operator[](int n) const
{
if(n < 0 || n >= length){ //异常处理过程
return data[0];
}
if(data){
return data[n];
}
}
size_t String::size() const//获取字符的长度
{
return length;
}
const char* String::c_str()//转化成c字符串
{
return data;
}
//重载输出运算符
ostream& String::operator<< (ostream& os,String& str)//重载<<运算符
{
os<<str.data;
return os;
}
//重载输入运算符
istream& String::operator>> (istream& is ,String& str)//重载>>运算符
{
该用法是错误的is>>str.data;
//因为不能确定str.data和输入的字符串的大小
char tmp[1000] = {0};
is>>tmp;
str.length = strlen(tmp);
str.data = new char[str.length + 1];
strcpy(str.data,tmp);
return is;
}
String::~String() //析构函数
{
if(data){
delete []data;
data = NULL;
length = 0;
}
}
以上为string类的实现过程，
使用实例：
int main(int argc,char** argv){
String s1("ASDFGH"); //调用默认构造函数
cout<<"s1="<<s1.c_str()<<endl;
Striing s2 = s1; //复制函数
cout<<"s2 = "<<s2.c_str()<<endl;
String s3(s1)；//调用拷贝构造函数
cout<<"s3="<<s2.c_str()<<endl;
return 0;
}
输出结果：
s1=ASDFGH
s2=ASDFGH
s3=ASDFGH
#string中的剔除字符串的操作方法
#剔除字符串前后两段的空格
void tirm（std::string & str）{
if(!str.empty()){
str.erase(0,str.find_first_not_of(" "));
str.erase(str.find_last_not_of(" ") + 1);
}
}
删除所有的空格
void trimAllSpace(std::string & str){
if(!str.empty()){
int index = 0;
while((index = str.find(' ',index)) != std::string::npos){
str.erase(index,1);
}
}
}