对于命名空间std的string类，现在我们手动实现，了解string类运作的大致逻辑。
大体框架
现在对于string需要的成员函数以及成员变量，需要先列出来，方便后边的书写
cpp
namespace x
{
class string
{
public:
string(const char* str = "")
{}
string(const string& s);//拷贝构造
string& operator=(const string& s);//赋值拷贝
~string()
{}//析构
size_t capacity()const;//返回容量
size_t size()const;//返回此时大小
char& operator[](size_t pos);//返回指定位置的字符
const char& operator[](size_t pos)const
{}
void push_back(char ch);//尾插字符
void reserve(size_t n);//扩容
void append(const char* str);//增加字符串
string& operator+=(char ch);//增加字符
string& operator+=(const char* str);//增加字符串
void insert(size_t pos, char ch);//插入
bool operator<(const string& s)const//比较
{}
bool operator==(const string& s)const
{}
bool operator<=(const string& s)const
{}
bool operator>=(const string& s)const
{}
bool operator>(const string& s)const
{}
bool operator!=(const string& s)const
{}
void clear();
void erase(size_t pos, size_t len = npos);//消除指定位置的数据
string substr(size_t pos,size_t len=npos);
size_t find(const char* sub, size_t pos = 0);
size_t find(char ch, size_t pos=0);
void resize(size_t n, char ch = '\0');
private:
char* _str;
size_t _size;
size_t _capacity;
static const size_t npos = -1;
};
}初始化列表
cpp
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size + 1)
{
_str = new char[_capacity + 1];
strcpy(_str, str);//内容拷贝过去
}
~string()
{
delete[]_str;
_capacity = _size = 0;
_str = nullptr;
}//析构返回容量、大小
cpp
size_t capacity()const
{
return _capacity;
}//返回容量
size_t size()const
{
return _size;
}//返回此时大小返回指定位置的字符
cpp
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}//返回指定位置的字符
const char& operator[](size_t pos)const
{
assert(pos < _size);
return _str[pos];
}扩容，开辟空间
cpp
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];//留一个空位给' \0 '
strcpy(tmp, _str);
delete[]_str;//释放_str,将新定义好的tmp赋值给_str
_str = tmp;
_capacity = n;
}
}//扩容尾插字符/字符串
cpp
void push_back(char ch)
{
if (_size == _capacity)
{
reserve(_capacity = 0 ? 4 : 2 * _capacity);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}//尾插字符
void append(const char* str)
{
size_t n = strlen(str);
if (_size + n > _capacity)
{
reserve(_size + n);
}
strcpy(_str + _size, _str);//将原来的放入扩容的位置处
_size += n;
}//增加字符串清理
cpp
void clear()
{
_str[0] = '\0';
_size = 0;
}插入
cpp
void insert(size_t pos, char ch)
{
if (_size == _capacity)
{
reserve(_capacity = 0 ? 4 : 2 * _capacity);
}
int end = _size + 1;
for (int i = end; i > pos; i--)
{
_str[end] = _str[end - 1];
}
_str[pos] = ch;
++_size;
}//插入运算符重载运算
字符串直接增加
cpp
string& operator+=(char ch)
{
push_back(ch);
return *this;
}//增加字符
string& operator+=(const char* str)
{
append(str);
return *this;
}//增加字符串各种比较
cpp
bool operator<(const string& s)const//比较
{
return strcmp(_str, s._str)<0;
}
bool operator==(const string& s)const
{
return strcmp(_str, s._str) == 0;
}
bool operator<=(const string& s)const
{
return ( * this < s) || ( * this == s);
}
bool operator>=(const string& s)const
{
return !(*this < s);
}
bool operator>(const string& s)const
{
return !(*this <= s);
}
bool operator!=(const string& s)const
{
return !(*this == s);
}流插入/流提取
注意，这里为了能够多次流提取，就用get()函数------也就是getchar() 来读取空格
cpp
ostream& operator<<(ostream& out, const string& s)
{
for (int i = 0; i < s.size(); i++)
{
out << s[i];
}
return out;
}
istream& operator>>(istream& in, string& s)//流提取
{
s.clear();//先进行处理
char ch;
ch = in.get();//一个字符一个字符地拿
while (ch != ' ' && ch != '\n')
{
s += ch;//附上
ch = in.get();
}
return in;
}特定位置的数据清理
cpp
void erase(size_t pos,size_t len=npos)
{
assert(pos<_size);
if(len==npos||pos+len>_size)
{
_str[pos]='\0';
_size=pos;
}
else
{
size_t begin=pos+len;
whlie(begin<=_size)
{
_str[begin-len]=_str[begin];
++begin;
}
}
_size-=len;
}进行字符串的提取
cpp
string substr(size_t pos,size_t len=npos)
{
string s;
size_t end=pos+len;
if(len==npos||end>=_size)
{
len=_size-pos;//如果到末尾，那么取的字符就是剩下的全部
end=_size;//最后一个数据则直接取到末尾即可
}
s.reserve(len);
for(size_t i=pos;i<_size;i++)
{
s+=(_str[i]);
}
return s;
}查找函数
cpp
//查找字符
size_t find(char ch, size_t pos=0)
{
for(size_t i=0;i<_size;i++)
{
if(_str[i]==ch)
{
return i;//返回下标
}
}
return npos;
}
//字符串
size_t find(const char* sub, size_t pos = 0)
{
const char* p=strstr(_str,sub);//用ststr函数，恰好满足find函数的要求，kmp过于复杂
if(p)
{
return p-_str;
}
else
{
return npos;
}
}重新定义大小size
cpp
void resize(size_t n, char ch = '\0')
{
if(n<=_size)
{
_str[n]='\0';
}
else
{
reserve(n);
while(_size<n)//从_size一直到n都输入想要输入的字符
{
_str[_size]=ch;
++_size;
}
_str[_size]='\0';
}
}拷贝构造
cpp
//用一个交换函数来实现数据的交换，且为了不改变原对象，所以用一个中间载体来实现交换
void swap(string& s)
{
std::swap(_str,s._str);
std::swap(_size,s._size);
std::swap(_capacity,s,_capacity);
}
string(const string& s)
:_str(nullptr)
,_size(0)
,_capacity(0)
{
string tmp(s._str);
swap(tmp);
}赋值拷贝
cpp
string& operator=(const string& s)
{
if (this != &s)//异地拷贝，就是不共用同一个空间
{
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[]_str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}改进
对赋值拷贝改进
cpp
string& operator=(string tmp)//用形参接收要拷贝的对象
{
swap(tmp);//将中间载体与目标进行交换
return *this;//返回即可
}这样实现了定义了中间载体tmp的同时，用tmp接受了要拷贝的内容，然后直接进行交换，返回拷贝的对象。
对流提取的改进
我们知道，在进行流提取的时候，一旦内存满了，那我们就需要开辟空间，在输入初期需要多次重新开辟扩大空间，那有什么方法可以减少扩大空间的次数？------用一个数组作为暂时存放的缓冲器。
cpp
istream& operator>>(istream& in, string& s)//流提取
{
s.clear();//先进行处理
char buff[129];//用一个数组进行数据的传递和存放
size_t i = 0;
char ch;
ch = in.get();//一个字符一个字符地拿
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 128)//此时满了
{
buff[i] = '\0';
s += buff;
i == 0;//重置为0
}
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}