文章目录
⚽前言
C标准库中也提供了一系列的str库函数，但不符合oop思想（核心：封装、继承、多态），所以C++引入了string类，在OJ中很多有关字符串的题目都是以string类形式出现的，下面我们来深入了解一下
string类是由STL中类模板basic_string实例化的具体的类
因为字符类型不只是有char，还有char16_t，wchar_t等
string类可以理解为一个动态增长的顺序表，底层是一块连续的数组，当
字符串长度小于16时在栈上申请空间，之后才在堆上申请空间
我们可以通过一个简单的测试证明
#include <iostream>
#include <string>
using namespace std;
int main()
{
//s1的字符串长度小于16
string s1("2222222222");
//s2的字符串长度大于16
string s2("222222222222222222");
cout << sizeof(s1) << endl;
cout << sizeof(s2) << endl;
return 0;
}
s1的字符串是存在数组_Buf中的
s2的字符串是在堆上开辟空间由_Ptr指针维护的
且我们计算两个对象的大小都是28
所以string类的大致框架如下：
class string
{
private:
//四个成员变量大小刚好是28
char _Buffer[16]; //长度小于16直接存在buffer数组中
char* _Ptr; //长度大于16再从堆上申请空间
size_t _Mysize; //存储的有效字符个数
size_t _Myres; //存储有效字符的容量
};
同时string也不是直接从堆上申请空间的，避免频繁从堆上申请空间，底层是通过内存池申请的，我们简易模拟实现直接在堆上申请，模拟实现的大致框架如下：
template<class T>
class basic_string
{
private:
//去掉了buffer，统一在堆上申请空间
char* _str;
size_t size; //有效字符个数
size_t capacity; //存储有效字符容量
};
typedef basic_string<char> string;
⚽模拟实现
由于库中有的函数会重载很多版本，所以模拟实现时只会重载一些常用的版本
⭐构造函数
#include <iostream>
#include <string>
using namespace std;
namespace king //由于会和std中的string冲突，所以我们在自己的命名空间实现
{
class string
{
public:
string(const char* str = "") //采用缺省参数，模拟实现上面的1和4
:_size(strlen(str))
, _capacity(_size)
{
_str = new char[_size + 1];
strcpy(_str, str);
}
private:
char* _str;
size_t _size; //有效字符个数
size_t _capacity; //只算存储有效字符的容量，不计入'\0',new的时候直接+1
};
}
⭐拷贝构造
拷贝构造肯定是深拷贝
//复用构造函数初始化tmp，然后交换*this与tmp，由于tmp只在当前作用域，出了作用域会调用析构函数，所以将_str先初始化为nullptr
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//s1(s2)
string(const string& s)
:_str(nullptr)
{
string tmp(s._str);
swap(tmp);
}
⭐赋值运算符重载
//s1=s2
string& operator=(const string& s)
{
if (this != &s)
{
//同样玩的是拷贝构造的套路，复用拷贝构造初始化tmp
//然后交换*this与tmp，tmp同样会调用析构函数释放原来*this维护的空间
string tmp(s);
swap(tmp);
}
return *this;
}
⭐析构函数
~string()
{
delete[] _str; //释放空间
_str = nullptr; //置空
_size = _capacity = 0; //置0
}
⭐计算size和capacity
这里size和capacity肯定是不可以直接改动的，所以成员函数要用const修饰
-
size：返回字符串有效字符长度（个数）
-
capacity：返回可存储有效字符的空间总大小
const size_t size() const
{
return _size;
}
const size_t capacity() const
{
return _capacity;
}
其实在STL出来之前就已经有string类了，所以最开始使用的是
lenth()而不是size()， size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器像vector、list的接口保持一 致，一般情况下基本都是用size()。
⭐重载[]
- 功能：返回pos位置的字符
重载了两个版本，const对象不可被修改，而非const对象可以通过[]修改对应的字符
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
⭐c_str
- 功能：返回指向字符数组的指针
const char* c_str() const
{
return _str;
}
⭐clear
- 功能：清空有效字符
//这里不会讲capacity置空，以空间换时间
void clear()
{
_size = 0;
_str[0] = '\0';
}
⭐迭代器区间
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;
}
写到这里我们就可以验证范围for的底层就是一个迭代器
在没有修改begin和end之前，范围for是可以跑起来的
将bengin和end修改后，范围for就失效了
⭐增
⚡reserve函数
- 功能：为字符串预留空间，如果给的n小于等于capacity则不处理，n大于*capacity，就改变capacity的大小
void reserve(size_t n)
{
//只处理大于size的
if (n > _capacity)
{
char* tmp = new char[n + 1]; //为'\0'预留空间
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
//这里是将capacity直接换成了给定的n，与库中的有所区别，大家下去可以验证一下库中是如何处理的
_capacity = n;
}
}
⚡resize函数
- 功能：将有效字符的个数该成n个，多出的空间用字符c填充，默认填充’\0’
情况一：n<=_size，将_size变为n
情况二：_size < n <= _capaicty，将n-_size个空间填充为ch
情况三：n > _capacity 扩容
void resize(size_t n, char ch = '\0')
{
// n小于等于size时，只保留n个字符
if (n <= _size)
{
_size = n;
}
//n大于size时
else
{
//大于capacity就要扩容
if (n > _capacity)
{
reserve(n); //复用reserve函数
}
memset(_str + _size, ch, n - _size);
_size = n;
}
_str[_size] = '\0'; //最后添加'\0'结尾
}
⚡push_back尾插
void push_back(char ch)
{
if (_capacity == _size)//判断是否需要扩容
reserve(_capacity == 0 ? 4 : _capacity * 2); //还需要判断_capacity是否为0
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
⚡append字符串追加
void append(const char* str)
{
size_t len = strlen(str); //计算需要追加的字符串长度
if (_capacity < len + _size)
reserve(len + _size); //扩容指定长度，因为len的长度不确定，所以无法直接扩2倍
strcpy(_str + _size, str);
_size = len + _size;
}
⚡operator+=
我们一般+=用 的比较多，不管是字符还是字符串都可以用
//直接复用上面的push_back和append函数即可
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
⚡insert函数
- 功能：指定位置插入
//从pos位置插入n个字符ch
string& insert(size_t pos, size_t n, char ch)
{
assert(pos <= _size); //断言pos最多只能在\0位置插入
if (_size + n > _capacity)
reserve(_size + n); //新的有效字符个数
size_t end = _size + n;
while (end >= pos + n)
{
_str[end] = _str[end - n];
--end;
}
memset(_str + pos, ch, n);
_size += n; // 更新_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)
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
⭐删
功能：从pos位置删除len个字符
这里的npos是一个静态的成员常量，npos为42亿9千万，是_size的最大值，C++不认为一个字符串会超过这么大，而len默认是npos，意为删除string对象从pos位置开始的所有字符
namespace king
{
class string
{
public:
string& erase(size_t pos = 0, size_t len = npos)
{
assert(pos < _size); //断言pos必须要小于_size
if (len == npos || len + pos >= _size)
{
_size = pos;
_str[_size] = '\0';
}
else
{
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;
}
private:
char* _str;
size_t size;
size_t capacity;
static const size_t npos;
};
const size_t string::npos = -1; //将npos初始化为-1
}
⭐查
查找不到时返回npos
//从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
size_t find(char ch, size_t pos = 0)
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (ch == _str[i])
return i;
}
return npos;
}
//从字符串pos位置开始往后找匹配的字符串str，返回匹配的字符串的首位置
size_t find(const char* str, size_t pos = 0)
{
assert(pos < _size);
const char* p = strstr(_str + pos, str);
if (p == nullptr)
return npos;
else
return p - _str;
}
还有rfind函数从字符串pos位置从后往前找，大家有兴趣也可以实现一下
⭐改
修改的话，上面重载[]或是用迭代器就可以修改指定字符
⭐重载<<和>>
如果重载成成员函数，隐藏的this指针要是左操作数，调用时只能这样调用，看起来非常别扭，所以将这里的两个重载函数定义为全局的
string s("hello");
s >> cin;
s << cout;
ostream& operator<<(ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
out << (s[i]);
}
//out << s.c_str() << endl;
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear(); //先清空s的有效字符
char ch = cin.get(); //每次读取一个字符
while (ch != '\n' && ch != ' ')
{
s += ch;
ch = in.get();
}
return in;
}
⚽源码
#include <iostream>
#include <string>
using namespace std;
namespace king
{
class string
{
public:
typedef char* iterator;
typedef const char* const_iterator;
string(const char* str = "")
:_size(strlen(str))
, _capacity(_size)
{
_str = new char[_size + 1];
strcpy(_str, str);
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
//s1(s2)
string(const string& s)
:_str(nullptr)
{
string tmp(s._str);
swap(tmp);
}
//s1=s2
string& operator=(const string& s)
{
if (this != &s)
{
string tmp(s);
swap(tmp);
}
return *this;
}
const size_t size() const
{
return _size;
}
const size_t capacity() const
{
return _capacity;
}
char& operator[](size_t pos)
{
assert(pos < _size);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
const char* c_str() const
{
return _str;
}
void clear()
{
_size = 0;
_str[0] = '\0';
}
iterator begin()
{
return _str;
}
iterator end()
{
return _str + _size;
}
const_iterator begin() const
{
return _str;
}
const_iterator end() const
{
return _str + _size;
}
void reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void resize(size_t n, char ch = '\0')
{
if (n <= _size)
{
_size = n;
}
else
{
if (n > _capacity)
{
reserve(n);
}
memset(_str + _size, ch, n - _size);
_size = n;
}
_str[_size] = '\0';
}
void push_back(char ch)
{
if (_capacity == _size)
reserve(_capacity == 0 ? 4 : _capacity * 2);
_str[_size] = ch;
++_size;
_str[_size] = '\0';
}
void append(const char* str)
{
size_t len = strlen(str);
if (_capacity < len + _size)
reserve(len + _size);
strcpy(_str + _size, str);
_size = len + _size;
}
string& operator+=(char ch)
{
push_back(ch);
return *this;
}
string& operator+=(const char* str)
{
append(str);
return *this;
}
size_t find(char ch, size_t pos = 0)
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (ch == _str[i])
return i;
}
return npos;
}
size_t find(const char* str, size_t pos = 0)
{
assert(pos < _size);
const char* p = strstr(_str + pos, str);
if (p == nullptr)
return npos;
else
return p - _str;
}
string& insert(size_t pos, size_t n, char ch)
{
assert(pos <= _size);
if (_size + n > _capacity)
reserve(_size + n); //新的有效字符个数
size_t end = _size + n;
while (end >= pos + n)
{
_str[end] = _str[end - n];
--end;
}
memset(_str + pos, ch, n);
_size += n; // 更新_size
return *this;
}
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)
{
_str[end] = _str[end - len];
--end;
}
strncpy(_str + pos, str, len);
_size += len;
return *this;
}
string& erase(size_t pos = 0, size_t len = npos)
{
assert(pos < _size);
if (len == npos || len + pos >= _size)
{
_size = pos;
_str[_size] = '\0';
}
else
strcpy(_str + pos, _str + pos + len);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
private:
char* _str;
size_t _size;
size_t _capacity; //只算有效字符个数，不计入'\0',new的时候直接+1
static const size_t npos;
};
const size_t string::npos = -1;
//cout << s1 << s2;
ostream& operator<<(ostream& out, const string& s)
{
for (size_t i = 0; i < s.size(); i++)
{
out << (s[i]);
}
//out << s.c_str() << endl; 当对象中有空白字符时无法捕获如string s("he \l),所以要逐字符输出
return out;
}
istream& operator>>(istream& in, string& s)
{
s.clear();
char ch = cin.get();
while (ch != '\n' && ch != ' ')
{
s += ch;
ch = in.get();
}
return in;
}
void Test1()
{
string s1("hello");
string s2("world");
string s3(s1);
s1 = s2;
cout << s1.size() << endl;
cout << s1[1] << endl;
string::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
it = s1.begin();
while (it != s1.end())
{
*it += 1;
++it;
}
it = s1.begin();
while (it != s1.end())
{
cout << *it << " ";
++it;
}
}
void Test2()
{
string s1("abcdefg");
s1.push_back('@');
s1.append("** **");
cout << s1 << endl;
string s2;
cin >> s2;
cout << s2 << endl;
s1.resize(20, 'x');
s1 += '#';
s1 += "$$$";
size_t ret= s1.find('c');
}
void Test3()
{
string s1("abcdefg");
size_t ret = s1.find("cde", 3);
s1.insert(7, 2, '@');
s1.insert(0, "ddd#");
s1.insert(9, "ssss");
s1.erase(1);
}
void Test4()
{
string s1("hello");
string::iterator it = s1.begin();
while (it != s1.end())
{
cout << *it << " ";
++it;
}
cout << endl;
for (auto& e : s1)
{
cout << e << " ";
}
}
}
int main()
{
king::Test4();
return 0;
}
以上就是string类的模拟实现了，我们模拟了一些常用的函数，模拟实现有利于我们了解string类，同时在学习其他容器时会方便很多，希望我的文章对你有所帮助，欢迎👍点赞 ，📝评论，🌟关注，⭐️收藏
614
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
