STL之string类的模拟实现

目录

1. string的成员变量

2. string的成员函数 

2.1 string类的c_str()和swap()函数

2.2 string类的构造 

 2.3 string类的拷贝构造

2.3.1传统写法：

2.3.2现代写法： 

2.4string类的运算符重载 

 2.4.1传统写法：

2.4.2现代写法 

2. 5 string析构函数 

2.6 string的迭代器 

2.7 string的容量操作 

2.7.1. 有效长度与容量大小 

2.7.2. 容量操作 

2.8. string的访问操作 

2.9 string的修改操作 

2.9.1. 字符串的添加

2.9.2. 字符串的删除 

3.0 find()与substr()函数。

3.1. string的非成员函数

---

💓 博客主页：C-SDN花园GGbond

⏩ 文章专栏：玩转c++

为了让我们更加深入理解string，接下来我们将模拟实现一个·简易版的string。而为了和STL库中的string以示区分，我们将使用命名空间HTD对其封装。 

1. string的成员变量

string简单来说就是一个被封装可动态增长的字符数组，这与我们在数据结构中学的串非常类似，所以我们可以借助实现串的思路来大致模拟string的结构。 

下面是string的成员变量：

namespace betty
{class string {public://...private:char* _str;//存储的字符串size_t _size;//当前有效字符的个数size_t _capacity;//当前容量的大小，方便扩容};
}

注意的是\0既不占据有效长度的大小，也不占据容量的大小。 

2. string的成员函数 

2.1 string类的c_str()和swap()函数

在实现基本的构造，拷贝构造，赋值运算符重载，析构，和其他成员函数之前我们先实现c_str() 便于后续在类外使用_str成员变量来打印字符串的测试和swap（）便于进行实现拷贝构造和赋值运算符重载现代写法

注意：非成员swap（）函数在底层实际也是调用成员函数swap（）函数

const char* c_str()const
{return _str;
}

//交换字符串
void swap(string& s)
{std::swap(_str, s._str);//浅拷贝，没有开空间，只是改变指针指向std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}

2.2 string类的构造 

class string
{
public://无参构造/*string(){_str = nullptr;_size = _capacity = 0;}*/string(const char* str = ""){_size = strlen(str);_capacity = _size;_str = new char[_capacity + 1];strcpy(_str, str);}
private:char* _str;size_t _size;size_t _capacity;};

 2.3 string类的拷贝构造

2.3.1传统写法：

传统的思路就是拷贝，也就是我们先根据被拷贝的对象的_capacity开空间，然后再进行拷贝 

//拷贝构造(深拷贝)
string(const string& s):_size(s._size), _capacity(s._capacity)
{_str = new char[s._capacity + 1];strcpy(_str, s._str);
}

2.3.2现代写法： 

现代的思路就是，尝试去复用，比如说我们可不可以直接去利用前面的构造函数去构造一个新对象，然后再窃取新对象的成果（利用swap）

string(const string&s):_str(nullptr)
{string tmp(s._str);swap(tmp);
}

2.4string类的运算符重载 

 2.4.1传统写法：

传统的思路就是，先释放掉原空间，开跟s一样的空间   拷贝字符串，更改新的_szie,_capacity

//赋值运算符重载传统写法
string& operator=(const string& s)
{if (this != &s){delete[]_str;_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}return *this;
}

注意：要注意自赋值情况！！否则s就被释放了 

2.4.2现代写法 

 现代的思路就是，既然被赋值这个空间不想要，那就和形参直接交换吧！！但是要注意的是，这里就不能像传统的一样用const引用了，否则不想要的空间就给到我们的赋值对象了，这边就得用传值传参，这样被交换的就只是一个临时拷贝，不想要的空间随着栈帧的结束被销毁。 

//赋值运算符重载现代写法
string& operator=(string s)
{swap(s);return *this;
}

2. 5 string析构函数 

 们实现析构函数，只需要清理资源即可

//析构函数
~string()
{delete[]_str;_size = _capacity = 0;
}

2.6 string的迭代器 

首先我们来模拟实现一下迭代器iterator，而在string中迭代器iterator就是一个指针。所以我们直接使用typedef实现

 

typedef char* iterator;
typedef const char* const_iterator;

接下来我们来实现begin()与end()，其中begin()指向的是字符串的起始位置即_str，而end()指向有效字符最后的下一位即\0的位置。 

iterator begin()
{return _str;
}iterator end()
{return _str + _size;
}

实现完普通迭代器之后，我们可以顺便重载一个const_iterator的版本。 

const_iterator begin() const
{return _str;
}const_iterator end() const
{return _str + _size;
}

我们知道在string中还有一个反向迭代器，这个我们在之后会统一实现。 

2.7 string的容量操作 

2.7.1. 有效长度与容量大小 

首先我们先实现返回字符串有效长度的size() 与容量大小的capacity()。并且为了适配const对象，最后用const修饰this指针。

size_t size() const
{return _size;
}
size_t capacity() const
{return _capacity;
}

2.7.2. 容量操作 

首先我们实现判断字符串是否为空的empty()以及清理字符串的clear()。其中emty()
不需要修改，可以加上const

void clear()
{_str[0] = '\0';_size = 0;//clear()函数只会将字符串的内容设置为空，而不会改变其容量不考虑capacity
}
bool empty()const
{return _size == 0;
}

接下来我们来实现扩容函数reserve()与·resize()，其中reserve()最简单，只要新容量大于旧容量就发生扩容。 

void string::reserve(size_t n)
{if (n > _capacity){char*tmp= new char[n + 1];memcpy(tmp, _str, _size);delete[]_str;_str = tmp;_capacity = n;}
}
void string::resize(size_t n)
{if (n > _size){if (n > _capacity){reserve(n);}memset(_str + _size, '\0', n - _size);}_size = n;_str[_size] = '\0';}

2.8. string的访问操作 

为了符合我们C语言访问数组的习惯，我们可以先重载operator[]。当然我们也要提供两种不同的接口：可读可写与可读不可写。并且使用引用返回，减少不必要的拷贝。 

// 可读可写
char& operator[](size_t pos)
{assert(pos < _size);return _str[pos];
}
// 可读不可写
const char& operator[](size_t pos) const
{assert(pos < _size);return _str[pos];
}

同理我们也可以实现front()与back()函数。 

// 可读可写
char& front()
{return _str[0];
}
char& back()
{return _str[_size - 1];
}
// 可读不可写
const char& front()const
{return _str[0];
}
const char& back()const
{return _str[_size - 1];
}

2.9 string的修改操作 

2.9.1. 字符串的添加

首先我们将实现两个常用的修改函数：push_back()与append()

void push_back(char c)
{// 如果数据满了，则需要进行扩容if (_size == _capacity){ 	reserve(_capacity == 0 ? 4 : _capacity * 2);}_str[_size++] = c;_str[_size] = '\0';
}
// 追加字符串
void append(const char* str)
{int len = strlen(str);// 获取字符串的长度// 如果大于原来容量，则就需要扩容if (_size + len > _capacity){reserve(_size + len);}// 将字符串拷贝到末尾的_size位置memcpy(_str + _size, str, len + 1);_size += len;
}

而后我们可以复用前两个函数实现operator+=()。 

//追加一个字符
string& operator+=(char ch)
{push_back(ch);return *this;
}
//追加一个字符串
string& operator+=(const char* s)
{append(s);return *this;
}

最后我们来实现随机插入insert()函数。将pos位置和pos后所有字符移动len个单位，如果为字符len=1，否则len=字符串长度 

//添加一个字符
void insert(size_t pos, char ch)
{//防止越界访问assert(pos <= _size);//检查是否需要扩容if (_size == _capacity){size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newCapacity);}size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;_size++;
}
//添加一个字符串
void insert(size_t pos, const char* s)
{//防止越界访问assert(pos <= _size);//检查是否需要扩容size_t len = strlen(s);if (_size+len > _capacity){reserve(_size+len);}size_t end = _size + len;while (end > pos){_str[end] = _str[end - len];--end;}memcpy(_str + pos, s, len);
}

2.9.2. 字符串的删除 

 字符串的删除我们需要实现pop_back()与erase()两个函数。

void pop_back()
{_str[_size - 1] = '\0';--_size;
}

而随机删除erase()需要再定义一个静态类成员变量npos来实现，它为无符号数的-1，一般为整型的最大值

// 类内声明
static size_t npos;
// 类外初始化
size_t string::npos = -1;

将pos位置后所有字符往前移动len个单位，如果为字符 len=1，否则len=字符串长度 

void erase(size_t pos, size_t len = npos)
{assert(pos < _size);//判断是否将后面字符之间删除完if (len == npos || pos + len >= _size){_str[0] = '\0';_size = pos;}else{//往前移len个字符size_t begin = pos + len;while (begin <= _size){_str[begin - len] = _str[begin];++begin;}_size -= len;}
}

3.0 find()与substr()函数。

const char* c_str()const		
{		return _str;        
}
//找字符
size_t find(char ch, size_t pos = 0) const
{for (size_t i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;
}
//找字符串
size_t find(const char* s, size_t pos = 0) const
{const char* p = strstr(_str + pos, s);if (p){return p - _str;}return npos;
}
//截取一段字符串
string substr(size_t pos, size_t len = npos)
{string s;size_t end = pos + len;//判断是否截取到最后if (len == npos || pos + len >=_size){len = _size - pos;end = _size;}//提前开辟空间s.reserve(len);for (size_t i = pos; i < end; i++){s += _str[i];}return s;
}

3.1. string的非成员函数

bool operator<(const string& s1, const string& s2)
{return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const string& s1, const string& s2)
{return strcmp(s1.c_str(), s2.c_str())==0;
}
bool operator<=(const string& s1, const string& s2)
{return s1.c_str() == s2.c_str() || s1.c_str() < s2.c_str();
}
bool operator>(const string& s1, const string& s2)
{return strcmp(s1.c_str(), s2.c_str()) > 0;
}
bool operator>=(const string& s1, const string& s2)
{return s1.c_str() == s2.c_str() || s1.c_str() >s2.c_str();
}

 接下来让我们实现流插入operator<<()与流提取operator>>()。但是我们要注意普通istream对象无法提前空格与\n。这是我们就需要一个函数get()来提取

ostream& operator<<(ostream& out, const string& s)
{for (auto ch : s){out << ch;}return out;
}

// 流提取
istream& operator>>(istream& in, string& s)
{s.clear();//先清空原字符串char ch = in.get();char buf[128];int i = 0;while (ch != '\n')//以换行为分隔符{buf[i++] = ch;// 为\0留空间if (i == 127){buf[i] = '\0';s += buf;i = 0;}ch = in.get();}//将buf中剩余数据直接填入if (i != 0){buf[i] = '\0';s += buf;}return in;
}