之前学到了string类常用接口的后，我很好奇string类在底层是怎样实现的，在由之前学习到c++有关的之后，所以我打算模拟实现一下string类常用的接口，以便加深我对之前的知识的理解，和更好的去使用string类，比如在哪些场景使用哪些接口较为合适。接下来我会用c++来模拟实现各个接口。
string类就是存储字符的顺序表，它的实现与与顺序表的实现是非常相似，主要接口为增删查改。实现如下
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string.h>
#include<assert.h>
using namespace std;
//定义一个属于自己的域
namespace sjp
{
class string
{
private:
char* _str;
size_t _size;//字符串中的有效的字符个数
size_t _capacity;//字符串中的最大容量
static const size_t npos;//npos是string类对象中的一个静态成员变量，为整数的最大值
public:
//构造函数
string(const char* str ="")
{
_size = strlen(str);//计算出初始化字符串的大小
_capacity = _size;
_str = new char[_capacity+1];//开辟空间多开辟一块空间，这块空间留给\0
strcpy(_str, str);
}
//交换函数，可以与另一个sting对象交换数据
void swap(string& s)
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
//析构函数，清理资源
~string()
{
delete _str;
_str = nullptr;
_size = 0;
_capacity = 0;
}
//拷贝构造，对象创建时，可以将另一个string对象的数据拷贝给要创建的对象
string(const string& s)
{
sjp::string tmp(s._str);
swap(tmp);//函数调用结束时tmp会被析构函数给清理掉
}
//迭代器，string的迭代器的底层就是指针
typedef char* iterator;
iterator begin()
{
return this->_str;//返回字符串首元素的地址
}
iterator end()
{
return this->_str + _size;//返回字符串最后一个地址
}
// 返回字符的个数
size_t size()
{
return _size;
}
//预留字符串的空间，只改变_capacity，不改变初始化空间
void reserve(size_t capacity)
{
//如果预留的空间大于原本的空间，直接开辟一块capacity的空间，并把数据拷贝给这块空间
if (capacity > _capacity)
{
char* str= new char[capacity];
strcpy(str, _str);
_str = str;
_capacity = capacity;
}
//如果capacity小于_size,则_capacity不做改变，_size改变即可
else if(capacity<_size)
{
_size = capacity;
_str[_size] = '\0';
}
}
//预留空间，并且初始化这块空间，既改变capacity和size
void resize(size_t capacity,char ch='\0')
{
if (capacity < _size)
{
_size = capacity;
_str[_size] = '\0';
}
else
{
if (capacity > _capacity)
{
reserve(capacity);
}
memset(_str + _size, ch, (capacity-_size));//memset是创建一块空间，并初始化这块空间
_str[_size] = '\0';
_size = capacity;
}
}
//尾插一个字符
void push_back(char ch)
{
if (_size == _capacity)//判断字符串的空间是否满了
{
size_t newcapacity = _capacity == 0 ? 5 : _capacity * 2;
reserve(newcapacity);
_capacity = newcapacity;
}
_str[_size] = ch;
_size += 1;
_str[_size] = '\0';//最后记得加上\0
}
//尾插一个字符串
void append(const char* str)
{
size_t len = strlen(str);//尾插的字符串的个数
if (len + _size > _capacity)//原来的字符串的个数和要插入的字符的个数大于字符串的空间
{
reserve(len + _size);//增容
}
strcpy(_str + _size, str);
_size += len;
}
//操作符+=重载，尾插一个字符串
string& operator+=(const char* str)
{
append(str);
return *this;
}
//操作符+=重载，尾插一个string类对象
string& operator+=(const string& s)
{
append(s._str);
return *this;
}
//操作符+=重载，尾插一个字符
string& operator+=(const char ch)
{
push_back(ch);
return *this;
}
//操作符[]重载，访问字符串中的某个字符，既可读也可以写，const的string不能调用它
char& operator[](size_t i)
{
return _str[i];
}
//操作符[]重载，访问字符串中的某个字符，只能读不能写，const调用它
const char& operator[](size_t i)const
{
return _str[i];
}
//在某个位置插入一个字符
string& insert(size_t pos,char ch)
{
assert(pos < _size);
if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 5 : _capacity * 2;
reserve(newcapacity);
_capacity = newcapacity;
}
//不能这样实现，pos为0时，end减到-1时，由于end和pos是无符号，所以end会变成最大整数，一直无限循环
/*size_t end = _size - 1;
while (end >= pos)
{
_str[end - 1] = _str[end];
end--;
}
*/
size_t end = _size+1;
while(end>pos)
{
_str[end] = _str[end - 1];
end--;
}
_str[pos] = ch;
_size++;
return *this;
}
//在某个位置插入一个字符串
string& insert(size_t pos,const char* s)
{
assert(pos < _size);
size_t len = strlen(s);
if (len + _size > _capacity)
{
reserve(len + _size);
}
char* end = _str+_size;
while (end >=_str+pos)
{
*(end + len) = *end;
end--;
}
size_t cur = pos;
strncpy(_str + pos, s, len);
_size += len;
return *this;
}
//在某个位置去掉多少个字符
string& erase(size_t pos,size_t n=npos)
{
assert(pos < _size);
size_t leftlen = _size - pos;//leftlen是尾上
if (leftlen <= n)
{
_size = pos;
_str[_size] = '\0';//注意
}
else
{
strcpy(_str + pos, _str + pos + n);
_size -= n;
}
return *this;
}
//从pos位置开始查找查找一个字母
size_t find(const char ch,size_t pos=0)
{
assert(pos < _size);
for (int i = pos; i < _size; i++)
{
if (_str[i] == ch)
{
return i;
}
}
//找不到返回npos
return npos;
}
//从某个位置开始，查找一个字符串，如果找到，返回该字符串的位置，找不到返回npos
size_t find(const char* ch, size_t pos = 0)
{
assert(pos < _size);
//strstr（s1，s2）的功能是判断s2是否为s1的字串，并且返回s2在s1中的地址，找不到返回nullptr
const char* ret = strstr(_str+pos, ch);
/*char* cur = _str;
while (cur < _str+_size)
{
if (cur == tmp)
{
return cur - _str;
}
cur++;
}*/
if (ret)
{
return ret - _str;
}
else
{
return npos;
}
return npos;
}
//访问对象中的字符串
char* s_str()const
{
return _str;
}
//判断字符串是否为空
bool empty()const
{
return _size == 0;
}
//清空字符串
void clear()
{
_size = 0;
_str[_size] = '\0';
}
};
const size_t string::npos = -1;
//下面这几个为比较两个string对象的大小的操作符重载
bool operator==(const sjp::string& s1, const sjp::string& s2)
{
return strcmp(s1.s_str(), s2.s_str()) == 0;
}
bool operator>(const sjp::string& s1, const sjp::string& s2)
{
return strcmp(s1.s_str(), s2.s_str()) > 0;
}
bool operator<(const sjp::string& s1, const sjp::string& s2)
{
return !(s1 == s2) || !(s1 > s2);
}
bool operator>=(const sjp::string& s1, const sjp::string& s2)
{
return !(s1 < s2);
}
bool operator<=(const sjp::string& s1, const sjp::string& s2)
{
return !(s1 > s2);
}
bool operator!=(const sjp::string& s1, const sjp::string& s2)
{
return !(s1 == s2);
}
//操作符<<重载，使cout<<能够输出string对象
ostream& operator<<(ostream& out, string& s)
{
for (auto ch: s)//范围for的使用
{
out << ch;
}
return out;
}
//操作符>>重载使cin>>能够输入string对象
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch = in.get();//in.get()能够获取空格和回车字符
while (ch != ' ' && ch != '\n')//如果ch为空格或回车，将跳出输入
{
s += ch;
ch = in.get();
}
return in;
}
}
1.strstr（char* s1，char* s2）判断s2是否为s1的字串，如果是，则返回该字串在s1中的地址位置，如果不是返回空。
strcpy(char* s1,char* s2)将s2中的字符拷贝给s1，包括\0；
memset(void* str, ch, size) 从str的位置开始，开辟size个字节的大小，并将开辟的空间初始为ch
2.写istream和iostream的重载时，记得返回的值是istream&或iostream&（注意是引用），参数也是istream&或iostream&
3.写构造函数需要多开辟一个空间给\0,
4.如果没使用strcpy，删除或则增加需要记得在结尾_str[_size]=‘\0’.
5.operator[]需要实现两个，一个为const类型的，一个非const类型的，在操作函数后面加const是为了修饰this指针指向的成员变量，若为const类型的对象，它只能读，不能写，那么它在调用时会自动调用const类型的重载函数，若不是从const类型的对象，那么调用的时候会调用不是const类型的函数。
6.对于string的实现，c++标准只规定string要实现的接口功能，但各个编译器具体怎样实现，都是不一样的，例如，在vs编译器中，string的对象的大小是28个字节，在gcc中string对象的大小为12个字节。
模拟实现string常用接口后，我们可以知道string的迭代器的底层是指针，修改数据尽量少用insert，erase，因为它们的使用需要挪动数据，时间复杂度为O(n^2),效率太低了，reserve与resize的区别。
点个赞呗~！！！！