C++ 模板与 String 类详解

显式实例化：在函数名后的<>中指定模板参数的实际类型。

4. 模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以实例化为这个非模板函数。

2. 对于非模板函数和同名函数模板，如果其它条件相同，在调用时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生出一个更好匹配的函数，那么将选择模板。

3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

5. 类模板

类模板的定义格式

template <class T1, class T2, ..., class Tn> class 类模板名 {
    // 类内成员定义
};

类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

// Stack 是类名，Stack<int>才是类型
Stack<int> st1; // int
Stack<double> st2; // double

二、STL 简介

什么是 STL 呢？

STL 是 C++ 标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。

那么，我们需要学习 STL 的哪些部分呢？

主要学习五个部分，空间配置器直接使用即可。

三、String

学习 string 从两方面去学习，一个是了解 string 类的接口，另一个便是模拟实现 string。

string 是被 typedef 的，真名叫做 basic_string<char>，是用来存储字符的。

1. 构造函数

// 无参构造
string();

// 拷贝构造
string(const string& str);

// 字符串构造 (from c-string)
string(const char* s);

// 不太常用的
// 从 pos 位置开始，拷贝 str 字符串的后 len 个字符，如果 str 字符串
// 太短或者 len 为 npos，那就从 pos 位置拷贝到 str 字符串末尾
string(const string& str, size_t pos, size_t len = npos);

// 用 n 个连续的字符 c 的拷贝填充
string(size_t n, char c);

// 赋值
string& operator=(const string& str);

2. 迭代器

// 如果 string 对象是一个 const 类型的，函数返回 const_iterator，否则，返回 iterator
// 普通迭代器
iterator begin();          // 指向字符串的开始
iterator end();             // 指向字符串的末尾（最后一个字符的下一个位置）
const_iterator begin() const;
const_iterator end() const;

// 反向迭代器
// 反向迭代器指向 string 的反向开始位置（也就是 string 的末尾最后一个字符）
reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

// 指向 string 的末尾的反向（也就是 string 的第一个字符的前一个位置）
reverse_iterator rend();
const_reverse_iterator rend() const;

注：迭代器可以理解成像指针一样，但是迭代器不是指针。

3. 容量管理

// size 和 length 两个函数的功能是一致的
// 字符串的字节数
size_t size() const;
size_t length() const;

// 字符串的容量
size_t capacity() const;

// 清空字符串
void clear();

// 判断字符串是否为空，length 为 0 返回 true，否则，返回 false
bool empty() const;

// n 代表新的字符串的长度，c 是用来填充字符串中新的字符空间的字符
// 如果 n 小于当前字符串的长度，字符串会缩短至前 n 个字符，删除第
// n 个字符之后的所有字符
// 如果 n 大于当前字符串的长度，在字符串的末尾插入字符到 n 个
// （c 是一个具体的字符，就用 c 来初始化，否则就用空字符初始化）
void resize(size_t n);
void resize(size_t n, char c);

// 请求调整字符串的容量，适应将字符串的长度更改为最多 n 个字符的需求
// 如果 n > str.capacity，容器的容量会增加到 n 个字符（capacity >= n）
// 其它情况，缩小字符串的容量是一个非强制性的请求
// 这个函数不会影响字符串的长度和内容，也就是说即使缩容也不会
// 比字符串的长度小
void reserve(size_t n = 0);

// 减少字符串的容量去适应它的 size
// 不影响字符串的长度和内容
void shrink_to_fit();

shrink_to_fit通常是异地缩容，因为无法从内存块的中间释放一部分内存。

这是在 VS 上运行的结果，是没有缩容的，那么，看一下 g++ 编译器会不会进行缩容呢？

g++ 下也是没有缩容的。是否缩容，取决于平台。

4. 元素访问

// 返回在字符串中 pos 位置的字符的引用
char& operator[](size_t pos);
const char& operator[](size_t pos) const;

// 与 [] 的功能一样，这也是为什么 string 被吐槽的原因，设计了太
// 多的函数，有些函数功能是一样的，重点掌握 [] 的使用
char& at(size_t pos);
const char& at(size_t pos) const;

// 返回的是字符串中最后一个字符的引用
char& back();
const char& back() const;

// 返回的是字符串中第一个字符的引用
char& front();
const char& front() const;

5. 修改操作

// 在字符串的末尾追加另一个 std::string str 对象
string& operator+=(const string& str);

