上次介绍了标准库里的string类以及常用接口：【C++】String类：标准库介绍-CSDN博客
本次就来亲自动手来模拟实现下
目录
十一.关系比较运算符（relational operators）
一.基本结构
根据string标准库的文档：string - C++ Reference (cplusplus.com)
可以看见string类大致分为这么几个部分，那么我们的实现也根据这些功能来大致实现
此时，可以创建头文件：string.h 实现文件：string.cpp 测试文件：test.cpp
在自定义的命名空间内创建string类，配上基本结构：
namespace zyh
{
class string
{
public:
//各种函数
private:
char* _str;//没有设计成模板，直接使用char数组
size_t _size;//有效字符的个数
size_t _capacity;//分配空间的大小
static const size_t npos;//在外初始化为-1
};
}
二.构造函数（constructor）
1.构造函数
无参的构造函数，构造的是空字符串，但空字符串不代表什么都没有，只要是字符串，哪怕是空，也存在\0，这是字符串的标志，因此无参构造时也要开辟出一个char的空间并用\0来初始化
//无参
string()
:_str(new char[1]{'\0'})
,_size(0)
,_capacity(0)
{}
//有参
string(const char* str)
{
_size = strlen(str);
_capacity = _size;
//capactiy不包含'\0'
_str = new char[_capacity + 1];
strcpy(_str, str);
}当然也可以合二为一，直接使用缺省参数
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;
//capactiy不包含'\0'
_str = new char[_capacity + 1];
strcpy(_str, str);
}2.拷贝构造
传统写法：
string(const string& s)
{
_size = s._size;
_capacity = s._capacity;
_str = new char[_capacity + 1];
strcpy(_str, s._str);
}现代写法：使用中转站临时对象tmp来交换得到
要使用s1来拷贝构造s3,那么只需要使用s1的字符串来构造一个临时对象tmp，再将s3的内容与tmp进行交换即可
void swap(String& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
string(const string& s)
{
string tmp(s._str);
swap(tmp);
}3.c_str()
目前还没有对string类进行流操作的重载，因此想要打印字符串，此处提供c_str()方法来得到成员_str，以此来进行打印
const char* c_str()const
{
return _str;
}三.析构函数（destructor）
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}四.operator=
注意=（赋值运算）是有返回值的，返回值就是它本身，因此返回值类型为string&，同时为了防止自身给自身赋值，加入判断this是否指向参数，否则会出错
string& operator=(const string& s)
{
if (this != &s)
{
//清除旧空间
delete[] _str;
_size = s._size;
_capacity = s._capacity;
//开辟新空间
_str = new char[_capacity + 1];
//并且复制
strcpy(_str, s._str);
}
return *this;
}五.迭代器（iterator）
这里我们使用指针来模拟迭代器，那么就将char*类型的指针重命名为iterator
同理，那么const_iterator是针对常量的，那么就是对应const char*
//迭代器
typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{
return &_str[0];
}
iterator end()
{
return &_str[_size];
}
const_iterator begin()const
{
return _str;
}
const_iterator end()const
{
return _str + _size;
}六.容量操作（capacity）
//capacity
size_t size()const
{
return _size;
}
size_t capacity()const
{
return _capacity;
}
bool empty()const
{
return (_size == 0);
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
_capacity = n;
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
}
}
void resize(size_t n, char c)
{
if (n > _size)
{
int i = n - _size;
while (i--)
{
push_back(c);
}
}
_size = n;
}七.修改操作（modify）
void push_back(char c)
{
//扩容
if (_size == _capacity)
{
reserve(_capacity == 0 ? 4 : _capacity * 2);//考虑空的情况
}
_str[_size++] = c;
_str[_size] = '\0';
}
string& operator+=(char c)
{
push_back(c);
return *this;
}
void append(const char* str)
{
size_t len = strlen(str);
if (_size + len > _capacity)
{
reserve(_size + len);
}
strcpy(_str + _size, str);
_size = _size + len;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
void clear()
{
char* tmp = new char[_capacity + 1];
tmp[0] = '\0';
_str = tmp;
_size = 0;
}八.访问操作（access）
//access
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos)const
{
assert(pos >= 0 && pos < _size);
return _str[pos];
}九.查找操作（find）
size_t find(char c, size_t pos) const
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)
{
return i;
}
return npos;
}
}
size_t find(const char* s, size_t pos) const
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, s);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr - _str;
}
}十.插入和删除（insert and erase）
//在pos位置上插入字符c
string& insert(size_t pos, char c)
{
assert(pos <= _size);
if (_size == _capacity)
{
reserve((_capacity == 0) ? 4 : 2 * _capacity);
}
//向后移动
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end - 1];
end--;
}
_str[pos] = c;
_size++;
return *this;
}
//在pos位置上插入字符串str
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--;
}
for (size_t i = 0; i < len; i++)
{
_str[pos + i] = str[i];
}
_size += len;
return *this;
}
string& erase(size_t pos, size_t len)
{
assert(pos < _size);
if (len >= _size - pos)
{
_str[pos] = '\0';
_size = pos;
}
else
{
for (size_t i = pos + len; i <= _size; i++)
{
_str[i - len] = _str[i];
}
_size -= len;
}
return *this;
}十一.关系比较运算符（relational operators）
//使用strcmp实现两个即可，此处实现了小于和等于
//其余的使用已实现的逻辑即可
bool operator<(const string& s)
{
return strcmp(_str, s._str) < 0;
}
bool operator<=(const string& s)
{
return (*this < s) || (*this == s);
}
bool operator>(const string& s)
{
return !(*this <= s);
}
bool operator>=(const string& s)
{
return !(*this < s);
}
bool operator==(const string& s)
{
return strcmp(_str, s._str) == 0;
}
bool operator!=(const string& s)
{
return !(*this == s);
}十二.流操作重载
注意必须是全局声明，为什么？因为如果是成员函数，那么只需用this指针即可，但这样的话，就必须要string<<cout ( string.operator<<(cout) )了，很明显与平时使用的顺序不同，为了调整参数位置使得其按正确顺序，就必须声明在全局而不使用this指针，这一点友元就能做到。
还有值得注意的一点是返回值，必须是ostream&，这是为了能够连续的使用流操作符
//在外部实现，内部声明友元类
ostream& operator<<(ostream& _cout, const zyh::string& s)
{
for (auto ch : s)
{
_cout << ch;
}
return _cout;
}
istream& operator>>(istream& _cin, zyh::string& s)
{
s.clear();
//防止频繁扩容
const int N = 256;
char buff[N];
int i = 0;
char ch = _cin.get();
while (ch != ' ' && ch != '\n')
{
buff[i++] = ch;
if (i == N - 1)
{
buff[i] = '\0';
s += buff;
i = 0;
}
//s += ch;
ch = _cin.get();
}
buff[i] = '\0';
s += buff;
return _cin;
}
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
