string类部分函数模拟实现
对于一些常用的string类的函数进行模拟实现，通过对一些函数的模拟是实现了解，其底层的实现原理，加深对于string 类中的函数的理解
构造函数
String(const char* str="")//使用缺省参数
27 :_str(new char[strlen(str)+1]) //预留一个位置放‘\0’
28 {
29 strcpy(_str,str); //直接拷贝
30 _size=strlen(str);
31 _capacity=_size;
32 }
析构函数
~String()//析构函数
34 {
35 delete[] _str;
36 _size=0;
37 _capacity=0;
38 }
拷贝构造
39 String(const String& s)//拷贝构造
40 :_str(nullptr),
41 _size(0),
42 _capacity(0)
43 {
44 String tmp(s._str);//创建一个临时变量
45 this->Swap(tmp); //通过实现的string类的Swap进行交换
46 }
47
赋值运算符重载
55 //赋值运算符重载
56 String& operator=(const String& s)
57 {
58 String tmp(s._str);
59 swap(_str,tmp._str);
60 _size=s._size;
61 _capacity=s._capacity;
62 return *this;
63 }
size()
返回字符串的有效字符长度，不包含’\0’
68 size_t size()
69 {
70 return _size;
71 }
capacity()
返回当前字符串有效容量，不含’\0’
_capacity(0)
43 {
44 String tmp(s._str);
45 this->Swap(tmp);
46 }
swap()
string类中的交换函数，交换两个string类对象
48 //string交换
49 void Swap(String& s)
50 {
51 swap(_str,s._str);
52 swap(_size,s._size);
53 swap(_capacity,s._capacity);
54 }
迭代器
string类中的迭代器，begin()于end()
typedef char* iterator;
17 typedef char* const_iterator;
18 iterator begin()
19 {
20 return _str;
21 }
22 iterator end()
23 {
24 return _str+_size;
25 }
c_str()
输出返回对象的字符串
const char* C_str()
65 {
66 return _str;
67 }
reserve()
增容，所增容量为n ,如果所给参数小于原容量，容量保持不变，否则增加指定长度的容量，不改变有效字符串的长度
void myString::String::Reserve(size_t n)
{
if(n>_capacity)
{
char* tmp=new char[n+1];
strcpy(tmp,_str);
delete[] _str;
_str=tmp;
_capacity=n;
_str[n+1]=0;
}
}
resize()
重新调整字符串的大小
void myString::String::Resize(size_t n,char s)
{
if(n<_size)
{
_str[n]=0; //如果目标值小于有效字符串长度直接截断字符串
}else if(n>_size&&n<_capacity||n>_capacity)
{
if(n>_capacity)
this->Reserve(n);
int pos=_size;
while(pos!=n)
{
_str[pos++]=s;
}
_str[pos]='\0';
}
}
push_back()
在结尾插入一个字符
void myString::String::Push_Back(char ch){
if(_size==_capacity)
this->Reserve(_capacity*2);
_str[_size++]=ch;
_str[_size]='\0';
}
append()
在结尾追加一个字符串
void myString::String::Append(const char* str){
int len=strlen(str);
if(_size+len>_capacity)
this->Reserve((_size+len)*2);
strcpy(_str+_size,str);
}
operator+=()
重载+=追加一个字符
myString::String& myString::String::operator+= (char ch){
this->Push_Back(ch); //复用之前实现好的函数
return *this;
}
重载+= 追加一个字符串
myString::String& myString::String::operator+= (const char* str){
this->Append(str);
return *this;
}
find()
从pos位置后开始查找一个字符，找到返回字符在字符串中的下标，找不到返回全局变量npos 也就是-1
size_t myString::String::Find(char ch,size_t pos){
if(pos>_size||pos<1)
return npos;
while(pos!=_size)
{
if(_str[pos]==ch)
return pos;
else pos++;
}
return npos;
}
查找一个字符串，从pos位置开始
返回 找到后的第一个字符的位置
size_t myString::String::Find(char* str ,size_t pos){
if(pos>_size||pos<1)
return npos;
int len=strlen(str);
int i=pos,j=0;
while(i!=_size)
{
int start=i;
while(j!=len&&_str[i]==str[j])
{
j++;
i++;
}
if(j==len)
break;
i=start+1;
j=0;
}
if(j=len&&i!=_size)
return i-len;
return npos;
}
insert()
在pos位置之后插入一个字符
void myString::String::Insert(size_t pos,char ch){
if(pos>=_size||pos<1)
perror("pos error");
if(_size==_capacity)
this->Reserve(_capacity*2);
int cur=_size;
while(cur!=pos-1)
{
_str[cur+1]=_str[cur];
cur--;
}
_size+=1;
_str[pos]=ch;
}
在pos位置后再插入一个字符串
void myString::String::Insert(size_t pos,char* str){
if(pos>=_size||pos<0)
perror("pos error");
int len=strlen(str);
if(_size+strlen(str)>_capacity)
this->Reserve((_size+len)*2);
_size+=len;
int cur = _size ;
while(cur!=pos-1)
{
_str[cur+len] = _str[cur];
cur--;
}
while(len--)
{
_str[pos++] = *str++;
}
}
erase()
从某一位置开始，删除指定长度的字符
如果删除长度超过
size_t myString::String::Erase(size_t pos, size_t len)
{
if(pos>_size || pos<0)
perror("pos error");
if(pos+len >= _size)
return npos;
int k = len;
while(k--)
{
_str[pos] = _str[pos+len];
pos++;
}
_str[pos]='\0';
_size-=len;
}
assign()
重新分配字符串
myString::String& myString::String::assign(char* str)
{
strcpy(_str,str);
_size=strlen(str);
}
operator<< 与 operator<<
输入输出的重载，因为要访问私有数据，out又要做左操作数，所以要将其声明为类的友元函数，在类外定义。
ostream& operator<<(ostream& out,myString::String& s)
134 {
135 out<<s._str;
136
W>137 }
138 istream& operator>>(istream& _cin ,myString::String& s)
139 {
140 _cin>>s._str; return _cin;
141
142 }
operator < 和 operator >