C++（string类的实现）

🕗 发布于 2024-10-04 13:56 c++ 开发语言

1. 迭代器、返回capacity、返回size、判空、c_str、重载[]和clear的实现

string类的迭代器的功能就类似于一个指针，所以我们可以直接使用一个指针来实现迭代器，但如下图可见迭代器有两个，一个是指向的内容可以被修改，另一个则是指向的内容不能被修改，那么我们就需要实现两个；这个实现其实很简单，我们只需要使用typedef或者using来实现，这里我就两个都实现出来，两个选其一即可；如下图和代码所示：

#include<assert.h>
class string
{
public:

using iterator = char*;
typedef char* iterator;

using const_iterator = const char*;
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;
}

//返回capacity
size_t capacity()const
{
return _capacity;
}

//返回size值
size_t size() const
{
return _size;
}

//判空
bool empty()const
{
return _str[0] == '\0';
}

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

//模拟方括号通过下表访问
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}

const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
//clear
void clear()
{
_str[0] = '\0';
//_capacity = 0;  //这个大小不能改，改了就废了，这是我犯过的一个错误
_size = 0;
}
private:
char* _str;
size_t _size;
size_t _capacity;
};

2. 实现string类的构造和析构函数

一般实现类我们都需要先实现他的构造函数和析构函数，我们就先实现string类的构造函数，但string类的构造函数有很多个，我们就挑几个来实现，第一个是模拟 string s1("hello world")；第二个是模拟string s1(s2)也就是拷贝构造；

2.1 string s1("hello world")的实现

string.h

class string
{
public:

//模拟string s1("hello world")
string(const char* str = "");
//模拟string s1(s2)
string(const string& s);

private:
char* _str;
size_t _size;
size_t _capacity;
};

string.cpp

string::string(const char* str)
:_size(strlen(str))
{
_capacity = _size;
//一般都会多开一个空间给'\0'
_str = new char[_size + 1];

strcpy(_str, str);
}
//模拟string s1(s2)
string::string(const string& s1)
{
//我们要创建一个他的大小的空间
_str = new char[s1._capacity + 1];
strcpy(_str, s1._str);
_capacity = s1._capacity;
_size = s1._size;
}

代码的解释：

先来说第一个，有的人问为什么我们不把_capacity和_size的初始化都放到初始化列表里面去，可以尝试着说_size(strlen(str));_capacity(_size);_str(new char[_size+1])这样按着这个顺序来，是因为初始化列表走的顺序不是按初始化列表里的顺序来的，而是按声明的顺序来，如果说我们_size不是第一个声明的话，那么_capacity和_str都错了，可能会取得错误的值，所以我们只把_size放到里面的话就不会出现上面的那种情况，在函数里面要动态开辟一块空间进行深拷贝（不进行深拷贝的后果前面有说这里就不过多阐述），然后直接用一个strcpy把内容复制到_str来即可；

第二个参数要用传引用避免进行拷贝构造调用，然后需要创建一块和s1一样大的空间，但他并不会给'\0'的顺序算入，所以我们需要+1；

注意！：上面的缺省参数要给char* str="";我们不能给NULL。

析构函数的实现：

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

3. 实现reserve（不是reverse）操作

reserve就是提前开空间，需要看具体什么意思的话可以去看前一篇c++文章介绍string的使用的；如下代码所示：

void string::reserve(size_t n)
{
//开空间的话我们要判断n是否大于capacity
if (n > _capacity)
{
char* temp = new char[n + 1];
strcpy(temp, _str);
delete[]_str;
_str = temp;
_capacity = n;
}
}

注意：我们开空间后用一个temp来接收，把_str的内容复制到temp再释放掉_str，不然会造成内容泄漏；

4. 实现push_back和append操作

push_back：进行push_back操作前我们需要判断_str的空间是否足够，如果不够则需要扩容；扩容时按二倍扩容，所以我们需要用一个三目运算符来判断，如果_capacity=0的时候就无法进行二倍扩容操作，那就需要给他一直初始空间大小；如下代码所示：

void string::push_back(char ch)
{
//检查空间
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
_size++;
}

append：append和push_back不一样，append可以插入一个字符串，但我们也是需要考虑空间问题，首先我们需要计算传入的字符串的长度，然后加上我们原有的长度看看是否大于我们的空间容量，如果大于则按二倍扩，但我们又需要考虑一个情况就是如果说二倍扩的空间还是没有我们传入字符串的长度加原有的长度大的话，我们就让他需要多少空间就给多少空间；

void string::append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
size_t NewCapacity = 2 * _capacity;
if (NewCapacity < _size + len)
NewCapacity = _size + len;
reserve(NewCapacity);
}
strcpy(_str + _size, str);
_size += len;
}

5. 实现insert和erase操作

实现insert和erase的话我们需要对字符进行往前或者往后挪动，这也导致他们的效率不高；实现insert的时候也是需要和上面的一样扩容操作，当我们在hello world中间插入一个this的时候，我们把world挪到后面去给this腾出4个位置；如下代码所示：

