C++中string的模拟实现

c++中的string类可以实现字符串对象的一系列操作，如下图就是从cplusplus上截取的string的一部分功能：

接下来我就简单模拟几个函数实现 

首先，我们要给出完整的string类，包括构造函数，析构函数，私有成员char* str 

并且在类内声明要实现的函数（本文我只实现了operator=，operator[ ]，pushback(),以及三个operator+=，五个insert等） 

#include<iostream>
#include<cstring>
using namespace std;
class String
{
friend ostream& operator<< (ostream& os,String& s);
public:
String(const char* str = "") //构造函数
:_sz(strlen(str))
,_capacity(strlen(str)+1)
,_str(new char[strlen(str)+1])
{
cout<<"String(const char* str)"<<endl;
strcpy(_str,str);
}
String(const String& s) //拷贝构造
:_sz(s._sz)
,_capacity(strlen(s._str)+1)
,_str(new char[strlen(s._str)+1])
{
cout<<"String(const String& s)"<<endl;
strcpy(_str,s._str);
}
~String()
{
cout<<"~String()"<<endl;
if(*_str != NULL)
{
delete[] _str;
_str = NULL;
_sz = 0;
_capacity = 0;
}
}
String& operator= (const String& s);
//String& operator= (const String& s);
char& operator[] (int index);
void Push_Back(char c);
String& operator+= ( const String& str );
String& operator+= ( const char* s );
String& operator+= ( char c );
String& insert ( size_t pos, const String& str );
String& insert ( size_t pos1, const String& str, size_t pos2, size_t n );
String& insert ( size_t pos, const char* s, size_t n);
String& insert ( size_t pos, const char* s );
String& insert ( size_t pos, size_t n, char c );
private:
char* _str;
int _sz;
int _capacity;
};

分别在类外实现各功能：

1. operator= 

用一个已知对象给一个新对象赋值（效果与拷贝构造相同，但实现不同）：实现这个运算符重载应该注意的是判断两个对象是否相等，并且参数与返回值是引用类型会提高效率 

String& String::operator= (const String& s)
{
if(this != &s) //判断两个对象是否相等
{
delete[] _str;
_str = new char[strlen(s._str)+1];
strcpy(_str,s._str);
_sz = s._sz;
_capacity = s._capacity;
}
return *this;
}

赋值运算符重载还有一种比较简单的做法，即直接交换两个对象的字符串指针即可

String& String::operator= (const String& s)
{
std::swap(_str,s._str);
return *this;
}

2. operator[ ]

重载数组坐标[ ]是比较简单的，直接返回该对象的坐标即可

char& String::operator[] (int index)
{
return _str[index];
}
//由于_str是指向该字符串的指针，_str[ index ]是对下标为index的字符的解引用，所以返回值类型为char

3. Push_Back()

要在字符数组尾部插入一个元素，那就一定要先想到容量的问题，因此需要定义两个成员_sz,_capacity，_sz标记当前容量，_capacity表示每次扩大容量的个数，其次就可以用一个CheckCapacity()函数来解决容量问题，包括检测与增容。由于该函数是在用的时候自动检测，所以不需要被外部使用者知道，因此可以将此函数在类内声明为私有 

private:
void CheckCapacity(int count)
{
if(_sz+count >= _capacity)
{
int newCapacity = 2*_capacity > (_capacity + count) ? 2*_capacity : (_capacity+count);
char* temp = new char[newCapacity];
strcpy(temp,_str);
delete[] _str;
_str = temp;
_capacity = newCapacity;
}
}

解决了容量的问题，接下来就可以插入了，只需将字符插入到最后一个位置并加上'\0'就ok了

void String::Push_Back(char c)
{
CheckCapacity(1);
_str[_sz++] = c;
_str[_sz] = '\0';
}

4. operator+=

例：

string str1("abcdef");
string str2("123456");
str1 += str2;  ------------>>abcdef123456
str1 += "123456";---------->>abcdef123456
str1 += 'L';  ----------->>abcdefL

如果是字符串，就可以用strcat函数将其追加在前一个字符串后边；如果是一个字符，处理方法类似于Push_Back
 

