🔥个人主页：Quitecoder
🔥专栏：c++笔记仓
朋友们大家好，本篇文章我们模拟实现一个string类来深刻理解string类函数的功能
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 d
x 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;
}
}
本节内容到此结束，感谢大家阅读！！
1211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