string& string::insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (_size + len > _capacity)
{
size_t Newcapacity = 2 * _capacity;
if (_size + len > Newcapacity)
Newcapacity = _size + len;
reserve(Newcapacity);
}
size_t end = _size + len;
while (end > pos + len - 1)
{
_str[end] = _str[end - len];
--end;
}
for (size_t i = 0; i < len; i++)
{
_str[pos + i] = str[i];
}
_size += len;
return *this;
}

erase也同理，但erase有两种情况，第一种是在pos位置删除len长度的时候如果说len长度大于pos后面的长度的时候那就直接让pos位置为'\0'，因为\0就是意味着结束，第二种情况则是len小于pos后面的长度，那就需要挪动数据；如下代码所示：

string& string::erase(size_t pos, size_t len)
{
assert(pos < _size);
if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
size_t end = pos + len;
while (end <= _size)
{
_str[end - len] = _str[end];
++end;
}
_size -= len;
}
return *this;
}

6. 实现npos和find的操作

npos在string里面代表最大的值但他是静态成员、不能被修改、还是一个无符号整型，那就直接给他一个-1就可以；如下代码所示：

#include<assert.h>
class string
{
public:
const static size_t npos = -1;

private:
char* _str;
size_t _size;
size_t _capacity;
};

注意！：这里为什么可以给缺省值-1是因为加了const，如果不加const是无法给的，因为被static修饰的变量是不走初始化列表，在定义的时候给值就是给缺省参数，缺省参数是给初始化列表使用的；

find操作实现：find有两个，一个是从指定位置开始找，另一个则是从头遍历到尾，直接进行暴力遍历就可以实现；如下代码所示：

size_t string::find(char c, size_t pos )const
{
assert(pos <= _size);
for (size_t i = pos; i < _size; i++)
{
if (c == _str[i])
{
return i;
}
}
return npos;
}

size_t string::find(const char* s, size_t pos )const
{
//我们要从pos位置找起那么就要_str+pos；
assert(pos <= _size);
const char* ptr = strstr(_str + pos, s);
if (ptr == NULL)
{
return npos;
}
else
return ptr - _str;
}

注意，这里ptr-_str的操作是指针-指针得到的是中间元素的个数即位置；

7. 实现getline操作

getline的操作是一直往字符串里输入数据，直到碰到输入特定的字符的时候才终止，因为是输入数据，所以需要使用流插入类型，和重载cin一样，并且在进行一下操作的时候我们还需要清楚原有的数据，举个例子如果说你不清楚的话，原先本身s1对象里就有hello world的数据了，当你想输入一个year的时候就会打印hello world year，而string类里的getline是不会保留hello world的，所以我们先要进行clear操作；如下代码所示：

istream& getline(istream& is, string& s,char delim)
{
s.clear();

int i = 0;
char buff[256];

char ch;
ch = is.get();
//因为使用cin的时候当碰到' '和'\n'的时候就结束
while (ch!=delim)
{
buff[i++] = ch;
if (i == 255)
{
buff[i] = '\0';//因为是数组，模拟存储字符串的时候不会有\0
s += buff;//因为用+=会自行进行扩容
i = 0;
}
ch = is.get();
}
if (i > 0)
{
buff[i] = '\0';
s += buff;
}
return is;
}

代码解释：char buff[255]想做的是减少扩容操作，因为如果进行过多的扩容操作就会导致运行效率降低，那我们就可以预先给他开辟256个空间，然后进行接收输入的数据，但我们不能使用cin，因为cin碰到空格的时候就会结束，所以我们可以使用输入流里的get，然后就对输入的字符开始判断是否是特定字符，再往buff里面放，当i==255的时候，也就是剩下最后一个空间就需要给'\0'；

8. 比较运算符重载

很简单，只要实现了两个后面都可以套用，直接上代码；

bool string::operator==(const string& s)
{
return strcmp(this->c_str(), s.c_str());
}

bool string::operator!=(const string& s)
{
return !((*this)==s);
}

    bool string::operator<(const string& s)
{
return strcmp(this->c_str(), s.c_str()) < 0;
}

bool string::operator<=(const string& s)
{
return *this < s || *this == s;
}
bool string::operator>(const string& s)
{
return !(*this <= s);
}
bool string::operator>=(const string& s)
{
return *this > s || *this == s;
}

9.实现+=运算符重载

直接套用append和push_back即可；如下代码所示：

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

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

10.实现swap

std里面本身就有一个swap，为什么我们又要另外实现呢？原因是std域内的swap是一个模板，比如我们有两个自定义string类型s1 和s2，那么传过去就成了会调用拷贝构造，还需要多次开辟空间，所以我们需要在类内实现；其实也是很简单的，我们直接调用std域内的swap对s1和s2的成员进行交换即可；如下代码所示：

void string::swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}

