STL是C++标准库的重要部分，提供数据结构和算法。主要组件包括容器（如vector、list）、算法和迭代器。string类是表示字符串的类，有多种构造函数，支持常见的字符串操作。文章还讨论了STL的内存管理和并发安全性问题，以及string类的容量和修改操作。此外，介绍了自定义实现string类的关键部分，如构造、赋值和迭代器。
STL简介
STL(standard template libaray-标准模板库)：
是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包含数据结构与算法的软件框架。
是一套功能强大的 C++ 模板类，提供了通用的模板类和函数，这些模板类和函数可以实现多种流行和常用的算法和数据结构，如向量、链表、队列、栈。
STL以HP版为始祖，衍生出很多版本，其中P.J.版本被被Windows Visual C++采用，RW版本被C+ + Builder 采用，SGI版本被GCC(Linux)采用。
从可读性角度考量，后续参考STL源代码会以SGI版本为主。
STL的六大组件
算法包含各种常见算法的函数
容器是数据结构
迭代器用于访问容器
空间配置器是内存池
STL的缺陷
- STL库的更新太慢了。上一版靠谱的是C++98，中间的C++03基本都是些修订。C++11出来已经过了十几年，STL才进一步更新。
- STL至今不支持线程安全。并发环境下需要开发者自己加锁，且锁的粒度较大。
- STL极度追求效率，导致内部比较复杂。如类型萃取、迭代器萃取。
- 使用STL会有代码膨胀的问题，如vector/vector/vector这样使用会生成多份代码，这是模板语法本身导致的。
容器-string类
- 字符串是表示字符序列的类(底层是字符数组)。
- 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
- string类使用char作为其字符类型，具有默认的char_traits和分配器类型（关于模板的更多信息，参见basic_string）。
- string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
- 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。
在使用string类时，须包含头文件string并使用命名空间std：
#include<string>
using namespace std;
实际使用中，不主动包含string头文件也可以使用std::string，但这是间接被实现的，且并不一定等价于主动包含string头文件的效果。可以的话尽量自己主动包含。
详情见：C++ 使用字符串一定要 #include 吗？
总结：
- string是表示字符串的字符串类。
- 该类的接口与常规容器的接口基本相同，添加了一些专门用来操作string的常规操作。
- string在底层实际是：basic_string模板类的别名，typedef basic_string<char, char_traits, allocator>string;
- 不能操作多字节或者变长字符的序列。
- 使用时尽量主动包含string头文件。
string类的常用构造函数
| (构造)函数名称 | 功能说明 |
|---|---|
| string() （重点） | 构造空的string类对象，即空字符串 |
| string(const char* s) （重点） | 用C-string来构造string类对象 |
| string(const string&s) （重点） | 拷贝构造函数 |
| string(size_t n, char c) | string类对象中包含n个字符c |
例:
#include <iostream>
#include <string>
using namespace std;
void Teststring() {
string s1; //构造空的string类对象s1
string s2("hell word"); //用C格式的字符串构造string类对象s2
string s3(s2); //拷贝构造s3
string s4 = "hell word"; //也可以这样构造对象，const char* 转 string
for (size_t i = 0; i < s2.size(); ++i) {
cout << s2[i]++ << endl; //std::string::operator[] 重载，返回对字符串中i处字符的引用，可按位置打印字符。
}
cout << endl;
cout << s2 << endl; //std::operator<< (string) 重载，可直接打印整个字符串。
cout << s3 << endl;
}
int main() {
Teststring();
return 0;
}
运行结果：
构造string对象
string();//default (1) *重点*
string (const string& str);//copy (2) *重点*
string (const string& str, size_t pos, size_t len = npos);//substring (3)
string (const char* s);//from c-string (4) *重点*
string (const char* s, size_t n);//from sequence (5)
string (size_t n, char c);//fill (6)
template <class InputIterator> string (InputIterator first, InputIterator last);//range (7)
构造一个string对象，根据使用的构造函数版本初始化其值：
(1) [重点]空字符串构造函数（默认构造函数）
构建一个空字符串，其长度为0个字符。
(2) [重点]拷贝构造函数
构造一个str的副本。
(3) 子串构造函数
复制str中从pos位置开始，跨越leng个字符的部分（如果str太短或者len等于string::npos，则复制到str的末端）。
static const size_t npos = -1;//无符号整型给-1，等效于无符号整型的最大值
(4) [重点]来自c字符串
复制s所指向的以\0作为结尾的字符串(C字符串)，即用C字符串构造string类对象。
(5) 来自buffer(缓冲区?)
从s指向的字符数组中复制前n个字符。
(6) fill构造函数
通过连续拷贝n个字符c来填充字符串。
(7) range构造函数(迭代器区间构造)
复制 [first,last) 区间中的字符序列，字符顺序不变。
以上所有构造函数都支持一个成员类型为allocator_type的对象作为最后的额外可选参数，这对于字符串来说是不相关的（上面没有显示，完整的签名见basic_string的构造函数）。
拷贝和赋值string对象(深拷贝)
string& operator= (const string& str);//string (1)
string& operator= (const char* s);//c-string (2)
string& operator= (char c);//character (3)
string对象赋值：
为字符串分配一个新值，替换其当前内容。
(1)是赋值，(2)与(3)是用来提供冗余的重载。
析构string对象
出作用域会自动调用析构函数释放对象的资源。不会抛出异常。
string类对象的容量操作
| 函数名称 | 功能说明 |
|---|---|
| size(重点) | 返回字符串的有效长度 |
| length | 返回字符串的有效长度 |
| capacity | 返回类所分配的空间的大小 |
| empty(重点) | 检查字符串是否为空串，为空则返回true，否则返回false |
| clear(重点) | 清空有效字符 |
| reserve(重点) | 为字符串预留空间 |
| resize(重点) | 将字符串的有效字符数改为指定的大小，多出的空间用特定字符填充 |
- size()与length()方法的底层实现原理完全相同，一般用的都是size()。string在STL出现前就已存在于标准库，最初就是用length()返回有效长度，故而保留length()。引入size()是为了与STL中其他容器的接口保持一致。
size_t size() const;
size_t length() const;
- clear()只是将string中有效字符清空，不改变所占用空间的大小（开出空间后一般都不会进行缩容）。
需注意empty()的函数名并不是动词"清空"，而是"为空"状态，“清空”是clear的功能。
void clear();//清空有效字符
bool empty() const;//检查是否为空字符串
- reserve()：为string预留空间，不改变有效元素个数。当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。
void reserve (size_t n = 0);//n为要预留的字符个数，默认为0
- resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是，当字符个数增多时：
resize(n)用0来填充多出的元素空间。
resize(size_t n, char c)用字符c来填充多出的元素空间。
使用resize的时候如果传的尺寸比字符串实际尺寸小，会删除数据，保留前n个元素。
注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
void resize (size_t n);//用0填充
void resize (size_t n, char c);//用指定字符填充
string类对象的修改操作
| 函数名称 | 功能说明 |
|---|---|
| push_back; | 在字符串后尾插指定的字符，字符串长度增加1 |
| append | 在字符串后追加一个字符串 |
| operator+= (重点) | 在字符串后追加单个字符或字符串 |
| c_str (重点) | 返回C格式字符串 |
| 【find + npos】 (重点) | 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置 |
| rfind | 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置 |
| substr | 在str中从pos位置开始，截取n个字符，然后将其返回 |
- 在string尾部追加字符时，
s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。 - 对string操作时，若能够大概预估到放多少字符，可以先用reserve预留空间。
- find配合substr便可以从字符串中提取指定内容。
vs和g++下string的结构
如未指出，默认32位平台。
vs下string的结构
string共占28个字节，内部结构略复杂：
- 一个联合体，用来定义string中字符串的存储空间：
-字符串长度小于16时，使用内部固定的字符数组来存放。
-字符串长度大于等于16时，从堆上开辟空间以存放内容。
union _Bxty
{ // storage for small buffer or pointer to larger one
value_type _Buf[_BUF_SIZE];
pointer _Ptr;
char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
这样做是因为大多数情况下字符串的长度都小于16，则string对象创建好之后，内部已有16个字符数组的固定空间，不需要专门从堆申请空间创建，效率较高。
-
一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量。
-
一个指针做其他事情。
故vs下string类占16+4+4+4=28字节。
g++下string的结构
G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段：
- 空间总大小。
- 字符串有效长度。
- 引用计数。
struct _Rep_base
{
size_type _M_length;
size_type _M_capacity;
_Atomic_word _M_refcount;
};
- 指向堆空间的指针，用来存储字符串。
模拟实现string
string.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <assert.h>
using namespace std;
namespace my_string {
class string {
public:
//原生指针实现迭代器
typedef char* iterator;
typedef char* const_iterator;//供const使用的重载版本
iterator begin() {
return _str;
}
iterator end() {
return _str + _size;
}
const_iterator begin() const{
return _str;
}
const_iterator end() const{
return _str + _size;
}
string(const char* str = "")//缺省不能给nullptr，因为strlen等函数会解引用。给常量字符串""会自动带上\0，不需要写成"\0"
//若类的声明顺序错误，会导致初始化顺序错误，进而导致问题，故只初始化_size这一个变量以增加容错
:_size(strlen(str))
{
_capacity = _size == 0 ? 3: _size;//保证_capacity不为0
_str = new char[_capacity + 1];//_capacity是有效字符数量，实际空间需加上\0占用的一位
strcpy(_str, str);
}
//默认拷贝构造只能浅拷贝，深拷贝需要手动实现
string(const string& s)
:_size(s._size)
,_capacity(s._capacity)
{
_str = new char[s._capacity + 1];//开空间
strcpy(_str, s._str);//拷数据
}
//赋值是关于两个已经存在的对象进行操作，所以要考虑二者长度不相等的情况
//左值长度小于右值长度时左值会需要扩容，而右值长度远小于左值时直接赋值(一般不会去缩容)会存在极大浪费
//前者的情况直接扩容即可。而对于后者的情况，系统一般会新开一块右值长度的空间并拷入数据，将之作为左值所对应的新空间并释放其旧空间
//库里的实现方式是，不判断大小，直接释放左值(this)原本的空间，给左值新开右值大小的空间并拷贝之
string& operator=(const string& s) {
if (this != &s) {//需要判断是否为自我赋值，是则不进行操作，不然在拷之前就给自己释放掉了
char* tmp = new char[s._capacity + 1];//使用tmp暂存以使得开空间失败时直接抛异常，而不会破坏被赋值的左值的类
strcpy(tmp, s._str);
delete[] _str;
_str = tmp;
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
~string() {
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
const char* c_str() {
return _str;
}
size_t size() const{//加const，普通对象与const对象就都可以调用，普通对象调用时权限缩小
return _size;
}
size_t capacity() const {
return _capacity;
}
const char& operator[](size_t pos) const{//用于const对象，不允许修改
assert(pos < _size);
return _str[pos];
}
char& operator[](size_t pos) {//用于普通对象，允许修改
assert(pos < _size);
return _str[pos];
}
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);
}
//扩容(类似realloc)
void reserve(size_t n) {
if (n > _capacity) {//判断n大小，避免缩容
char* tmp = new char[n + 1];//开新空间，n+1是为\0预留一位
strcpy(tmp, _str);//拷贝到新空间
delete[] _str;//释放旧空间
_str = tmp;
_capacity = n;
}
}
void append(const char* str) {
insert(_size, str);
}
//相比apprnd，push_back只能追加单个字符
void push_back(char ch) {
insert(_size, ch);
}
//扩容+初始化
void resize(size_t n, char ch = '\0') {
//n<_size，删除前n个之后的数据，不缩容(缩容代价大)
if (n <= _size) {//==的情况也包含一下
_size = n;
_str[_size] = '\0';
}
else{
if (n > _capacity) {//n大于容量则先扩容
reserve(n);
}
size_t i = _size;
while (i < n) {
_str[i] = ch;
++i;
}
_size = n;
_str[_size] = '\0';
}
}
string& operator+=(char ch) {
push_back(ch);
return *this;
}
string& operator+=(const char* str) {
append(str);
return *this;
}
//特定位置插入/清除
string& insert(size_t pos, char ch) {//待改进，现在这个写法pos给0会出问题
assert(pos <= _size);
if (_size + 1 > _capacity) {
reserve(2 * _capacity);
}
//
size_t end = _size + 1;//+1错开一位以实现能够判断end>=pos的效果，同时end在循环中不再会变成-1
while (end > pos){//判断end>=pos的话，若pos为0，要到end为-1时循环才会停，但end是无符号整型，会出问题。
_str[end] = _str[end - 1];//与+1对应
--end;
}
_str[pos] = ch;
++_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 - 1) {
_str[end] = _str[end - len];
--end;
}
//拷贝插入
strncpy(_str + pos, str, len);
_size += len;
return *this;//与库函数格式保持一致
}
string& erase(size_t pos, size_t len = npos) {//不给要删的长度则默认npos
assert(pos < _size);
if (len == npos || pos + len >= _size) {//npos及超出size的长度，从指定位置删到最后
_str[pos] = '\0';
_size = pos;
}
else {
strcpy(_str + pos, _str + pos + len);
_size -= len;
}
return *this;//与库函数格式保持一致
}
//内置类型的swap可以直接浅拷贝
void swap(string& s) {
std::swap(_str, s._str);//这里必须指定用std的swap，否则会就近调用自己而报错。
std::swap(_capacity, s._capacity);
std::swap(_size, s._size);
}
size_t find(char ch, size_t pos = 0){
assert(pos < _size);
for (size_t i = pos; i < _size; ++i) {
if (_str[i] == ch) {
return i;
}
}
return npos;
}
size_t find(const char* str, size_t pos = 0) {
assert(pos < _size);
char* p = strstr(_str + pos, str);
if (p == nullptr) {
return npos;
}
else {
return p - _str;
}
}
void clear() {
_str[0] = '\0';
_size = 0;
}
private:
char* _str;
size_t _size;
size_t _capacity;
static size_t npos;
//传统语法：静态成员变量不能在声明处缺省，可在类外定义
//但，库里的是(static const size_t npos;)，然后就可以(static const size_t npos = -1;)
//↑这个语法只是特例，只适用于整型，不能改成(static const double npos = 1.2;)这种
};
size_t string::npos = -1;//静态成员变量不能在声明处缺省，可在类外定义
//流插入与流提取重载，只能在类外
ostream& operator<<(ostream& out, const string& s) {
for (auto ch : s) {
out << ch;
}
return out;
}
istream& operator>>(istream& in, string& s) {
s.clear();//流插入前先清理(不缩容)
char ch = in.get();
char buff[128];
//↑类似于库中的解决长字符串情况下频繁扩容的效率问题的方式，每次根据输入的字符数决定扩多少个buff的大小，buff出作用域销毁
size_t i = 0;
while (ch != ' ' && ch != '\n') {
buff[i++] = ch;
if (i == 127) {
buff[127] = '\0';
s += buff;
i = 0;
}
ch = in.get();
}
if (i != 0) {
buff[i] = '\0';
s += buff;
}
return in;
}
void test_string1() {
string s1;
string s2("hell word");
cout << s1.c_str() << endl;
cout << s2.c_str() << endl;
s2[0]++;
cout << s1.c_str() << endl;
cout << s2.c_str() << endl;
}
void test_string2() {
string s1;
string s2("hell word");
string s3(s2);//拷贝
cout << s2.c_str() << endl;
cout << s3.c_str() << endl;
s2[0]++;
cout << s2.c_str() << endl;
cout << s3.c_str() << endl;
s1 = s3;//赋值
cout << s1.c_str() << endl;
cout << s3.c_str() << endl;
}
void Print(const string& s) {
for (size_t i = 0; i < s.size(); ++i) {
cout << s[i] << " ";
}
cout << endl;
string::const_iterator it = s.begin();
while (it != s.end()) {
++it;
}
cout << endl;
for (auto ch : s) {
cout << ch << " ";
}
cout << endl;
}
void test_string3() {
string s1("hell word");
for (size_t i = 0; i < s1.size(); ++i) {
s1[i]++;
}
cout << endl;
for (size_t i = 0; i < s1.size(); ++i) {
cout << s1[i] << " ";
}
cout << endl;
Print(s1);
string::iterator it = s1.begin();
while (it != s1.end()) {
(*it)--;
++it;
}
cout << endl;
it = s1.begin();
while (it != s1.end()) {
cout << *it << " ";
++it;
}
cout << endl;
//范围for的实现类似宏，这里的范围for底层用到的是前面自己实现的迭代器
//若把前面迭代器的begin改成Begin，迭代器依旧正常运行，但范围for会出错，vs会在报错里要求提供"begin"
for (auto ch : s1) {
cout << ch << " ";
}
cout << endl;
}
void test_string4() {
string s1("hell word");
string s2("hell word");
string s3("printf");
cout << (s1 == s2) << endl;
cout << (s1 < s2) << endl;
cout << (s1 >= s3) << endl;
}
void test_string5() {
string s1("hell word");
s1 += '-';
s1 += "114514";
cout << s1.c_str() << endl;
s1.insert(6, '*');
cout << s1.c_str() << endl;
}
void test_string6() {
string s1("12345");
s1.insert(0, 'a');
cout << s1.c_str() << endl;
s1.insert(3, 'b');
cout << s1.c_str() << endl;
s1.insert(0, "cccc");
cout << s1.c_str() << endl;
s1.insert(5, "ddddd");
cout << s1.c_str() << endl;
}
void test_string7() {
string s1("0123456789");
s1.erase(5, 3);
cout << s1.c_str() << endl;
s1.erase(3, 30);
cout << s1.c_str() << endl;
s1.erase(1);
cout << s1.c_str() << endl;
}
void test_string8() {
string s1("0123456789");
s1 += '\0';
s1 += "aaaaaa";
cout << s1 << endl;
cout << s1.c_str() << endl;//c_str若在字符串中间遇到\0，则直接停止，不会完整打印
string s2;
cin >> s2;
cout << s2 << endl;
cin >> s1;
cout << s1 << endl;
}
}
test.cpp
#include"string.h"
int main() {
try {
my_string::test_string8();
}
catch (const exception& e) {
cout << e.what() << endl;//显示异常
}
return 0;
}
迭代器初步了解（遍历string容器）
迭代器用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。
#include <iostream>
#include <string>
using namespace std;
int main() {
string s1("hell word");
//迭代器
string::iterator it = s1.begin();
while (it != s1.end()) {
cout << *it << " ";
++it;
}
cout << endl;
//范围for
for (auto ch : s1) {
cout << ch << " ";
}
cout << endl;
//反向迭代器
string::reverse_iterator rit = s1.rbegin();
while (rit != s1.rend()) {
cout << *rit << " ";
++rit;//注意是++不是--
}
cout << endl;
return 0;
}
- 这里begin可以看作指向string第一个字符的指针(vs下不是指针，linux下是)。
- end可以看作指向string最后一个元素的下一个位置的指针(不指向最后一个元素)。
- 迭代器的begin与end构成的区间为[begin，end)，左闭右开。
- iterator实际上是在string类中通过typedef出的类型，而不是内部类。
- 范围for实际上是靠编译器将其替换为迭代器的方式来实现的。
- 反向迭代器的rbegin指向的是\0的前一位(即末元素)，rend指向首元素的前一位，构成的区间为(rend,rbegin]，左开右闭。
- 由于是反向迭代器，rit++是从rbegin向rend的，所以++向左，–向右。
运行结果：
补充：const迭代器
std::string::begin
iterator begin();
const_iterator begin() const;
- 对于const对象，应使用const_iterator，而不是iterator。
- const迭代器只能遍历与读取容器的数据 ，而普通迭代器还能写。
- const迭代器也有对应的反向const迭代器const_reverse_iterator。
- 故迭代器共四种 ，普通迭代器与const迭代器，以及二者各自对应的反向迭代器。
1753
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
