string的文档网站
string类的介绍以及一些常见问题
-
String是一个管理字符数组的类,要求这个字符数组结尾用 ‘\0’ 标识
- 涉及的问题如下:
- 拷贝构造和赋值重载实现 深拷贝
- 增删查改的相关接口
- 重载一些常见的运算符如:[] 、>> 、<< 等
- 迭代器
- 涉及的问题如下:
-
对于一个成员函数,什么时候该加const呢?
- 1 、如果是 只读函数 ,则要加 const
- 2 、如果是 只写函数 ,则不能加 const
- 3 、如果 既是可读又是可写的函数 ,则要重载两个版本的函数,即 const 版本与 非const 版本
String类的模拟实现 (定义在string.h中)
类的整体框架(简单的直接在框架实现了)
#include <iostream>
#include <cstring> //运用C++风格的头文件
#include <cassert>
using namespace std;
namespace liren //为了防止与库里的string的冲突,使用自己的命名空间
{
class string
{
public:
typedef char* iterator; //用于普通对象的迭代器
typedef const char* const_iterator; //用于const对象的迭代器
public:
string(const char* str = ""); //构造函数,且缺省值必须给"",而不是nullptr或者"\0"
~string(); //析构函数
string(const string& s); //现代写法的拷贝构造函数(深拷贝问题)
string& operator=(const string& s); //现代写法的赋值运算符重载(深拷贝问题)
void swap(string& s); //自己写的swap去调用全局swap完成类成员变量的交换
//
// iterator 与 const_iterator 迭代器
iterator begin() //用于普通对象,可读可写
{
return _str;
}
const_iterator begin() const //用于const对象,只能读
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator end() const
{
return _str + _size;
}
/
// capacity
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
bool empty() const
{
return _size == 0;
}
void reserve(size_t n); //预留空间(用于防止多次增容,提高效率)
void resize(size_t n, char c = '\0'); //设置有效字符个数
/
// access
char& operator[](size_t index)//at左右与[]类似,但是at越界是抛异常
{
assert(index < _size); //这里无需判断>=0的情况,因为index的类型是size_t
return _str[index];
}
//要写两个版本,因为如果是const对象调用operator[]的话,若没有两个版本则只能读不能写
const char& operator[](size_t index) const
{
assert(index < _size);
return _str[index];
}
//
// modify
void push_back(char c);
void append(const char* str); //追加一个字符串
string& operator+=(char c) //两个+=的重载函数可以调用上面的push_back以及append进行复用
{
push_back(c);
return _str;
}
string& operator+=(const char* str)
{
append(str);
return _str;
}
void clear()
{
_size = 0;
_str[_size] = '\0';
}
const char* c_str() const //因为该函数只读,所以用const修饰
{
return _str;
}
/
// 返回字符c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const;
// 返回子串s在string中第一次出现的位置
size_t find(const char* str, size_t pos = 0) const;
// 在pos位置上插入字符c/字符串str,并返回该字符的位置
string& insert(size_t pos, char c);
string& insert(size_t pos, const char* str);
// 删除pos位置上的元素,并返回该元素的下一个位置
string& erase(size_t pos, size_t len = npos);
private:
char* _str; //管理字符数组的指针
size_t _capacity; //数组的容量(不包括'\0')
size_t _size; //有效字符个数
static const size_t npos; //类外定义
};
/
// 表示关系的运算符重载(作为非成员函数重载)
// 以及输入输出的运算符重载
ostream& operator<<(ostream& out, const string& s);
istream& operator>>(istream& in, const string& s);
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 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 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;
}
const size_t string::npo = -1;
}
构造函数与析构函数(重点)
string(const char* str = "")
{
assert(str != nullptr);
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity + 1]; //这里要多留一个空间给'\0'
strcpy(_str, str);
}
---------------------------------------------------------------------
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
现代写法的拷贝构造以及赋值运算符重载(重点)
string(const string& s)
:_str(nullptr), //这里将_str置为nullptr是为了等会swap时候tmp最后析构,不会将随机值处的数据析构掉,而是析构nullptr
_size(0),
_capacity(0)
{
string tmp(s._str); //这里调用的是构造函数,而不是拷贝构造,如果调用拷贝构造,会死循环
this->swap(tmp); //具体看下面swap的实现,其实就是将成员函数交换了
}
-------------------------------------------------------------------------------
string& operator=(string s) //与拷贝构造不一样,这里使用传值
{
this->swap(s);
return *this;
}
//更严谨版本的 = 运算符重载(防止了自己给自己赋值,但是没必要这么写,因为基本没有自己给自己赋值的情况)
string& operator=(const string& s)
{
if(*this != s)
{
string tmp(s);
this->swap(tmp);
return *this;
}
}
注意事项:
- **拷贝构造 **是在 对象定义时候 操作的,所以这个时候不会去调用构造函数,所以此时 this 的 _str 指向的地址是随机的,而与 tmp 交换成员变量的数据之后,tmp 就指向了随机处,出了该作用域就析构了,就会将随机值处的数据析构掉,导致内存数据的丢失。为了避免这种情况,在拷贝构造的时候增加初始化列表对 this 的成员变量进行初始化,将 _str 置为 nullptr。
- 而 赋值运算符重载 是在 对象存在之后 进行的赋值,所以无需将 this 处的 _str 置为 nullptr 以及初始化成员变量
附:
此处又涉及一个概念,我们平常习惯于写成以下这种形式:
string s1 = "lirendada";
以vs编译器为例,上述代码其实是 隐式类型转换 :
- 编译器先将 “lirendada” 拿去调用 构造函数,再将这个 临时对象 赋给 s1
- 但现在编译器做了优化,会直接将上述代码转化为调用 拷贝构造函数
- 除此之外,可以用 explicit 关键字让编译器禁止这种隐式类型转换
swap 函数
void swap(string& s) //调用std库中的swap进行交换
{
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
reserve 函数
void reserve(size_t n) //为数组预留空间,若n小于_capacity则无需操作
{
if(n > _capacity)
{
char* tmp = new char[n + 1]; //多留一个位置给'\0'
//注意,这里要把_size + 1 个一起拷过去,不然最后一个位置的 '\0' 没有被传过去的话,字符串就没有了尾,就会有随机值
strncpy(tmp, _str, _size + 1);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
resize 函数
有两种情况:
n 如果 小于 _size 的话,直接将 _size 减少到 n 个.
n 如果 大于 _size 的话,要判断一下 n 是否大于 _capacity ,是的话就得 扩容 ,并且 填充字符c。
不是的话,直接填充字符c即可
void resize(size_t n, char c = '\0'); //设置有效字符个数
{
if(n > _size)
{
if(n > _capacity) //大于容量则要扩容
reserve(n);
memset(_str + _size, c, n - _size); //填充字符c
_str[n] = '\0'; //这步很关键,因为填充完后要将多留出的一位要置为'\0'
_size = n;
}
else
{
_size = n;
_str[_size] = '\0'; //记得最后一位置为'\0'
}
}
insert函数
//作用:在pos位置上插入 字符c 或者 字符串str ,并返回该字符的位置
//插入一个字符c
string& insert(size_t pos, char c)
{
assert(pos <= _size);
if(_size == _capacity)
reserve(_capacity == 0 ? 4 : _capacity * 2); // 这样子写防止容量为0的时候
size_t end = _size; //从后往前挪动数据
while(end > pos)
{
_str[end] = _str[end - 1];
--end;
}
_str[end] = c;
_size++;
_str[_size] = '\0'; //记得_size处置为'\0'
return *this;
}
//插入一个字符串str
string& insert(size_t pos, const char* str)
{
assert(pos <= _size);
int ls = strlen(str);
int len = _size + ls; //加起来的总长度
if(len > _capacity)
reserve(len);
//用指针挪动不容易出问题(顺便将'\0'也挪动了)
char* end = _str + _size;
while(end >= _str + pos)
{
*(end + ls) = *end;
end--;
}
strncpy(_str + pos, str, ls); //将str拷过去_str的pos处,长度为ls
_size = len;
return *this;
}
push_back函数
//1、第一种方法,自己实现
void push_back(char c)
{
if(_size == _capacity)
reserve(_capacity == 0 ? 4 : 2 * _capacity); // 这样子写防止容量为0的时候
_str[_size] = c;
_size++;
_str[_size] = '\0'; //记得最后一位置为'\0'
}
//2、第一种方法,自己实现
void push_back(char c)
{
this->insert(_size, c);
}
append函数
//1、第一种方法,自己实现
void append(const char* str)
{
}
//2、第一种方法,自己实现
void append(const char* str)
{
this->insert(_size, str);
}
erase函数
string& erase(size_t pos, size_t len = npos) //默认删除整个字符串
{
assert(pos < _size);
size_t leftLen = _size - pos;
if(leftLen <= len) //剩余的字符小于要删的长度
{
_str[pos] = '\0';
_size = pos;
}
else
{
strpy(_str + pos, _str + pos + len);
_size = len;
}
return *this;
}
find函数
// 返回字符c在string中第一次出现的位置
size_t find(char c, size_t pos = 0) const
{
assert(pos < _size);
for(size_t i = pos; i < _size; ++i)
{
if(_str[i] == c)
return i;
}
return npos;
}
// 返回子串s在string中第一次出现的位置
size_t find(const char* str, size_t pos = 0) const
{
assert(pos < _size);
//运用c的库函数strstr
const char* tmp = strstr(_str + pos, s);
if (tmp == nullptr)
return npos;
//两个指针相减求出该处的下标
return tmp - _str;
}
>> 与 << 运算符重载(作为非成员函数重载)
ostream& operator<<(ostream& out, const string& s)
{
//out << s._str << endl; 不能直接这样子,因为out遇到空格也会中断
for (auto i : s)
out << i;
return out;
}
istream& operator>>(istream& in, string& s)//注意s不能用const修饰
{
//in >> s._str; 不能这样子写,因为遇到空格就中断了输入
//char ch;
//in >> ch; //因为in是istream的对象,所以它遇见空格和换行也会中断
s.clear();//记得先清理一下
char ch = in.get();//get是istream库里的函数,接收的字符串不会因为空格而中断
while (ch != ' ' && ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}
附加:
istream& getline(istream& in, string& s)
{
//与 >> 的重载差不多,只不过遇到' ' 也就是空格也要接收
s.clear();
char ch = in.get();
while (ch != '\n')
{
s += ch;
ch = in.get();
}
return in;
}