void string::swap(string& s1, string& s2)
{
s1.swap(s2);
}

11. 实现流插入>>和流提取运算符重载<<

流提取简单，其实就是直接打印_str里的值就可以；如下代码所示：

ostream& operator<<(ostream& os, const string& str)
{
for (size_t i = 0; i < str.size(); i++)
{
os << str[i];
}

return os;
}

流插入也简单，和append差不多，但是和append不同的一点是，append是遇到特定字符的时候就结束，而流插入cin的则是碰到空格或者换行符的时候结束；如下代码所示：

istream& operator>>(istream& _cin, string& s)
{
s.clear();

int i = 0;
char buff[255];

char ch;
ch = _cin.get();
//因为使用cin的时候当碰到' '和'\n'的时候就结束
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 255)
{
buff[i] = '\0';//因为是数组，模拟存储字符串的时候不会有\0
s += buff[i];//因为用+=会自行进行扩容
i = 0;
}
ch = _cin.get();
}
if (i > 0)
{
buff[i] = '\0';
s += buff;
}
return _cin;
}

12. 赋值运算符的重载

赋值运算符的重载有两种情况，举个例子吧，string s1("hello world");string s2("man!")；第一种是s1 = s2，第二种是s1 = s1（我也不知道这个写来有什么意义，但string类支持这个操作）我们需要分类讨论这两个，因为赋值运算符的重载是需要释放原空间接收新空间，例如s1 = s2就需要释放s1的空间然后把s2的空间和值给s1，但如果是s1=s1的话，s1的空间释放了就没法进行，所以要分类讨论；如下代码所示：

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

上面那个太复杂了，下面这个是现代写法：

//现代写法
string& string::operator=( string s)
{
swap(s);
return *this;
}

举个例子s1.swap(s2);s2出了函数栈帧自动销毁，然后这里是传值传参不会影响到实参；

END！

原文地址：https://blog.csdn.net/2301_80475151/article/details/142693349

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【PyTorch】图像目标检测
下一篇：使用Python实现图形学的阴影贴图算法

15.数据结构与算法-队列的表示和实现（循环队列/链队列）
队列的抽象数据类型定义循环队列的初始化求队列的长度循环队列的入队循环队列的出队取队头元素链队列链队列的初始化链队列的销毁链队列的入队链队列出队求链队列的队头元素
阅读更多2024-10-04
【C语言】字符和字符串函数(2)
（9）现在我们就来看进行一次匹配的过程，也很简单，我们还是创建一个while循环，如果s1和s2解引用不是\0，并且解引用后相等，那我们就让s1和s2加加，一直往后走，当循环结束时，我们就判断s2解引
阅读更多2024-10-04
【机器学习(八)】分类和回归任务-因子分解机(Factorization Machines,FM)-Sentosa_DSML社区版
相比传统代码方式，利用Sentosa_DSML社区版完成机器学习算法的流程更加高效和自动化，传统方式需要手动编写大量代码来处理数据清洗、特征工程、模型训练与评估，而在Sentosa_DSML社区版中，
阅读更多2024-10-04
详解调用钉钉AI助理消息API发送钉钉消息卡片给指定单聊用户
本文针对现在钉钉提供的AI助理能力，带你学会如何调用钉钉的AI助理主动发送消息API去发送一个自己配置的钉钉消息卡片给指定钉钉用户，可以设想一下，实现了后台对接钉钉AI助理的能力，那对于你公司的行政来
阅读更多2024-10-04
ARM base instruction -- movk
ARM base instruction -- movk
阅读更多2024-10-04
Framebuffer学习
Frame是帧的意思，buffer是缓冲的意思，这意味着Framebuffer就是一块内存，里面保存着一帧图像。Framebuffer中保存着一帧图像的每一个像素颜色值，假设LCD的分辨率是1024x
阅读更多2024-10-04
DNS服务器
DNS（Domain Name System，域名系统）服务器是一种特殊的服务器，它的主要功能是。
阅读更多2024-10-04
ubuntu添加 SSH 密钥到 GitHub
通过生成 SSH 密钥、将其添加到 SSH 代理，并将公钥添加到 GitHub，你现在应该能够无缝地使用 SSH 进行 Git 操作。如果你遇到任何问题，请确保你执行了每一个步骤，并且公钥正确添加到了
阅读更多2024-10-04
stm32f103调试，程序与定时器同步设置
在调试定时器相关代码时，注意到定时器的中断位总是置1，怀疑代码有问题，经过增大定时器的中断时间，发现定时器与代码调试并不同步，这一点对于调试涉及定时器的代码是非常不利的，这里给出keil调试stm32
阅读更多2024-10-04
sql-labs：17~41（sql时间盲注和布尔盲注、sql注入爆数据思路、简单的sql注入绕过）
password：id=1' and if(1=1,sleep(1),1) and '1'='1 # 单引号闭合。uagent:1' and up
阅读更多2024-10-04