前言
本文介绍了string类的函数以及模拟实现
C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数。但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。因此在C++中引入了string类
提示：以下是本篇文章正文内容，下面案例可供参考
一、String类的内部成员变量有什么?
1.char* _str
char* _str 这个字符指针指向了string字符串中的第一个元素，从而可以访问到string。
2.size_t _size
用来保存字符串的长度。(注意_str[_size]一般为‘\0’)
3._capacity
用来保存字符串的容量。（一般开辟_capacity+1个大小）
4.static size_t npos=-1
方便进行后续的一系列操作。
代码如下（示例）：
class string{
private:
char* _str;
size_t _size;
size_t _capacity;
static size_t npos;
};
size_t string::npos = -1;
二、基本方法
1.构造函数
1.默认构造
通过传递给形参一个字符串并给它一个缺省值来进行默认构造
代码如下（示例）：
string(const char* str="")
{
_size = strlen(str);
_capacity = _size;
_str = new char[_capacity+1];
strcpy(_str, str);
}
2.深拷贝构造
通过传入一个string类型的参数，通过其_capacity,strcpy函数来构造*this。
代码如下（示例）：
string(const string& st)
{
_str = new char[st._capacity];
strcpy(_str, st._str);
_size = st._size;
_capacity = st._capacity;
}
3.赋值运算符的重载
首先通过引用将st传入，然后通过深拷贝创建一个temp变量。然后将this与temp变量值交换一下。最后通过返回 *this再拷贝构造一个新的变量。
代码如下(示例)：
string operator=(const string& st)
{
string temp(st);
swap(temp);
return *this;
}
2.迭代器及其部分运算符的实现
1.正向迭代器
代码如下（示例）：
首先使用typedef对char进行封装。
begin返回字符串第一个字符所在的位置，end返回最后一个字符的后一个位置。
因为char本身可以++ – 以及*。所以在此没有写其的重载。
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类中再定义一个ReverseIterator类，即通过正向迭代器将反向迭代器封装。
rbegin()返回end()，rend()返回begin()的位置。
例如定义了一个jjw::string::reverse_iterator it = st1.rbegin();
++it 相当于–it，–it相当于++it。注意这里对it解引用返回的是it的上一个位置的字符(因为rbegin是返回的end的位置)，这样才可以保证全部遍历完成。
代码如下（示例）：
class _ReverseIterator {
private:
iterator _it;
public:
typedef _ReverseIterator self;
_ReverseIterator(string::iterator it)
:_it(it)
{}
self& operator++()
{
return _ReverseIterator(--_it);
}
self& operator--()
{
return _ReverseIterator(++_it);
}
bool operator!=(_ReverseIterator it)
{
return it._it != _it;
}
char operator*()
{
return *(_it-1);
}
};
typedef _ReverseIterator reverse_iterator;
reverse_iterator rbegin()
{
_ReverseIterator it(end());
return it;
}
reverse_iterator rend()
{
return _ReverseIterator(begin());
}
// 在main函数中 这样即可遍历一次st1
jjw::string st1 = "hello world";
jjw::string::reverse_iterator it = st1.rbegin();
while (it != st1.rend())
{
cout << *it;
it++;
}
cout << endl;
3.运算符以及输入输出流的重载
1. > < == >= <=的重载
因为有一点冗余，所以以小于为例说明。
这里我们先使用memcmp函数进行比较（注意我们比较的长度是两个字符串当中较小的那一个）
如果ret==0 则就去看它俩的长度，如果_size1 <_size2 说明 str1<str2
如果ret!=0 则就去看ret是否小于0，小于0说明str1<str2
其他几个同理。
bool operator<(const string& s)
{
int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
return ret == 0 ? _size < s._size : ret<0;
}
bool operator>(const string& s)
{
int ret = memcmp(_str, s._str, _size < s._size ? _size : s._size);
return ret == 0 ? _size>s._size:ret>0;
}
bool operator==(const string& s)
{
if (s._size == _size)
{
int ret = memcmp(_str, s._str, _size);
return ret == 0 ? 1 : 0;
}
else
return 0;
}
bool operator>=(const string& s)
{
return (*this > s) || (*this == s);
}
bool operator<=(const string& s)
{
return (*this < s) || (*this == s);
}
2. 流输入，流输出的重载
因为流输入流输出函数的第一个形参必须为流，所以我们需要将其定义在类外（因为类内默认第一个参数为this指针）。而我们还需要去访问_str来获取字符串，所以我们需要将其设置为友元函数。
这里流输入预先定义了一个字符数组，是为了避免多次开空间。
注意每次读数据需要将内存中的空格以及换行读出。
class string{ //在类内声明友元
friend ostream& operator<<(ostream& out, const jjw::string& s);
friend istream& operator>>(ostream& in, const jjw::string& s);
friend istream& getline(istream& in, string& str);
}
ostream& operator<<(ostream& out, const jjw::string& s)
{
for (auto e : s)
{
out << e;
}
return out;
}
istream& operator>>(istream& in, jjw::string& s)
{
char ch = in.get();
while (ch == ' ' || ch == '\n')
ch = in.get();
char buff[128] = { '\0' };
int i = 0;
s.clear();
while (ch != ' '&&ch != '\n')
{
buff[i++] = ch;
if (i == 127)
{
buff[i] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i != 0)
{
buff[i] = '\0';
s += buff;
}
return in;
}
istream& getline(istream& in, string& str) //每次读一行的数据给str
{
char ch = in.get();
while (ch == '\n')
ch = in.get();
str.clear();
while (ch != '\n')
{
str += ch;
ch = in.get();
}
str[str.size()] = '\0';
return in;
}
三.实用方法
1.reserve函数
reserve扩容函数，输入一个size_t的容量，若其大于_capacity，则就去扩容。
void reserve(size_t new_capacity)
{
if (_capacity < new_capacity)
{
char* temp = new char[new_capacity + 1];
if (_str != nullptr)
{
strcpy(temp, _str);
}
_capacity = new_capacity;
delete[] _str;
_str = temp;
}
}
2.push_back函数
在字符串末尾追加一个x字符，如果容量不够了就去先扩容
void push_back(char x)
{
if (_size == _capacity)
{
if (_size == 0)
reserve(1);
else
reserve(_size * 2);
}
_str[_size] = x;
_size++;
_str[_size] = '\0';
}
3. append函数
在字符串末尾追加一个新的字符串
扩容后直接调用strcpy()函数
void append(const char* str)
{
size_t length = strlen(str);
if (_size + length > _capacity)
{
reserve(_size + length + 1);
}
/*for (size_t i = 0; i < length; i++)
{
push_back(str[i]);
}*/
strcpy(_str + _size, str);
_size += length;
_str[_size] = '\0';
}
4. += 运算符的重载
+= 既可以追加字符，也可以追加字符串
直接调用push_back or append即可完成
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(char* str)
{
append(str);
return *this;
}
5.insert函数
1.在第pos个位置插入n个字符
void insert(size_t pos, size_t n, char ch) //在pos下标位置插入n个ch
{
assert(pos <= _size&&pos >= 0); //断言 pos必须在有效位内
if (_size + n> _capacity) // 容量不够则去扩容
{
reserve(_size + n + 1);
}
for (size_t i = 0; i < n; i++) // 移动元素，腾出位置
{
_str[_size + i] = _str[pos + i];
}
for (size_t i = 0; i < n; i++) //插入元素
{
_str[pos + i] = ch;
}
_size += n;
_str[_size] = '\0';
}
2.在pos位置上插入字符串
void insert(size_t pos, const char* str) // 在pos位置上插入字符串str
{
assert(pos <= _size&&pos >= 0);
size_t length = strlen(str);
if (length + _size>_capacity)
{
reserve(length + _size + 1);
}
for (size_t i = 0; i < length; i++)
{
_str[_size + i] = _str[pos + i]; //注意这里移动元素与上述不同
}
for (size_t i = 0; i < length; i++)
{
_str[pos + i] = str[i];
}
_size += length;
_str[_size] = '\0';
}
6. c_str()函数
char* c_str()
{
return _str;
}
7.swap函数
void swap(string& st)
{
std::swap(_str, st._str);
std::swap(_size, st._size);
std::swap(_capacity, st._capacity);
}
8.erase函数
从pos位置开始 将后面的len个字符全部删除
- 如果是将pos位置后面的全部删除，则直接令_str[pos]='\0’即可（这里就体现出npos的作用）
- 如果删除len个，则需要移动元素
void erase(size_t pos, size_t len = npos)
{
assert(pos >= 0 && pos < _size);
if (len == npos || pos + len>_size)
{
_str[pos] = '\0';
_size = pos;
}
else
{
size_t i = pos, j = pos + len;
for (; j <= _size; j++, i++)
{
_str[i] = _str[j];
}
}
}
9. Find函数
1.从pos位置寻找字符ch，找不到则返回npos
size_t Find(char ch, size_t pos = 0)
{
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == ch)
return i;
}
return npos;
}
2.从pos位置寻找字符串str，找不到返回npos
size_t Find(const char* str, size_t pos = 0)
{
assert(pos < _size);
size_t i = pos, j = 0;
while (i < _size&&j < strlen(str))
{
if (_str[i] == str[j])
i++, j++;
else
{
i = i - j + 1;
j = 0;
}
}
if (j == strlen(str))
//找到了
return i - strlen(str);
else
return npos;
}
10.substr函数
从pos位置截取长度为len的字符串，并将其返回
string substr(size_t pos = 0, size_t len = npos)//从pos截取长度为len的字符串
{
size_t n = len;
if (len == npos || len + pos > _size) // 说明pos后全部截取
{
n = _size - pos;
}
string temp;
temp.reserve(n + 1); // 开空间
for (size_t i = pos; i < pos + n; i++)
{
temp += _str[i]; // 遍历+=即可
}
temp[_size] = '\0';
return temp;
}
11.resize函数
变换str中的有效容量
如果n<=_size，直接截取。
如果n>_size,扩容，将ch依次填充。
void resize(size_t n, char ch = '\0'){ //扩大_size，如果n<_size,则舍去，否则扩容
if (n < _size)
{
_size = n;
_str[_size] = '\0';
}
else
{
reserve(n);
for (int i = _size; i < n; i++)
{
_str[i] = ch;
}
_size = n;
_str[_size] = '\0';
}
}
12. clear函数
对其_size,_capacity设置为0，但并不删除其原空间
void clear() //不释放空间
{
_size = 0;
}
13.size,capacity以及empty函数
size_t capacity()
{
return _capacity;
}
size_t size()
{
return _size;
}
bool empty()
{
if (_size == 0 && _capacity == 0)
return true;
else
return false;
}
总结
以上就是string的常用函数以及模拟实现（本人小白一枚，若有错误还望各位指正）
完整的代码存放在gitee上：https://gitee.com/jj-wen/c-beginner/commit/820d3d28b5fd76d4531353e448b280497d8ea9f1
学习任重而道远，希望自己可以坚持下去。
1450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
