1.函数的头文件
最好是定义在自己的命名空间里面，避免和已有的冲突。
namespace bt
{
//模拟实现string类
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
string(const char* str = ""); //构造函数
string(const string& s); //拷贝构造函数
string& operator=(const string& s); //赋值运算符重载函数
~string(); //析构函数
//迭代器
iterator begin();
iterator end();
const_iterator begin()const;
const_iterator end()const;
//容量和大小相关
size_t size();
size_t capacity();
void reserve(size_t n);
void resize(size_t n, char ch = '\0');
bool empty()const;
//字符串相关
void push_back(char ch);
void append(const char* str);
string& operator+=(char ch);
string& operator+=(const char* str);
string& insert(size_t pos, char ch);
string& insert(size_t pos, const char* str);
string& erase(size_t pos, size_t len);
void clear();
void swap(string& s);
const char* c_str()const;
//访问字符串相关
char& operator[](size_t i);
const char& operator[](size_t i)const;
size_t find(char ch, size_t pos = 0)const;
size_t find(const char* str, size_t pos = 0)const;
size_t rfind(char ch, size_t pos = npos)const;
size_t rfind(const char* str, size_t pos = 0)const;
//运算符重载函数
bool operator>(const string& s)const;
bool operator>=(const string& s)const;
bool operator<(const string& s)const;
bool operator<=(const string& s)const;
bool operator==(const string& s)const;
bool operator!=(const string& s)const;
private:
char* _str; //存储字符串
size_t _size; //记录字符串当前长度
size_t _capacity; //记录字符串当前容量
static const size_t npos; //静态成员变量（整型最大值）
};
const size_t string::npos = -1;
//运算符重载函数
istream& operator>>(istream& in, string& s);
ostream& operator<<(ostream& out, const string& s);
istream& getline(istream& in, string& s);
}
2.默认成员函数的实现
2.1构造函数
自带缺省参数，不传参时为空串，同时初始化字符串的大小和容量。
代码：
string(const char* str = "")
{
_size=strlen(str);
_capacity=_size;
_str=new char[_capacity+1];
strcpy(_str,str);
}
2.2拷贝构造函数
有关于深浅拷贝：
浅拷贝（一个字节一个字节的拷贝）：拷贝出来的目标对象的指针和原对象的指针指向的空间是同一块空间。
深拷贝（值拷贝）：深拷贝是指原对象与拷贝对象互相独立。
我们肯定不想我们写的函数是浅拷贝，于是我们必须实现深拷贝，深拷贝也有两种方法：
2.2.1方法一（传统写法）
思路很简单：先给拷贝对想开出可以容纳原对象的空间，然后把原对象赋值过去。
代码：
string(const string& s)
:_str(new char[s._capacity + 1])
, _size(0)
, _capacity(0)
{
strcpy(_str, s._str); //将s._str拷贝一份到_str
_size = s._size; //_size赋值
_capacity = s._capacity; //_capacity赋值
}
2.2.2方法二（现代写法）
思路：先根据原字符串调用拷贝构造函数生成tmp对象，然后交换tmp对象和拷贝对象。
代码：
string(const string& s)
:_str(nullptr)
, _size(0)
, _capacity(0)
{
string tmp(s._str);
swap(tmp);
}
2.3赋值运算符重载函数
和拷贝构造函数相同，也存在深浅拷贝的问题。同样也是有两种写法：
2.3.1传统写法
代码：
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;//(支持连续赋值）
}
2.3.2现代写法
与拷贝构造函数也十分类似：
代码1：
string& operator=(string s) //接收右值的时候自动调用拷贝构造函数
{
swap(s);
return *this; //（支持连续赋值）
}
代码2：
防止自己赋值给自己
string& operator=(const string& s)
{
if (this != &s) //防止自己给自己赋值
{
string tmp(s);
swap(tmp);
}
return *this; //（支持连续赋值）
}
但是，几乎不存在自己赋值给自己，所以代码1就够了。
2.4析构函数
string类的析构函数需要我们自己编写，因为每个string对象中的成员_str都指向堆区的一块空间，当对象销毁时堆区对应的空间并不会自动销毁，为了避免内存泄漏，我们需要使用delete手动释放堆区的空间。
~string()
{
delete[] _str; //释放_str指向的空间
_str = nullptr; //置空，防止非法访问
_size = 0;
_capacity = 0;
}
3.迭代器
string类中迭代器实际就是字符指针。
typedef char* iterator;
typedef const char* const_iterator;
3.1begin
返回字符串第一个字符的地址。
iterator begin()
{
return _str; //返回字符串中第一个字符的地址
}
const_iterator begin()const
{
return _str; //返回字符串中第一个字符的const地址
}
3.2end
返回字符串最后一个字符的后一个字符的地址（'\0'的地址）。
iterator end()
{
return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
}
const_iterator end()const
{
return _str + _size; //返回字符串中最后一个字符的后一个字符的const地址
}
迭代器遍历string：（实质上就是指针遍历）
string s("hello world");
string::iterator it = s.begin();
while (it != s.end())
{
cout << *it << " ";
it++;
}
cout << endl;
string的范围for遍历，实际上for遍历会自动替换为迭代器遍历。
string s("hello world");
for (auto e : s)
{
cout << e << " ";
}
cout << endl;
4.容量相关函数
4.1size和capacity
size用来获取字符串当前的有效长度（除‘\0’）
size_t size()const
{
return _size; //返回字符串当前的有效长度
}
capacity用来获取当前字符串容量
size_t capacity()const
{
return _capacity; //返回字符串当前的容量
}
4.2reserve和resize
reserve规则：
1、当n大于对象当前的capacity时，将capacity扩大到n或大于n。
2、当n小于对象当前的capacity时，什么也不做。
void reserve(size_t n)
{
if (n > _capacity) //当n大于对象当前容量时才需执行操作
{
char* tmp = new char[n + 1]; //多开一个空间用于存放'\0'
strncpy(tmp, _str, _size + 1);
delete[] _str; //释放对象原本的空间
_str = tmp; //将新开辟的空间给_str
_capacity = n; //容量跟着改变
}
}
注意：这里要用strncpy,主要是防止出现_str="hello\0\0\0\0"而漏拷贝，这样就可以拷贝多个“\0”。
resize规则：
1、当n大于当前的size时，将size扩大到n，扩大的字符为ch，若ch未给出，则默认为’\0’。
2、当n小于当前的size时，将size缩小到n。
void resize(size_t n, char ch = '\0')
{
if (n <= _size) //n小于当前size
{
_size = n;
_str[_size] = '\0'; //在size个字符后放上'\0'
}
else
{
if (n > _capacity) //判断是否需要扩容
{
reserve(n);
}
for (size_t i = _size; i < n; i++) //将size扩大到n，扩大的字符为ch
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0'; //字符串后面放上'\0'
}
}
4.3empty
用strcmp判空
bool empty()
{
return strcmp(_str, "") == 0;
}
5.修改字符串相关函数
5.1push_back
push_back函数的作用就是在当前字符串的后面尾插上一个字符，尾插之前首先需要判断是否需要增容，若需要，则调用reserve函数进行增容，然后再尾插字符，注意尾插完字符后需要在该字符的后方设置上’\0’，否则打印字符串的时候会出现非法访问，因为尾插的字符后方不一定就是’\0’。
void push_back(char ch)
{
if (_size == _capacity) //判断是否需要增容
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
_str[_size] = ch;
_size++;
_str[_size] = '\0';
}
5.2append
append的作用是在当前字符串后面插一个字符串，尾插前还是要判断能否容纳，不能则增容；
然后再将待尾插的字符串插入，因为待尾插字符串后方自身有‘\0’,所以无需设置。
void append(const char* str)
{
size_t len = _size + strlen(str);
if (len > _capacity) //判断是否需要增容
{
reserve(len);
}
strcpy(_str + _size, str);
_size = len;
}
5.3operator+=
拼接字符：
string& operator+=(char ch)
{
push_back(ch); //尾插字符串
return *this; //（支持连续+=）
}
拼接字符串：
string& operator+=(const char* str)
{
append(str); //尾插字符串
return *this; //（支持连续+=）
}
5.4insert
insert函数的作用是在字符串的任意位置插入字符或是字符串。
插入字符：
string& insert(size_t pos, char ch)
{
assert(pos <= _size); //检测下标的合法性
if (_size == _capacity) //判断是否需要增容
{
reserve(_capacity == 0 ? 4 : _capacity * 2);
}
char* end = _str + _size;
//将pos位置及其之后的字符向后挪动一位
while (end >= _str + pos)
{
*(end + 1) = *(end);
end--;
}
_str[pos] = ch; //pos位置放上指定字符
_size++;
return *this;
}
插入字符串：
string& insert(size_t pos, const char* str)
{
assert(pos <= _size); //检测下标的合法性
size_t len = strlen(str);
if (len + _size > _capacity) //判断是否需要增容
{
reserve(len + _size);
}
char* end = _str + _size;
//将pos位置及其之后的字符向后挪动len位
while (end >= _str + pos)
{
*(end + len) = *(end);
end--;
}
strncpy(_str + pos, str, len); //pos位置开始放上指定字符串
_size += len;
return *this;
}
5.5erase
分两钟情况：1、pos位置及其之后的有效字符都需要被删除。
2、pos位置及其之后的有效字符只需删除一部分。
string& erase(size_t pos, size_t len = npos)
{
assert(pos < _size);
size_t n = _size - pos; //pos位置及其后面的有效字符总数
if (len >= n) //说明pos位置及其后面的字符都被删除
{
_size = pos; //size更新
_str[_size] = '\0'; //字符串后面放上'\0'
}
else
{
strcpy(_str + pos, _str + pos + len); //用需要保留的有效字符覆盖需要删除的有效字符
_size -= len; //size更新
}
return *this;
}
5.6clear
void clear()
{
_size = 0; //size置空
_str[_size] = '\0'; //字符串后面放上'\0'
}
5.7swap
直接调用库里的swap模板函数将对象的各个成员变量进行交换即可，但我们若是想在这里调用库里的swap模板函数，需要在swap函数之前加上“::”（作用域限定符） 。
void swap(string& s)
{
//调用库里的swap
::swap(_str, s._str);
::swap(_size, s._size);
::swap(_capacity, s._capacity);
}
5.8c_str(返回C类型的字符串)
const char* c_str()const
{
return _str;
}
6.访问字符串相关函数
6.1operator[ ]
可读可写：
//[]运算符重载（可读可写）
char& operator[](size_t i)
{
assert(i < _size); //检测下标的合法性
return _str[i]; //返回对应字符
}
只读：
//[]运算符重载（只读）
const char& operator[](size_t i)const
{
assert(i < _size); //检测下标的合法性
return _str[i]; //返回对应字符
}
6.2find和rfind
6.2.1find
正向查找第一个匹配的字符：
size_t find(char ch, size_t pos = 0)
{
assert(pos < _size); //检测下标的合法性
for (size_t i = pos; i < _size; i++) //从pos位置开始向后寻找目标字符
{
if (_str[i] == ch)
{
return i;
}
}
return npos; //没有找到目标字符，返回npos（整型的最大值）
}
正向查找第一个匹配的字符串：
size_t find(const char* str, size_t pos = 0)
{
assert(pos < _size); //检测下标的合法性
const char* ret = strstr(_str + pos, str); //调用strstr进行查找
if (ret) //ret不为空指针，说明找到了
{
return ret - _str; //返回字符串第一个字符的下标
}
else
{
return npos;
}
}
6.2.2rfind
我们可以利用镜面对称的思想来复用find。
反向查找第一个匹配的字符：
size_t rfind(char ch, size_t pos = npos)
{
string tmp(*this); //拷贝构造对象tmp
reverse(tmp.begin(), tmp.end());
if (pos >= _size)
{
pos = _size - 1;
}
pos = _size - 1 - pos;
size_t ret = tmp.find(ch, pos); //复用find函数
if (ret != npos)
return _size - 1 - ret; //找到了，返回ret镜像对称后的位置
else
return npos; //没找到，返回npos
}
反向查找第一个匹配的字符串：
size_t rfind(const char* str, size_t pos = npos)
{
string tmp(*this); //拷贝构造对象tmp
reverse(tmp.begin(), tmp.end());
size_t len = strlen(str);
char* arr = new char[len + 1];
strcpy(arr, str); //拷贝str给arr
size_t left = 0, right = len - 1; //设置左右指针
//逆置字符串arr
while (left < right)
{
::swap(arr[left], arr[right]);
left++;
right--;
}
if (pos >= _size)
{
pos = _size - 1; //重新设置pos为字符串最后一个字符的下标
}
pos = _size - 1 - pos;
size_t ret = tmp.find(arr, pos); //复用find函数
delete[] arr; //销毁arr指向的空间，避免内存泄漏
if (ret != npos)
return _size - ret - len; //找到了，返回ret镜像对称后再调整的位置
else
return npos; //没找到，返回npos
}
7.关系运算符重载函数
关系运算符有 >、>=、<、<=、==、!= 这六个，但是对于C++中任意一个类的关系运算符重载，我们均只需重载其中的两个，剩下的四个关系运算符可以通过复用已经重载好了的两个关系运算符来实现。
对于string类，我们可以选择只重载 > 和 == 这两个关系运算符。
//>运算符重载
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) || (*this == s);
}
//<运算符重载
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);
}
8.读写运算符函数
8.1>>
istream& operator>>(istream& in, string& s)
{
s.clear(); //清空字符串
char ch = in.get(); //读取一个字符
while (ch != ' '&&ch != '\n') //当读取到的字符不是空格或'\n'的时候继续读取
{
s += ch; //将读取到的字符尾插到字符串后面
ch = in.get(); //继续读取字符
}
return in; //支持连续输入
}
8.2<<
ostream& operator<<(ostream& out, const string& s)
{
//使用范围for遍历字符串并输出
for (auto e : s)
{
out << e;
}
return out; //支持连续输出
}
8.3getline
istream& getline(istream& in, string& s)
{
s.clear(); //清空字符串
char ch = in.get(); //读取一个字符
while (ch != '\n') //当读取到的字符不是'\n'的时候继续读取
{
s += ch; //将读取到的字符尾插到字符串后面
ch = in.get(); //继续读取字符
}
return in;
}
扫一扫
1330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
