【c++】string类模拟实现

阅读本书更多章节>>>>

🔥个人主页：Quitecoder

🔥专栏：c++笔记仓

朋友们大家好，本篇文章我们模拟实现一个string类来深刻理解string类函数的功能

目录

`1.基本框架``2.构造函数与析构函数``3.遍历字符串``4.对内容的修改``5.几个重载函数``6.完整代码`

1.基本框架

我们stl库中的string类实在std命名空间的，这里我们自定义一个命名空间own，包含string类和简单的成员变量：

namespace own{class string{public:---private:char* _str;size_t _size;size_t _capacity;}}

2.构造函数与析构函数

我们上篇文章知道，string类有多种构造函数，我们来实现常见的几种：

🔥string()

空字符串构建：

string():_str(new char[1]),_size(0),_capacity(0){   _str[0]='\0';}

这里我们给字符数组分配一个空间大小来存储\0,同时设置类的 _size 和 _capacity 成员变量的初始值

🔥string(const char*str)

这个我们用一个常量字符串来实例化一个对象

string(const char* str):_str(new char[strlen(str)+1]),_size(strlen(str)),_capacity(strlen(str)){strcpy(_str, str);}

这个我们给数组开辟字符串长度大小加一的空间，末尾存储\0，再设置两个成员的大小，函数体内，我们用字符串函数将常量字符串拷贝到对象的数组中

我们可以对代码进行优化，可以将上述两个函数通过缺省值合并为一个函数

string(const char* str=""): _size(strlen(str)){_capacity = _size;_str = new char[_size + 1];strcpy(_str, str);}

缺省值即为空字符串，初始化列表只为size赋值减少对strlen的多次调用

🔥~string()

析构函数

~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}

🔥深拷贝string(const string& s)

我们知道，系统默认的拷贝构造是逐个字节的浅拷贝，会导致两个字符串指向同一个空间，在析构时可能会对同一个空间多次释放使系统崩溃

所以，我们需要手动实现深拷贝

string(const string& s){_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}

我们给为当前的字符串开辟与拷贝对象相同的一块空间，将拷贝对象拷贝给this对象，再将剩余成员变量修改

3.遍历字符串

首先我们用三个函数来获取三个成员变量：

const char* c_str()const{return _str;}size_t size() const{return _size;}size_t capacity() const{return _capacity;}

我们这里设置为const成员函数，使string类对象和const string类对象都可以调用这几个函数

🔥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];}

这个版本的运算符重载是常量成员函数，意味着它不会修改类的成员变量

代码测试：

void test1(){string s1("hello world");string s2;cout << s1.c_str() << endl;cout << s2.c_str() << endl;for (size_t i = 0; i < s1.size(); i++){cout << s1[i] << " ";}const string s3("xxxx");for (size_t i = 0; i < s3.size(); i++){cout << s3[i] << " ";}cout << endl;}

🔥迭代器iterator

我们上篇文章知道，迭代器是一个类似于指针却不是指针的东西，实际上迭代器十分复杂，但是我们简单的模拟实现就认为它是指针

我们提供四个函数，分别为常量和非常量对象的版本：

typedef char* iterator;typedef const char* const_iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}const_iterator begin()const{return _str;}const_iterator end()const{return _str + _size;}

测试代码如下：

void test2(){string s1("hello world");string::iterator it1 = s1.begin();while (it1 != s1.end()){cout << *it1 << " ";++it1;}cout << endl;const string s3("xxxxxxxx");string::const_iterator it4 = s3.begin();for (auto ch : s3){cout << ch << " ";}cout << endl;}

结果如下：

h e l l o   w o r l dx x x x x x x x

我们在上面用到了范围for，通过调试我们来观察：

for (auto ch : s3)00007FF6D3D68BCA  lea         rax,[s3]  00007FF6D3D68BCE  mov         qword ptr [rbp+0A8h],rax  00007FF6D3D68BD5  mov         rcx,qword ptr [rbp+0A8h]  00007FF6D3D68BDC  call        own::string::begin (07FF6D3D61091h)  00007FF6D3D68BE1  mov         qword ptr [rbp+0C8h],rax  00007FF6D3D68BE8  mov         rcx,qword ptr [rbp+0A8h]  00007FF6D3D68BEF  call        own::string::end (07FF6D3D61014h)  

我们截取一部分观察，其本质还是使用了迭代器，但注意，这里迭代器的命名必须规范

4.对内容的修改

🔥reserve开空间

我们在字符串插入会进行扩容，这里我们用上篇提到的reserve函数：

