手撕STLstring类
Posted The August
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了手撕STLstring类相关的知识，希望对你有一定的参考价值。
string类
标准库中的string类
string类
- 字符串是表示字符序列的类
- 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
- string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型
- string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数
- 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
注：
string类用utf-8编码，按单字节处理
u16string用utf-16编码
u32string用utf-32编码
wstring类按两字节处理
编码：
计算机中存储只有二进制0、1，用对应的ASCII表来表示文字（支持英文的）其中ASCII表是对256个值建立一个对应的表示值
在早期只有欧美国家使用计算机（早期的计算机中只能表示英文，不能表示其他国家的文字），后来全世界各个国家都开始用计算机了，需要建立自己的编码表
在Linux中常用utf-8、utf-16、utf-32
在Windows中常用gbk
总结：
- string是表示字符串的字符串类
- 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
- string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator> string;
- 不能操作多字节或者变长字符的序列。
在使用string类时，必须包含#include < string > 头文件以及using namespace std;
string类的常用接口说明
具体用法见string类的常见接口说明
- string类对象的常见构造
- string类对象的访问及遍历操作
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
int main()
string s1;
string s2("hello");
const string s3("hehe");
cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;
// 1. for+operator[] 遍历+修改
for (size_t i = 0;i < s2.size();i++)
s2[i] += 1;// 修改
for (size_t i = 0;i < s2.size();i++)
cout << s2[i] << ""; // 遍历
cout << endl;
// 2. 范围for 遍历+修改
for (auto& ch : s2)
ch -= 1;// 修改
for (auto ch : s2)
cout << ch << "";// 遍历
cout << endl;
// 3. 迭代器 遍历+修改
string::iterator it = s2.begin();
while (it != s2.end())
(*it)++;// 修改
it++;
it = s2.begin();
while (it != s2.end())
cout << *it << "";// 遍历
it++;
cout << endl;
//反着遍历对象
string::reverse_iterator rit = s2.rbegin();
while (rit != s2.rend())
cout << *rit << "";
rit++;
cout << endl;
//const 对象的遍历
string::const_iterator cit = s3.begin();
while (cit != s3.end())
cout << *cit << "";
cit++;
cout << endl;
//const 对象反着的遍历
string::const_reverse_iterator rcit = s3.rbegin();
while (rcit != s3.rend())
cout << *rcit << "";
rcit++;
return 0;
总结：
迭代器是一个行为像指针的东西，有可能是指针，也有可能不是指针
迭代器可以用统一类似的方式去访问修改容器
begin（）返回的是第一个有效数据位置的迭代器，end（）返回的是最后一个有效数据的下一个位置的迭代器
rbegin（）返回的是最后个有效数据位置的迭代器，rend（）返回的是第一个有效数据的前一个位置的迭代器
所有的容器都支持用迭代器，所以迭代器才是容器通用的访问方式（vector/string这样的结构支持下标+[]去访问，而像list、map这样的就不支持了）
const对象要用const迭代器，只读，不能写
operator[]和at的区别：operator[]如果发生越界访问会报断言错误（assert），而at会报异常（需要捕获异常）
- string类对象的容量操作
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
int main()
string s1("hello");
//推荐用size()
cout << s1.size() << endl;
cout << s1.length() << endl;
cout << s1.capacity() << endl;
cout << s1.max_size() << endl;//max_size()实际中没有意义
string s2("hello world");
cout << s2 << endl;
cout << s2.size() << endl;
//将s2中有效字符个数增加到20个，多出位置用缺省值'\\0'进行填充
// 注意此时s2中有效字符个数已经增加到20个
s2.resize(20);
cout << s2 << endl;
cout << s2.size() << endl;
s2[19] = 'x';
cout << s2 << endl; //hello world x
cout << s2.size() << endl;
string s3("hello world");
//将s3中有效字符个数增加到20个，多出位置用'x'进行填充
s3.resize(20,'x');
cout << s3 << endl; //hello worldxxxxxxxxx
cout << s3.size() << endl;
string s4("hello world");
//将s4中有效字符个数缩小到5个
s4.resize(5);
cout << s4 << endl; //hello
cout << s4.size() << endl;
string s5("hello world");
s5.reserve(25);
cout << s5 << endl;//hello world
cout << s5.size() << endl;//11
cout << s5.capacity() << endl;//31
s5.reserve(10);
cout << s5 << endl;//hello world
cout << s5.size() << endl;//11
cout << s5.capacity() << endl;//31
string s6("hehe");
cout << s6 << endl;
// 将s6中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小
s6.clear();
cout << s6 << endl;
return 0;
注意：
- size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下基本都是用size()。
- clear()只是将string中有效字符清空，不改变底层空间大小。
- resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
- reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
- 在Windows中容量是以大约1.5倍增容的，在Linux中容量是以大约2倍增容的
- reserve的作用：如果知道需要多少空间，直接一次性开好，避免增容，提高效率
- resize的作用：既能开好空间，又能对这些空间初始化
- string类对象的修改操作
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
int main()
string s1("hello");
string s2("world");
s1 += " ";
s1 += s2;
cout << s1 << endl;
//能不用就不用，因为insert和erase在头部或者中间等位置插入删除需要插入数据，效率低尽量少用
s1.insert(0, "C++ ");
cout << s1 << endl;
string s3("hello world");
s3.erase(5);
cout << s3 << endl;
//取文件后缀名
string file1("test.cpp");
string file2("test.c.zip");
size_t pos1 = file1.find('.');
// npos是string里面的一个静态成员变量
// static const size_t npos = -1;
if (pos1 != string::npos)
cout << file1.substr(pos1) << endl;
size_t pos2 = file2.rfind('.');
if (pos2 != string::npos)
cout << file2.substr(pos2) << endl;
return 0;
应用场景：
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
int main()
//取出url中协议、域名、uri
string url("http://www.cplusplus.com/reference/string/string/find/");
cout << url << endl;
size_t pos1 = url.find("://");
if (pos1 != string::npos)
string protocol = url.substr(0, pos1 - 0);
cout << "protocol:" << protocol << endl;
size_t pos2 = url.find('/',pos1+3);
if (pos2 != string::npos)
string domain = url.substr(pos1+3, pos2 - (pos1+3));
cout << "domain:" << domain << endl;
string uri = url.substr(pos2);
cout << "uri:" << uri << endl;
printf("%s\\n", url.c_str()); //以C语言的方式打印字符串
return 0;
注意：
- 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
- 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。
- string类非成员函数
注：cin遇到空格和换行就会分割（或结束），而getline遇到空格不会分割（或结束）遇到换行才分割（或结束）
- string类对象的字符串的转换（在C++11适用）
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
using namespace std;
int main()
int i = 1234;
string s = to_string(i); //将int类型的i转换成字符串，再将字符串赋值给s
//s "1234"
cout << s << endl;
int j = stoi(s); // 将字符串s转换成int类型，再赋值给j
return 0;
string类的模拟实现
string类的成员变量：
Member functions
构造函数
string(const char* str="")
:_size(strlen(str))
, _capacity(_size)
_str = new char[_capacity + 1];
strcpy(_str, str);
注：构造函数传参必须是const char*类型的，字符串是存放在代码段中的常量区的是不可修改的，因此如果想修改其中string类的对象时，需要将在堆上开辟一段空间用来存放字符串，这样可以实现string类的增、删、查、改
析构函数
~string()
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
注：在堆上开辟的空间，记得一定要释放，否则会出现内存泄漏
拷贝构造（深拷贝）
//深拷贝的现代写法
string(const string& s)
:_str(nullptr)
string tmp(s._str);
swap(tmp);
//深拷贝的传统写法
string(const string& s)
:_size(s._size)
,_capacity(s._capacity)
, _str (new char[s._capacity + 1])
//_str = new char[strlen(s._str)+1];
strcpy(_str, s._str);
注：
string类的拷贝构造是深拷贝
深拷贝：拷贝对象，新开一块空间跟原来对象一样大的空间，再把原来对象空间上的值拷贝过来
浅拷贝：指向同一块空间，析构两次，其中一个修改另外一个也会受影响
深拷贝的传统写法：首先在初始化列表中开辟出和s一样大小的空间，其次再将s中的内容拷贝到新创建的对象中
深拷贝的现代写法：首先创建一个string类的临时对象tmp并将s的内容拷贝到tmp中，然后将tmp和新创建的对象进行交换，最后tmp会自动调用析构函数
赋值重载（深赋值）
//赋值重载的现代写法
string& operator=(string s)
swap(s);
return *this;
string& operator=(const string& s)
if (this != &s)
string tmp(s._str);
swap(tmp);
return *this;
//赋值重载的传统写法
string& operator=(string s)
if (this != &s)
char* tmp = new char[strlen(s._str) + 1];
delete[] _str;
_str = tmp;
strcpy(_str, s._str);
return *this;
注：
赋值重载的传统写法：首先开辟一段能写下s._str的空间，然后将本身的空间是释放，再将tmp拷贝给本身，最后将s的内容拷贝给自己（注意先开辟空间在释放原来的，否则，开辟空间失败后还是释放了原来的空间_str）
赋值重载的现代写法：将赋值的对象拷贝（深拷贝）给s对象，然后将自己与s交换，最后释放s
Capacity
size
size_t size()const
return _size;
size 返回字符串有效字符长度
capacity
size_t capacity()const
return _capacity;
capacity 返回当前为字符串分配的存储空间的大小，以字节表示。
reserve
void reserve(size_t n)
if (n > _capacity)
char* tmp = new char[n+1];
strcpy(tmp, _str);
::swap(_str, tmp);
_capacity = n;
delete[] tmp;
reserve为字符串预留空间
reserve(size_t n=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
resize
void resize(size_t n, char ch='\\0')
if (n <= _size)
_size = n;
_str[_size] = '\\0';
else
if (n > _capacity)
reserve(n);
for (size_t i = _size;i < n;i++)
_str[i] = ch;
_size = n;
_str[_size] = '\\0';
resize将有效字符的个数该成n个，多出的空间用字符ch填充
resize(size_t n, char ch=’\\0’)是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用’\\0’来填充多出的元素空间，resize(size_t n, char ch=’\\0’)用字符ch来填充多出的元素空间。
注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
clear
void clear()
_st以上是关于手撕STLstring类的主要内容，如果未能解决你的问题，请参考以下文章