文章目录
模拟实现string
前言: string需要实现的接口
1.string类的迭代器。
2.string类的构造函数、析构函数、拷贝构造函数、赋值运算符重载。
3.管理字符串的数组，可以增删查改，具体包括reverse、resize、push_back、append、insert、erase、find、clear、getline接口的实现。
4.[]、+=、<、<=、==、>、>=、！=、<<、>>运算符重载。
提示: 重点是4个默认的成员函数及增删查改的实现
string结构定义
class string
{
public:
private:
char* _str;
size_t _size;
size_t _capacity;
static const size_t npos;
};
const size_t string::npos = -1;
npos简单理解就是无符号整型中的-1
1. string类的迭代器的实现
string类的迭代器有两种, 一种迭代器可读指向内容可以修改, 一种是const类型的迭代器,只读不可修改指向内容。迭代器可以简单理解成指针实现, 实现时只需返回字符串首元素和尾元素下一个位置即可
注意end的指向位置
class string
{
public:
//指针实现迭代器
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;
}
}
2. string类4个默认的成员函数
2.1 构造函数
string的构造函数主要是无参的和有参数的构造函数, 这里使用缺省参数形式来将无参和有参两种形式写到一个函数中, 缺省值给""或’\0’。在初始化列表的位置计算出字符串长度_size, 后将 _size的值赋给 _capacity, 动态开辟一个 _capacity+1大小的空间(多开一个空间给’\0’), 后将原空间的内容拷贝到新空间。
注意: 即使是空串,也要保证_capacity不能为0，因为要插入字符 , 所以对于空串特殊处理先给 _capacity赋值3，开辟4个字节空间
string(const char* str = "") //常量字符串默认以'\0' 结束
:_size(strlen(str))
{
_capacity = _size == 0 ? 3 : _size; //要插入字符, 保证capacity不为0
_str = new char[_capacity + 1]; //多开一个空间给'\0'
strcpy(_str, str);
}
2.2 析构函数
直接将开辟空间释放, 其他成员变量置为0即可
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
2.3 拷贝构造函数
用初始化列表的方式给 _size和 _capacity初始化，后开辟 _capacity+1的空间, 将原字符串内容拷贝到新空间
string(const string& s)
:_size(s._size)
, _capacity(s._capacity)
{
_str = new char[_capacity + 1];
strcpy(_str, s._str);
}
2.4 赋值运算符重载
分以下三种情况，针对这三种情况，统一做法是: 开辟新的空间tmp(不要直接去释放 _str会破坏原来的空间) 将去赋值的字符串s拷贝到tmp中, 释放掉被赋值字符串的空间使其指向tmp并修改 _size和 _capacity
注意: 要防止自己给自己赋值
string& operator=(const string& s)
{
if (this != &s) //防止自己给自己赋值
{
//空间开辟失败直接抛异常, 不会破坏原空间
char* tmp = new char[s._capacity + 1];
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
3. 管理字符串相关接口
3.1 reserve
思路同赋值重载, 如果所需容量大于 _capacity， 则开辟n+1的新空间tmp, 内容拷贝过去后释放旧空间, 使 _str指向新空间并修改 _capacity
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1]; //多开一个是给'\0'
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
3.2 resize
resize分为三种情况
- 当n小于_size,则 _size等于n(相当于删除数据, 直接把 n值赋给 _size, 在字符串末尾添加’\0’)
- 当n> _size但是小于 _capacity时, _size仍等于n, 可以不用处理
- 当n大于 _size时候,先增容,然后将 _size和n之间的数据初始化, 修改 _size的值并在字符串末尾添加’\0’
void resize(size_t n,char ch='\0') //3种情况
{
if (n < _size) //删除数据保留前n个
{
_size = n;
_str[_size] = '\0';
}
else if (n > _size)
{
if (n > _capacity)
{
reserve(n);
}
size_t i = _size;
while (i < n)
{
_str[i] = ch;
++i;
}
_size = n;
_str[_size] = '\0';
}
}
3.3 push_back
原版
思路类似于顺序表的尾插, 先检查容量大小(需要扩容时扩容2倍), 后将字符插入到原字符串的末尾, 最后一定要在字符串末尾补上一个’\0’
void push_back(char ch)
{
if (_size + 1 >= _capacity)
{
reserve(_capacity * 2);
}
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
复用版
直接复用insert来插入一个字符
void push_back(char ch)
{
insert(_size, ch);
}
3.4 append
原版
先计算要插入字符串长度, 检查容量大小(需要扩容时扩容成原字符串的长度+插入字符串的长度大小)；
将需要尾插的字符串拷贝到原字符串的后面；
插入后修改原字符串大小
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
//_str+_size是从此串的\0位置开始拷贝str的内容
strcpy(_str + _size, str);
_size += len;
}
复用版
直接复用insert来插入一个字符串
void append(const char* str)
{
insert(_size, str);
}
3.5 insert
插入字符
- 检查容量
- 挪动数据: 使end指向最后一个数据的下一个, 原来end-1位置的数据挪到end位置, --end循环挪动数据
- 在pos位置插入字符, 修改 _size的值
注意: 要保证pos位置的合法性
坑: end是size_t类型的, 此写法end=0时再–end, end会变成一个很大的数, end永远会大于pos, 死循环下去
string& insert(size_t pos, char ch)
{
assert(pos <= _size); // = _size就是'\0'
if (_size + 1 > _capacity)
{
reserve(_capacity * 2);
}
//挪动数据
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[pos] = ch;
++_size;
return *this;
}
插入字符串
- 检查容量
- 挪动数据: 使end指向最后一个数据+len(所需插入长度)的位置, 原来end-len位置的数据挪到end位置, --end循环挪动数据
- 赋值拷贝，使用strncpy(不会拷贝’\0’), 将需要插入的字符串拷贝到原字符串pos位置
- 修改 _size的值
注意: 要保证pos位置的合法性
string& 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-1)
{
_str[end] = _str[end-len];
--end;
}
//赋值拷贝
strncpy(_str + pos, str, len); //strncpy不会拷贝\0
_size += len;
return *this;
}
3.6 erase
分两种情况:
- 从
pos位置开始删除,len个,如果len不给或len长度大于剩下字符串的长度,删除pos及pos后的全部字符串, 即将pos位置置为’\0’, _size=pos- 给定len长度且小于剩下字符串的长度, 直接将pos+len位置的字符串拷贝到pos位置, 后修改 _size的值
注意: 要保证pos位置的合法性
string& 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;
}
return *this;
}
3.7 find
1. 查找字符
遍历这个数组, 找到字符返回下标， 找不到返回npos
注意: 要保证pos位置的合法性
size_t find(char ch, size_t pos=0)
{
assert(pos < _size);
for (size_t i = pos; i < _size; ++i)
{
if (_str[i] == ch)
return i;
}
return npos;
}
2. 查找字符串
直接用strstr这个函数去查找子串, 找不到返回npos， 找到返回查找出字符串首元素的下标即p - _str
注意: 要保证pos位置的合法性
size_t find(const char*str, size_t pos = 0)
{
assert(pos < _size);
char*p= strstr(_str + pos, str);
if (p == nullptr)
{
return npos;
}
else
{
return p - _str;
}
}
3.8 c_str
直接返回 _str这个字符串指针即可
const char* c_str()
{
return _str;
}
3.9 swap
直接复用库中提供swap函数拷贝
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_capacity, s._capacity);
std::swap(_size, s._size);
}
3.10 clear
void clear()
{
_size = 0;
_str[0] = '\0';
}
3.11 getline
istream& getline(istream& in, string& s)
{
s.clear();
char ch = in.get();
while (ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
3.12 size
size_t size() const
{
return _size;
}
3.13 capacity
size_t capacity() const
{
return _capacity;
}
运算符重载
[]
按照库中实现, 提供两个[]运算符重载
char& operator[] (size_t pos);支持读和写const char& operator[] (size_t pos) const;只支持读
//支持读和写
char& operator[](size_t pos)
{
assert(pos < _size); //防止越界
return _str[pos];
}
//只支持读
const char& operator[](size_t pos)const
{
assert(pos < _size); //防止越界
return _str[pos];
}
+=
分别提供字符和字符串的+=运算符重载 ， 分别复用
push_back和append即可
//字符
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
//字符串
string& operator+=(const char* str)
{
append(str);
return *this;
}
<<
ostream& operator<<(ostream& out, const string& s)
{
for (auto ch : s)
{
out << ch;
}
return out;
}
>>
流提取认为空格或换行是多个字符之间的间隔, 拿不到空格或换行；
get是任何一个字符都能拿到， 所以这里用get来读取数据
1.
istream& operator>>(istream& in, string& s)
{
s.clear(); //清理缓冲区
char ch = in.get();
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
2.
对比版本1， 版本2提供了一个buff字符串数组防止一次输入太多的数据,扩容代价大, 通过buff数组暂时存储一些数据, 可以一段一段进数据
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch = in.get();
char buff[128]={'\0'}; //防止扩容代价大，通过buff暂时储存，一段一段进
size_t i = 0;
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[127] = '\0';
s += ch;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
==
直接用strcmp函数去比较
bool operator==(const string& s)const
{
return strcmp(_str, s._str) == 0;
}
>
bool operator>(const string& s)const
{
return strcmp(_str, s._str) > 0;
}
>=
bool operator>=(const string& s)const
{
return *this > s || s == *this;
}
<
bool operator<(const string& s)const
{
return !(*this >= s);
}
<=
bool operator<=(const string& s)const
{
return !(*this > s);
}
!=
bool operator!=(const string& s)const
{
return !(*this == s);
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