String& String::operator+= ( const String& str )
{
CheckCapacity(strlen(str._str));
strcat(_str,str._str);
_sz += strlen(str._str);
_str[_sz] = '\0';
return *this;
}
String& String::operator+= ( const char* s )
{
CheckCapacity(strlen(s));
strcat(_str,s);
_sz += strlen(s);
_str[_sz] = '\0';
return *this;
}
String& String::operator+= ( char c )
{
CheckCapacity(1);
_str[_sz++] = c;
_str[_sz] = '\0';
return *this;
}

5. insert

例： 

string str1("12345");
string str2("abcde");
//String& insert ( size_t pos, const String& str );
str1.insert(3,str2); ------>> 12abcde345
//String& insert ( size_t pos1, const String& str, size_t pos2, size_t n );
str1.insert(2,str2,3,2);----->>1cd2345
//String& insert ( size_t pos, const char* s, size_t n);
str1.insert(2,"abcdef",3);----->>1abc2345
//String& insert ( size_t pos, const char* s );
str1.insert(4,"abc");----->>123abc45
//String& insert ( size_t pos, size_t n, char c );
str1.insert(2,5,'c');------>>1ccccc2345
String& String::insert ( size_t pos, const String& str )
{
if((pos>0) && (pos<=strlen(_str))) //判断pos是否合理
{
CheckCapacity(strlen(str._str));
char* tmp = new char[strlen(_str)-pos+2];
strcpy(tmp,_str+pos-1); //保存_str的pos位及之后的内容
//我们可以利用strcat函数来追加一个字符串，但前提是必须使前一个字符串（str1）以'\0'结尾
_str[pos-1] = '\0';
strcat(_str,str._str);
strcat(_str,tmp);
_sz += strlen(str._str);
_str[_sz] = '\0';
delete[] tmp;
}
return *this;
}
String& String::insert ( size_t pos1, const String& str, size_t pos2, size_t n )
{
if((pos1>0) && (pos1<=strlen(_str))) //判断pos1是否合理
{
if((pos2>0) && (pos2<=strlen(str._str))) //判断pos2是否合理
{
if((n>0) && (n<=strlen(str._str)-pos2)) //检测n是否合理
{
CheckCapacity(n);
char* tmp = new char[strlen(_str)-pos1+2];
strcpy(tmp,_str+pos1-1); //保存_str的pos1位及之后的内容
_str[pos1-1] = '\0';
strncat(_str,str._str+pos2-1,n);
strcat(_str,tmp);
_sz += strlen(str._str);
_str[_sz] = '\0';
delete[] tmp;
}
}
}
return *this;
}
String& String::insert ( size_t pos, const char* s, size_t n)
{
if((pos>0) && (pos<=strlen(_str))) //判断pos是否合理
{
CheckCapacity(n);
char* tmp = new char[strlen(_str)-pos+2];
strcpy(tmp,_str+pos-1); //保存_str的pos位及之后的内容
_str[pos-1] = '\0';
strncat(_str,s,n);
strcat(_str,tmp);
_sz += strlen(s);
_str[_sz] = '\0';
delete[] tmp;
}
return *this;
}
String& String::insert ( size_t pos, const char* s )
{
if((pos>0) && (pos<=strlen(_str))) //判断pos是否合理
{
CheckCapacity(strlen(s));
char* tmp = new char[strlen(_str)-pos+2];
strcpy(tmp,_str+pos-1); //保存_str的pos位及之后的内容
_str[pos-1] = '\0';
strcat(_str,s);
strcat(_str,tmp);
_sz += strlen(s);
_str[_sz] = '\0';
delete[] tmp;
}
return *this;
}
String& String::insert ( size_t pos, size_t n, char c )
{
if((pos>0) && (pos<=strlen(_str))) //判断pos是否合理
{
CheckCapacity(n);
int i = 1;
char* tmp = new char[strlen(_str)-pos+2];
strcpy(tmp,_str+pos-1);//2345
//_str[pos-1] = '\0';
for(i=1; i<=n; i++)
{
_str[i] = c;
}
_str[i] = '\0';
strcat(_str,tmp);
_sz += n;
_str[_sz] = '\0';
delete[] tmp;
}
return *this;
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

• 使用C++中string实现任意长度的正小数、整数之间加减法方法实例
• C++中将string类型转化为int类型
• C++中stringstream的用法和实例
• C++ string 字符串查找匹配实例代码
• 使用C++的string实现高精度加法运算的实例代码
• 从string类的实现看C++类的四大函数(面试常见)
• 详解C++中String类模拟实现以及深拷贝浅拷贝