目录
1 · STL简介
1 – 1 · 什么是STL
1 – 2 · STL的六大核心组件
2 · auto和范围for
2 – 1 · auto关键字
2 – 2 · 范围for
3 · string类的基本概念
4 · string的常用接口
4 – 1 · 构造
4 – 2 · 容量操作
4 – 3 · 访问与遍历
4 – 4 · 查找与修改
4 – 5 · 非成员函数
5 · VS下string的结构
6 · 浅拷贝 / 深拷贝
6 – 1 · 模拟实现string类常见的问题
6 – 2 · 浅拷贝
6 – 3 · 深拷贝
6 – 4 · 写时拷贝
7 · 拷贝实现的现代写法与传统写法
7 – 1 · 传统写法
7 – 2 · 现代写法
8 · string类的模拟实现
8 – 1 · string.h
8 – 2 · string.cpp
1 · STL简介
1 – 1 · 什么是STL
STL(standard template libaray-标准模板库
)
：
是
C++
标准库的重要组成部分
，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。提供了一系列
通用的模板类和函数，用于实现常见的数据结构和算法。它基于模板编程，支持泛型设计，允许开发者以高效、可复用的方式处理数据。
1 – 2 · STL的六大核心组件
迭代器（Iterators）类似指针的对象，用于遍历容器中的元素，是容器与算法之间的桥梁。类型包括：输入迭代器、输出迭代器、前向迭代器、双向迭代器、随机访问迭代器等。
仿函数（Functor）重载了operator()的类对象，可像函数一样调用，常用于自定义算法行为。
适配器（Adapters）基于现有容器或迭代器提供特殊接口，如stack（栈）、queue（队列）、priority_queue（优先队列）。
空间适配器（Allocator）是C++标准库中用于管理内存分配的模板类，允许用户自定义内存分配策略。
2 · auto和范围for
介绍两个C++11的小语法，方便更好了解
2 – 1 · auto关键字
在早期
C/C++
中
auto
的含义是：使用
auto
修饰的变量，是具有自动存储器的局部变量，后来这个
不重要了。
C++11
中，标准委员会变废为宝赋予了
auto
全新的含义即：
auto
不再是一个存储类型
指示符，而是作为一个新的类型指示符来指示编译器，
auto
声明的变量必须由编译器在编译时期
推导而得
。
用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
auto不能作为函数的参数，可以做返回值，但是建议谨慎使用
auto不能直接用来声明数组
2 – 2 · 范围for
对于一个
有范围的集合
而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的
for
循环。
for
循环后的括号由冒号
“
：
”
分为两部分：第一部分是范围
内用于迭代的变量，第二部分则表示被迭代的范围
，自动迭代，自动取数据，自动判断结束。
范围for可以作用到数组和容器对象上进行遍历
范围for的底层很简单，容器遍历实际就是替换为迭代器
int array[] = { 1, 2, 3, 4, 5 };
// C++98的遍历
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
{
array[i] *= 2;
}
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
{
cout << array[i] << endl;
}
// C++11的遍历
for (auto& e : array)
e *= 2;
for (auto e : array)
cout << e << " " << endl;
3 · string类的基本概念
在C++中，string类是标准库提供的用于处理字符串的类，属于std命名空间。它封装了字符序列的操作，提供了丰富的成员函数，支持动态内存管理，比C风格的字符数组（char[]）更安全、更高效。
4 · string的常用接口
4 – 1 · 构造
| 函数 | 功能 |
|
string() |
构造空的 |
|
string(const char* s) |
用 |
|
string(size_t n, char c) |
string |
|
string(const string&s) |
拷贝构造函数 |
void Teststring()
{
string s1; // 构造空的string类对象s1
string s2("hello world"); // 用C格式字符串构造string类对象s2
string s3(s2); // 拷贝构造s3
}
4 – 2 · 容量操作
| 函数 | 功能 |
| size | 返回字符串有效字符长度 |
| length | 返回字符串有效字符长度 |
| capacity | 返回空间总大小 |
| empty | 判空，空串返回true，非空返回false |
| clear | 清空字符串中字符 |
| reserve | 预留空间 |
| resize |
将有效字符的个数该成n个，多出的空间用字符c填充 |
注意：
1. 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在改变元素个数时，如果是将元素个数
增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
r
eserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参
数小于string的底层空间总大小时，reserver不会改变容量大小。
4 – 3 · 访问与遍历
| 函数 | 功能 |
| operator[ ] | 返回pos位置的字符，如果是const修饰的对象调用，那么只允许访问 |
| begin + end | begin获取第一个字符的迭代器，end获取最后一个字符的下一个位置的迭代器 |
| rbegin + rend | rbegin获取最后一个字符的迭代器，rend获取第一个字符的前一个位置的迭代器 |
| 范围for | C++11支持 |
4 – 4 · 查找与修改
| 函数 | 功能 |
| push_back | 在字符串后尾插一个字符 |
| append | 在字符串后追加一个字符串 |
| operator+= | 在字符串后追加一个字符串str |
| c_str | 返回C格式字符串 |
| find | 从字符串pos位置(默认是0)开始往后找字符c或字符串str，返回第一次在查找中出现的位置，如果没找到，则返回 npos |
| rfind | 从字符串pos位置(默认是尾)开始往前找字符c或字符串str，返回第一次在查找中出现的位置，如果没找到，则返回 npos |
| substr | 从字符串pos位置开始，截取n个字符，然后将其返回 |
注意：
在string尾部追加字符时，s.push_back(c) / s.append(1, c) / s += 'c'三种的实现方式差
不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可
以连接字符串。
对string操作时，如果能够大概预估到需要放多少字符，可以先通过reserve把空间预留好。
npos是string类的一个静态成员变量，为整型的最大值，使用时需要指定类域。
4 – 5 · 非成员函数
| 函数 | 功能 |
| operator+ | 不作为成员函数可能是因为想要支持字符串 + string，尽量少用，因为传值返回，导致深拷贝效率低 |
| operator>> | 运算符重载，输入 |
| operator<< | 运算符重载，输出 |
| getline | 获取字符串，默认是遇到换行终止，也可以自己定终止符，终止符为第三个参数 |
|
relational operators |
大小比较 |
5 · VS下string的结构
在32位平台下，指针占4个字节
string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义 string中字符串的存储空间：
这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建
好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。
其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的
容量
最后：还有一个指针做一些其他事情，故总占28个字节。
6 · 浅拷贝 / 深拷贝
6 – 1 · 模拟实现string类常见的问题
class string
{
public:
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;//capacity不包含\\0
_str = new char[_capacity + 1];
strcpy(_str, str);
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
private:
char* _str;
size_t _size;
size_t _capacity;
};
// 测试
void TestString()
{
string s1("hello bit!!!");
string s2(s1);
}
上面这段代码没有显示实现拷贝构造，那么此时测试中用的是默认的拷贝构造，也就是一个字节一个字节拷贝，此时_size与_capacity是没有问题的，问题出在_str，如下图：
最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。
具体说说就是当TestString函数结束，需要销毁s1和s2，先对s2进行销毁，此时s1与s2共用的_str指向的空间被释放，s2销毁成功，s1中的_str变为野指针，随后销毁s1，此时就崩溃了。
6 – 2 · 浅拷贝
也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。
可以采用深拷贝解决浅拷贝问题，即：每个对象都有一份独立的资源，不要和其他对象共享。
6 – 3 · 深拷贝
如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
深拷贝，给每个对象独立分配资源，保证多个对象不会因为共享资源而导致多次释放而导致程序崩溃。
6 – 4 · 写时拷贝
写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。
7 · 拷贝实现的现代写法与传统写法
7 – 1 · 传统写法
//传统写法
string(const string& str)
{
_size = str._size;
_capacity = str._capacity;
_str = new char[_capacity + 1];
strcpy(_str, str._str);
}
//传统写法
string& operator=(const string& str)
{
//防止自己给自己赋值的情况
if (this != &str)
{
delete[] _str;
_size = str._size;
_capacity = str._capacity;
_str = new char[_capacity + 1];
strcpy(_str, str._str);
}
return *this;
}
传统写法就是自己手动进行深拷贝操作，开空间，复制值。
7 – 2 · 现代写法
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);
}
//现代写法
string& operator=(string tmp)
{
swap(tmp);
return *this;
}
现代写法相当于把我们需要做的工作交给编译器，让编译器帮我们生成一个对象，然后我们只需要窃取劳动成果，将对象中的成员变量全部交换过来。
在运算符重载= 中更能体现出现代写法的价值，因为赋值需要将原空间进行释放，而tmp作为临时变量，出了作用域就要销毁，所以在交换过后，tmp会自动帮助将原空间进行释放。同时此时无需考虑自己给自己赋值的情况，在传统写法中，由于需要先释放原空间，所以需要考虑自己给自己赋值的情况，否则是找不到字符串的。
8 · string类的模拟实现
下面模拟实现几个string类的常用功能
8 – 1 · string.h
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
namespace naobeng
{
class string
{
public:
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;
}
void swap(string& s)
{
std::swap(_str, s._str);
std::swap(_size, s._size);
std::swap(_capacity, s._capacity);
}
string(const char* str = "")
{
_size = strlen(str);
_capacity = _size;//capacity不包含\\0
_str = new char[_capacity + 1];
strcpy(_str, str);
}
//传统写法
//string(const string& str)
//{
//_size = str._size;
//_capacity = str._capacity;
//_str = new char[_capacity + 1];
//strcpy(_str, str._str);
//}
//现代写法
string(const string& s)
{
string tmp(s._str);
swap(tmp);
}
//传统写法
//string& operator=(const string& str)
//{
////防止自己给自己赋值的情况
//if (this != &str)
//{
//delete[] _str;
//_size = str._size;
//_capacity = str._capacity;
//_str = new char[_capacity + 1];
//strcpy(_str, str._str);
//}
//return *this;
//}
//现代写法
string& operator=(string tmp)
{
swap(tmp);
return *this;
}
~string()
{
delete[] _str;
_str = nullptr;
_size = _capacity = 0;
}
size_t size() const
{
return _size;
}
size_t capacity() const
{
return _capacity;
}
bool empty() const
{
return _size == 0;
}
void clear()
{
_str[0] = '\\0';
_size = 0;
}
char& operator[](size_t pos)
{
assert(pos < _size);
//return *(_str + pos);
return _str[pos];
}
const char& operator[](size_t pos) const
{
assert(pos < _size);
return _str[pos];
}
const char* c_str() const
{
return _str;
}
void reserve(size_t n);
void push_back(char c);
void append(const char* str);
string& operator+=(char c);
string& operator+=(const char* str);
void insert(size_t pos, char c);
void insert(size_t pos, const char* str);
void erase(size_t pos, size_t len = npos);
size_t find(char c, size_t pos = 0);
size_t find(const char* str, size_t pos = 0);
string substr(size_t pos, size_t len = npos);
private:
char* _str = nullptr;
size_t _size = 0;
size_t _capacity = 0;
static const size_t npos;
};
bool operator>(const string& s1, const string& s2);
bool operator>=(const string& s1, const string& s2);
bool operator<(const string& s1, const string& s2);
bool operator<=(const string& s1, const string& s2);
bool operator==(const string& s1, const string& s2);
bool operator!=(const string& s1, const string& s2);
ostream& operator<<(ostream& out, const string& str);
istream& operator>>(istream& in, string& str);
}
一些频繁调用的功能可以不用做声明定义分离，让它成为内联
8 – 2 · string.cpp
#include "string.h"
namespace naobeng
{
const size_t string::npos = -1;
void string::reserve(size_t n)
{
if (n > _capacity)
{
char* tmp = new char[n + 1];
strcpy(tmp, _str);
delete[] _str;
_str = tmp;
_capacity = n;
}
}
void string::push_back(char c)
{
if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
_str[_size] = c;
_size++;
_str[_size] = '\\0';
}
void string::append(const char* str)
{
size_t newLength = _size + strlen(str);
if (newLength > _capacity)
{
reserve(newLength > 2 * _capacity ? newLength : 2 * _capacity);
}
//strcat(_str, str);
//_size = newLength;
//_str[_size] = '\\0';
strcpy(_str + _size, str);
_size = newLength;
}
string& string::operator+=(char c)
{
push_back(c);
return *this;
}
string& string::operator+=(const char* str)
{
append(str);
return *this;
}
void string::insert(size_t pos, char c)
{
assert(pos <= _size);
if (_size == _capacity)
{
size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
reserve(newcapacity);
}
//int end = _size;
//while (end >= (int)pos)
//{
//_str[end + 1] = _str[end];
//end–;
//}
size_t end = _size + 1;
while (end > pos)
{
_str[end] = _str[end – 1];
end–;
}
_str[pos] = c;
++_size;
}
void string::insert(size_t pos, const char* str)
{
assert(pos <= _size);
size_t len = strlen(str);
if (len == 0)
return;
size_t newLength = _size + len;
if (newLength > _capacity)
{
reserve(newLength > 2 * _capacity ? newLength : 2 * _capacity);
}
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 = newLength;
}
void 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;
}
}
size_t string::find(char c, size_t pos)
{
assert(pos < _size);
for (size_t i = pos; i < _size; i++)
{
if (_str[i] == c)
{
return i;
}
}
return npos;
}
size_t string::find(const char* str, size_t pos)
{
assert(pos < _size);
const char* ptr = strstr(_str + pos, str);
if (ptr == nullptr)
{
return npos;
}
else
{
return ptr – _str;
}
}
string string::substr(size_t pos, size_t len)
{
assert(pos < _size);
if (len > _size – pos)
{
len = _size – pos;
}
string str;
str.reserve(len);
for (size_t i = 0; i < len; i++)
{
str += _str[pos + i];
}
return str;
}
bool operator>(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) > 0;
}
bool operator==(const string& s1, const string& s2)
{
return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator>=(const string& s1, const string& s2)
{
return (s1 > s2) || (s1 == s2);
}
bool operator<(const string& s1, const string& s2)
{
return !((s1 > s2) || (s1 == s2));
}
bool operator<=(const string& s1, const string& s2)
{
return !(s1 > s2);
}
bool operator!=(const string& s1, const string& s2)
{
return !(s1 == s2);
}
ostream& operator<<(ostream& out, const string& str)
{
for (auto c : str)
{
out << c;
}
return out;
}
istream& operator>>(istream& in, string& str)
{
str.clear();
//优化，用数组做缓冲
const int N = 128;
char buff[N];
int i = 0;
char c;
c = in.get();
while (c != ' ' && c != '\\n')
{
buff[i++] = c;
if (i > N – 1)
{
buff[i] = '\\0';
str += buff;
i = 0;
}
c = in.get();
}
if (i > 0)
{
buff[i] = '\\0';
str += buff;
}
return in;
}
}
以上内容如有错误或不准确之处，欢迎指出，或者你有更好的想法，也欢迎交流。
