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;
}
278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