// 字符串的末尾追加 C 风格的 s 字符串 c-string
string& operator+=(const char* s);

// 在字符串的末尾追加单个字符 character
string& operator+=(char c);

// 追加 str 的拷贝
string& append(const string& str);

// 从 str 的 subpos 位置开始，拿取 sublen 个字符，追加到 string
// 的对象中，如果 str 太短或者 sublen 等于 npos，那就取到 str 的
// 末尾
string& append(const string& str, size_t subpos, size_t sublen);

// s 指向的以空字符结尾的字符序列，追加到 string 对象中 c-string
string& append(const char* s);

// 取 s 指向的字符数组前 n 个字符，追加到 string 对象中 buffer
string& append(const char* s, size_t n);

// n 个字符 c 的拷贝，追加到 string 对象中 fill
string& append(size_t n, char c);

// 在 string 对象的末尾添加字符 c，string 对象的长度增加 1
void push_back(char c);

// 删除 string 对象的最后一个字符，string 对象的长度减 1
void pop_back();

// 在 pos 位置插入 str 的拷贝
string& insert(size_t pos, const string& str);

// 从 str 中的 subpos 位置开始，取 sublen 个字符，插入到 string
// 对象中，如果 str 太短或者 sublen 等于 npos，就从 subpos 位置
// 开始一直到 str 字符串的末尾
string& insert(size_t pos, const string& str, size_t subpos, size_t sublen);

// s 指向的以空字符结尾的字符序列，插入到 string 对象中 c-string
string& insert(size_t pos, const char* s);

// s 指向的字符数组的前 n 个字符的拷贝插入到 string 对象中 buffer
string& insert(size_t pos, const char* s, size_t n);

// 插入字符 c 的 n 次拷贝 fill
string& insert(size_t pos, size_t n, char c);

// 从 pos 位置开始，删除 string 的 len 个字符，如果 string 太短或者 len 为 npos，就删到 string 的末尾。
// 注意，该函数默认删除 string 的所有字符 sequence
string& erase(size_t pos = 0, size_t len = npos);

// 从 string 对象中的 pos 位置，用 str 字符串替换掉 string 对象中的 len 个字符
string& replace(size_t pos, size_t len, const string& str);

// 拷贝 str 字符串赋值给 string 对象
string& assign(const string& str);

注：insert，erase，replace 需慎用，因为 string 的底层是数组，在插入，删除，数据时，都需要移动数据，这也就意味着时间复杂度为 O(N)，而替换数据，如果替换的字符串和 len 是相等的，那还是很高效的，但是如果不相等，也需要移动数据，时间复杂度也为 O(N)。

// 得到一个 C 风格的字符串
const char* c_str() const;

// 从 pos 位置开始查找一个 string 对象
size_t find(const string& str, size_t pos = 0) const;

// 从 pos 位置开始查找一个字符串 c-string
size_t find(const char* s, size_t pos = 0) const;

// 从 pos 位置查找 s 指向的字符数组的前 n 个字符 buffer
size_t find(const char* s, size_t pos, size_t n) const;

// 从 pos 位置查找单个字符 character
size_t find(char c, size_t pos = 0) const;

// 反向查找，与 find 的功能是一样的，只不过一个从 string 的开头处查找，一个从 string 的末尾查找
size_t rfind(const string& str, size_t pos = npos) const;
size_t rfind(const char* s, size_t pos = npos) const;
size_t rfind(const char* s, size_t pos, size_t n) const;
size_t rfind(char c, size_t pos = npos) const;

// 在字符串中查找第一个出现在指定字符集合中的字符
// 成功返回第一个匹配字符的位置，失败返回 npos
size_t find_first_of(const string& str, size_t pos = 0) const;

// 从 pos 位置开始取 len 个字符组成一个子串，构造一个新的 string 对象并返回（或者到字符串的末尾，如果 len 大于从 pos 位置开始剩余字符的长度）
string substr(size_t pos = 0, size_t len = npos) const;

// 从 pos 位置开始，拷贝 string 对象中的 len 个字符，存储在 s 指向的字符数组里
size_t copy(char* s, size_t len, size_t pos = 0) const;

npos是一个 size_t 类型，值为 -1，实际值是一个无穷大的数，因为 size_t 是一个无符号整型。

6. 非成员函数

// 获取一行字符
// is 输入流对象，str 存储字符的字符串对象，delim 提取字符的分割符
istream& getline(istream& is, string& str, char delim);
istream& getline(istream& is, string& str);