void reserve(size_t n){if (n > _capacity){char* tmp = new char[n+1];//多开一个strcpy(tmp, _str);delete[]_str;_str = tmp;_capacity = n;}}

只有当新的容量大于当前容量时才执行

new char[n+1] 分配足够的内存来存储 n 个字符和一个额外的空字符（存储\0），再将原来的字符串拷贝到新的空间中，并使原来的指针指向新空间，最后修改capacity为n，这里capacity含义是能存储有效字符个数的空间

🔥push_back尾插

void push_back(char ch){if (_size == _capacity){reserve(_capacity==0?4:_capacity * 2);}_str[_size] = ch;++_size;_str[_size] = '\0';}

尾插一次插入一个字符，首先判断空间大小，如果起始空间为0，就赋值为4，若不为零，则扩容二倍，最后填上\0

🔥append尾插字符串

我们用append来尾插一个常量字符串

void append(const char* str){//扩容size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}strcpy(_str + _size, str);_size += len;}

首先获取字符串的有效长度，再判断空间是否足够，最后用字符串函数strcpy从尾端进行插入，更改成员变量_size的值

🔥尾插operator+=

string& operator+=(char ch){push_back(ch);return *this;}string& operator+=(const char* str){append(str);return *this;}

我们可以直接复用上面的两个函数

🔥insert在指定位置插入字符或字符串

在pos位置插入字符，意味着我们需要将字符串从pos位置向后挪动一位

首先看第一个版本：

void insert(size_t pos, char ch){assert(pos <= _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}size_t end = _size;while (end >= pos){_str[end + 1] = _str[end];--end;}_str[pos] = ch;++_size;}

这里size初始指向末尾\0位置，将数据不断向后挪动，直到腾出pos位置，但是注意，如果pos为初始位置0，end–后会变成-1，而无符号整形-1即为一个很大的值，会无法跳出循环

改进：

void insert(size_t pos, char ch){assert(pos <= _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;++_size;}

我们初始指向\0的下一个位置，最终当end与pos值相等时跳出循环，完成插入与对成员变量的修改

下面来看插入一个字符串：

void insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}size_t end = _size + len;while (end >= pos+len){_str[end] = _str[end - len];--end;}strncpy(_str+pos,str,len);_size += len;}

同理，我们让end指向/0后面len个位置完成对原字符串的挪动，最后用strncpy函数拷贝到pos位置，修改成员函数值即可

🔥erase删除

我们同样有两个版本，先看第一种

void erase(size_t pos, size_t len = npos){assert(pos < _size);if (len == npos || pos + len >= _size){_str[pos] = '\0';_size = pos;}else//往前覆盖{strcpy(_str + pos, _str + pos + len);_size -= len;}}

这里pos不能等于_size是因为我们不能删去\0,nops我们知道，是整数-1,这里我们需要自己在类中定义

public:static const int npos;

在外部进行初始化：

const int string::npos = -1;

if (len == npos || pos + len >= _size){_str[pos] = '\0';_size = pos;}

这个条件意味着删除pos位置后面的所有字符，我们将pos位置修改为\0,再修改_size的值，本质与顺序表一样，并没有对后面的字符进行修改，只是一个覆盖而已

     else{strcpy(_str + pos, _str + pos + len);_size -= len;}

如果没有全部删除完，我们就将剩余部分拷贝到pos位置后面即可

但是注意这个条件

if (len == npos || pos + len >= _size);

如果我的len的值给npos-1，同样是一个很大的数，这里与pos进行计算可能会造成溢出，所以解决办法就是调换计算顺序

if (len == npos || len >= _size-pos);

🔥find查找字符或字符串

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;}

我们给了缺省值pos，如果不赋值，默认从起始位置开始找，遍历数组，若找到目标字符，则返回下标，若找不到，则返回npos

size_t find(const char* str, size_t pos = 0) const{assert(pos < _size);const char* a=strstr(_str+pos, str);if (a){return a - _str;}else{return npos;}}

查找目标字符串，我们调用字符串函数strstr，如果找到返回目标字符串起始位置的指针，若没找到，则返回空指针，我们再加一个判断条件，如果不为空，指针相减即为目标位置到起始位置的距离，若为空，则找不到，返回npos

🔥substr

substr 用于从字符串中提取一个子字符串。这个函数非常有用，模拟实现如下：

string substr(size_t pos=0, size_t len=npos){string sub;if (len == npos || len >= _size - pos){for (size_t i = pos; i < _size; i++){sub += _str[i];}}else{for (size_t i = pos; i < pos + len; i++){sub += _str[i];}}return sub;}

我们直接在新的sub字符串尾差字符

5.几个重载函数

🔥operator=赋值重载

string& operator=(const string& s){char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[]_str;_str = tmp;_size = s._size;_capacity = s._capacity;return *this;}

开辟一块新空间，将原内容拷贝到新空间中并释放，然后更改指针指向与成员变量，最后返回*this

🔥operator==等几个比较函数

我们简单模拟两个

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

剩余的情况可以复用上面的两个函数

🔥流插入与提取

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;ch = in.get();char buff[128];//缓冲数组size_t i = 0;while (ch!=' '&&ch!='\n')//读字符读不到空格{buff[i++] = ch;if (i == 127){buff[127] = '\0';s += buff;i = 0;}//s += ch;ch=in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}

输入是对内容的覆盖，所以我们首先实现一个clear函数来清空字符串，原理很简单：

void clear(){_size = 0;_str[_size] = '\0';}

只需要修改_size并设置\0即可

注意，我们cin输入是读不到空格与换行符的

其中ch = in.get();从输入流中读取单个字符

我们这里创造了一个缓冲数组char buff[128];，来简单进行讲解一下：

这个数组功能就是存储字符内容，如果数组满了，则直接进行+=将整个数组内容尾插到字符串中，并更新索引，其主要特点就是，避免了我们自己为字符串s不断扩容降低了效率，并且可能会造成空间的浪费

与cin不同的是，getline可以读取空格，所以我们只需要修改循环条件即可

istream& getline(istream& in, string& s){s.clear();char ch;ch = in.get();char buff[128];size_t i = 0;while ( ch != '\n'){buff[i++] = ch;if (i == 127){buff[127] = '\0';s += buff;i = 0;}//s += ch;ch = in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}

6.完整代码

#pragma once#include<string>#include<iostream>#include<assert.h>using namespace std;namespace own{class string{public:typedef char* iterator;typedef const char* const_iterator;/*string():_str(new char[1]),_size(0),_capacity(0){   _str[0]='\0';}*//*string(const char* str):_str(new char[strlen(str)+1]),_size(strlen(str)),_capacity(strlen(str)){strcpy(_str, str);}*/string(const char* str=""): _size(strlen(str)){_capacity = _size;_str = new char[_size + 1];strcpy(_str, str);}//深浅拷贝string(const string& s){_str = new char[s._capacity + 1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}//赋值重载string& operator=(const string& s){char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[]_str;_str = tmp;_size = s._size;_capacity = s._capacity;return *this;}const char* c_str()const{return _str;}~string(){delete[] _str;_str = nullptr;_size = _capacity = 0;}//遍历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];}//迭代器iterator begin(){return _str;}iterator end(){return _str + _size;}const_iterator begin()const{return _str;}const_iterator end()const{return _str + _size;}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n+1];//多开一个strcpy(tmp, _str);delete[]_str;_str = tmp;_capacity = n;}}void push_back(char ch){/*if (_size == _capacity){reserve(_capacity==0?4:_capacity * 2);}_str[_size] = ch;++_size;_str[_size] = '\0';*/insert(_size, ch);}void append(const char* str){扩容//size_t len = strlen(str);//if (_size + len > _capacity)//{//reserve(_size + len);//}//strcpy(_str + _size, str);//_size += len;insert(_size, str);}string& operator+=(char ch){push_back(ch);return *this;}string& operator+=(const char* str){append(str);return *this;}void insert(size_t pos, char ch){assert(pos <= _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}//int end = _size;//size_t//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;}void insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if (_size + len > _capacity){reserve(_size + len);}size_t end = _size + len;while (end >= pos+len){_str[end] = _str[end - len];--end;}strncpy(_str+pos,str,len);_size += len;}void erase(size_t pos, size_t len = npos){assert(pos < _size);//不删‘\0’//if (len == npos || pos + len >= _size)//可能会溢出if (len == npos || len >= _size-pos){_str[pos] = '\0';_size = pos;}else//往前覆盖{strcpy(_str + pos, _str + pos + len);_size -= len;}}void resize(size_t n, char ch = '\0'){if (n <= _size){_str[n] = '\0';_size = n;}else{reserve(n);for (size_t i = _size; i < n; i++){_str[i] = ch;}_str[n] = '\0';}}void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}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* str, size_t pos = 0) const{assert(pos < _size);const char* a=strstr(_str+pos, str);if (a){return a - _str;}else{return npos;}}string substr(size_t pos=0, size_t len=npos){string sub;if (len == npos || len >= _size - pos){for (size_t i = pos; i < _size; i++){sub += _str[i];}}else{for (size_t i = pos; i < pos + len; i++){sub += _str[i];}}return sub;}void clear(){_size = 0;_str[_size] = '\0';}private:char* _str;size_t _size;size_t _capacity;public:static const int npos;};const int string::npos = -1;bool operator==(const string& s1, const string& s2){int ret = strcmp(s1.c_str(), s2.c_str());return ret == 0;}bool operator<(const string& s1, const string& s2){int ret = strcmp(s1.c_str(), s2.c_str());return ret < 0;}//剩余各种情况复用即可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;ch = in.get();char buff[128];//缓冲数组size_t i = 0;while (ch!=' '&&ch!='\n')//读字符读不到空格{buff[i++] = ch;if (i == 127){buff[127] = '\0';s += buff;i = 0;}//s += ch;ch=in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}istream& getline(istream& in, string& s){s.clear();char ch;ch = in.get();char buff[128];size_t i = 0;while ( ch != '\n'){buff[i++] = ch;if (i == 127){buff[127] = '\0';s += buff;i = 0;}//s += ch;ch = in.get();}if (i > 0){buff[i] = '\0';s += buff;}return in;}}

本节内容到此结束，感谢大家阅读！！

阅读本书更多章节>>>>

本文链接：https://www.kjpai.cn/gushi/2024-04-20/160506.html，文章来源：网络cs，作者：亙句，版权归作者所有，如需转载请注明来源和作者，否则将追究法律责任！