string类模拟实现
前言：今天我们用C++实现一个增删查改的string类
1.构造，拷贝构造，析构
定义私有成员变量：
private:
char* _str;
size_t _size; //已经有多少个有效字符
size_t _capacity; //能存多少个有效字符
static size_t npos;1.1实现构造函数
string(const char* str="")
{
_size = strlen(str);
_capacity = _size; // '\0'不是有效字符
_str = new char[_capacity + 1];
strcpy(_str, str);
}
//string(const char* str = "\0") 错误示范
//string(const char* str = nullptr) 错误示范1.2 拷贝构造
深浅拷贝问题
浅拷贝，也称值拷贝，编译器只是将对象中的值拷贝过来，会出现多个对象共用同一份资源，当一个对象将那份空间释放掉，另一个对象不知道的时候会出现错误访问。
浅拷贝的问题：1.同一块空间会被析构两次 2.其中一个修改数据会影响另一个
string(const string& s)
:_str(new char[strlen(s._str)+1])
,_size(0)
,_capacity(0)
{
strcpy(_str,s._str);
_size = s._size;
_capacity = s._capacity;
}1.3 析构函数
~string()
{
delete[] _str;
_str = nullptr; //释放后记得置空
_capacity = _size = 0;
}2.运算符重载
当我们想比较两个string类的大小时，内置的运算符不适用，因此我们将自己实现运算符重载
由于运算符重载比较简单，不做过多阐述，直接将实现的代码写上
2.1 s1<s2
bool operator<(const string& s)
{
int ret = strcmp(_str, s._str); //比较两个字符串大小，比较ASII码值
return ret < 0;
}2.2 s1==s2
bool operator==(const string& s)
{
int ret = strcmp(_str, s._str);
return ret == 0;
}2.3 s1<=s2
bool operator<=(const string& s)
{
return *this < s || *this == s;
}2.4 s1>s2
bool operator>(const string& s)
{
return !(*this <= s);
}2.5 s1>=s2
bool operator>=(const string& s)
{
return !(*this < s);
}2.6 s1!=s2
bool operator != (const string& s)
{
return !(*this == s);
}3.增删查改
由于我们会在类外面遍历数组之类等操作会用到_size，_capacity,_str等私有成员变量，因此我们将它封装成函数，请看下面实现
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
const char* c_str()
{
return _str;
}3.1 增加一个字符或者字符串
插入的时候可能会出现空间不够的时候，因此我们要增容,由于经常会使用增容，防止出现代码冗长，因此我们将增容用一个函数实现，方便调用。
void reserve(size_t n)
{
if (n > _capacity)
{
char* newstr = new char[n + 1];
strcpy(newstr, _str);
delete[] _str;
_str = newstr;
_capacity = n;
}
}push_back :尾插一个字符
void push_back(char ch)
{
if (_size == _capacity) //判断是否需要增容
{
size_t newcapacity =_capacity == 0 ? 2 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0'; //必须加一个\0 ,否则出现内存泄露
}append : 尾插字符串
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
size_t newcapacity = _size + len;
reserve(newcapacity);
}
strcpy(_str+_size, str);
_size += len;
}由于插入字符和字符串会用到两个不同的函数，因此为了方便我们用"+="来实现
string& operator+=(char ch)
{
this->push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
this->append(str);
return *this;
}上述代码可以看出“+=”的底层实现仍然是调用push_back和append
3.2 删除
从pos位置，删除len长度的字符
void erase(size_t pos, size_t len = npos)
{
if (len >= _size - pos) //判断是否删除pos位置后所有字符
{
_str[pos] = '\0';
_size = pos;
}
else
{
while (pos <= _size)
{
_str[pos] = _str[pos + len];
pos++;
}
_size -= len;
}
}3.3 查找
在已知的字符串从pos位置查找所需要的字符或者字符串，返回它的位置，没知道则返回-1
size_t find(char ch, size_t pos = 0)
{
for (size_t i = pos;i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
char* p = strstr(_str, str); //寻找字符串里的子串
if (p == nullptr)
{
return npos;
}
else
return p - _str; //两个指针之间的个数
}3.4 插入
在pos位置插入一个字符或者字符串
void insert(size_t pos, char ch)
{
if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
reserve(newcapacity);
}
size_t end = _size;
while (end >= pos)
{
_str[end + 1] = _str[end];
end--;
}
_str[pos] = ch;
_size++;
}
void insert(size_t pos, const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
size_t newcapacity = _size + len;
reserve(newcapacity);
}
size_t end = _size;
while (end >= pos)
{
_str[end + len] = _str[end];
end--;
}
for (size_t i = 0; i < len; i++)
{
_str[pos++] = str[i];
}
_size += len;
}