《C++高级编程》读书笔记（十二：利用模板编写泛型代码）

1、参考引用

C++高级编程（第4版，C++17标准）马克·葛瑞格尔

2、建议先看《21天学通C++》这本书入门，笔记链接如下

21天学通C++读书笔记（文章链接汇总）

1. 模板概述

模板将参数化的概念推进了一步，不仅允许参数化值，还允许参数化类型。C++ 中的类型不仅包含原始类型，例如 int 和 double，还包含用户定义的类，例如 SpreadsheetCell 和 CherryTree。使用模板，不仅可编写不依赖特定值的代码，还能编写不依赖那些值类型的代码

2. 类模板

类模板定义了一个类，其中，将一些变量的类型、方法的返回类型和/或方法的参数类型指定为参数。类模板主要用于容器，或用于保存对象的数据结构

2.1 编写类模板

假设想要一个通用的棋盘类，可将其用作象棋棋盘、跳棋棋盘、井字游戏棋盘或其他任何二维的棋盘。为让这个棋盘通用，这个棋盘应该能保存象棋棋子、跳棋棋子、井字游戏棋子或其他任何游戏类型的棋子

2.1.1 Grid 类定义

第一行表示，下面的类定义是基于一种类型的模板。就像在函数中通过参数名表示调用者要传入的参数一样，在模板中使用模板参数名称 (例如 T) 表示调用者要指定的类型
指定模板类型参数时，可用关键字 class 替代 typename，但 class 会产生一些误解，因为这个词暗示这种类型必须是一个类，而实际这种类型可以是 class、struct、union、基本类型如 int 或 double 等
```
template <typename T>
class Grid {
    // ...
};
```

2.1.2 Grid 类的方法定义

template <typename T> 访问说明符必须在 Grid 模板的每一个方法定义的前面

模板要求将方法的实现也放头文件中，因为编译器在创建模板的实例前，需知道完整的定义，包括方法的定义

template <typename T>
Grid<T>::Grid(size_t width, size_t height) : mWidth(width), mHeight(height) { // 构造函数
    // ...
}

2.1.3 使用 Grid 模板

创建网格对象时，不能单独使用 Grid 作为类型，必须指定这个网格保存的元素类型。为某种类型创建一个模板类对象的过程称为模板的实例化。下面举一个示例

Grid<int> myIntGrid；
Grid<double> myDoubleGrid(11, 11);

myIntGrid.at(0, 0) = 10;
// at() 方法返回 std:optional 引用。optional 可包含值，也可不包含值
// 如果 optional 包含值，value_or() 方法返回这个值；否则返回给 value_or() 提供的实参
int x = myIntGrid.at(0, 0).value_or(0);

Grid<int> grid2(myIntGrid); // 复制构造函数
Grid<int> anotherIntGrid;
anotherIntGrid = grid2; // 赋值运算符

如果要声明一个接收 Grid 对象的函数或方法，必须在 Grid 类型中指定保存在网格中的元素类型
```
void processIntGrid(Grid<int>& grid) {
    // ...
}
```
为避免每次都编写完整的 Grid 类型名称，例如 Grid<int>，可通过类型别名指定一个更简单的名称
```
using IntGrid = Grid<int>;
```
Grid 模板能保存的数据类型不只是 int。例如，可实例化一个保存 SpreadsheetCell 的网格
```
Grid<SpreadsheetCell> mySpreadsheet;
SpreadsheetCell myCell(1.234);
mySpreadsheet.at(3, 4) = myCell;
```

Grid 模板还可保存指针类型

Grid<const char*> myStringGrid;
myStringGrid.at(2, 2) = "hello";

Grid 模板指定的类型甚至可以是另一个模板类型

Grid<vector<int>> gridOfVectors;
vector<int> myVector{1, 2, 3, 4};
gridOfVectors.at(5, 6) = myVector;

Grid 模板还可在堆上动态分配 Grid 模板实例

auto myGridOnHeap = make_unique<Grid<int>>(2, 2);
myGridOnHeap->at(0, 0) = 10;
int x = myGridOnHeap->at(0, 0).value_or(0);

2.2 编译器处理模板的原理

编译器遇到模板方法定义时会进行语法检查但不编译模板。编译器无法编译模板定义，因为它不知道要使用什么类型
编译器遇到一个实例化的模板时，例如 Grid<int> myIntGrid，就会将模板类定义中的每一个 T 替换为int，从而生成 Grid 模板的 int 版本代码。当编译器遇到这个模板的另一个实例时，就会生成另一个版本的 Grid 类

2.3 将模板代码分布在多个文件中

通常情况下，将类定义放在一个头文件中，将方法定义放在一个源代码文件中。创建或使用类对象的代码会通过 #include 来包含对应的头文件，通过链接器访问这些方法代码
模板不按这种方式工作。由于编译器需要通过这些 “模板” 为实例化类型生成实际的方法代码，因此在任何使用了模板的源代码文件中，编译器都应该能同时访问模板类定义和方法定义。有好几种机制可以满足这种包含需求

2.3.1 将模板定义放在头文件中

方法定义可与类定义直接放在同一个头文件中。当使用了这个模板的源文件通过 #include 包含这个文件时，编译器就能访问需要的所有代码。此外，还可将模板方法定义放在另一个头文件中，然后在类定义的头文件中通过 #include 包含这个头文件
```
// Grid.h
template <typename T>
class Grid {
    // ...
};
// 一定要保证方法定义的 #include 在类定义之后，否则代码无法编译
#include "GridDefinition.h"
```

2.3.2 将模板定义放在源文件中

可将方法定义放在一个源代码文件中。然而，仍然需要让使用模板的代码能访问到定义，因此可在模板类定义头文件中通过 #include 包含类方法实现的源文件
```
// Grid.h
template <typename T>
class Grid {
    // ...
};

#include "Grid.cpp"
```

2.4 模板参数

2.4.1 非类型的模板参数

非类型的模板参数只能是整数类型(char、int、long 等)、枚举类型、指针、引用和 std::nullptrt。从 C++17 开始，也可指定 auto、auto& 和 auto* 等作为非类型模板参数的类型，此时，编译器会自动推导类型

template <typename T, size_t WIDTH, size_t HEIGHT>
class Grid {
    // ...
};
// 实例化模板
Grid<int, 10, 10> myGrid;
Grid<int, 10, 10> anotherGrid;
myGrid.at(2, 3) = 42;
anotherGrid = myGrid;
cout << anotherGrid.at(2, 3).value_or(0);

2.4.2 类型参数的默认值

如果继续采用将高度和宽度作为模板参数的方式，就可能需要为高度和宽度 (它们是非类型模板参数) 提供默认值

template <typename T = int, size_t WIDTH = 10, size_t HEIGHT = 10>
class Grid {
    // ...
};

// 不需要在方法定义的模板规范中指定 T、WIDTH 和 HEIGHT 的默认值
template <typename T, size_t WIDTH, size_t HEIGHT>
const std::optional<T>& Grid<T, WIDTH, HEIGHT>::at(size_t x, size_t y) const {
    // ...
}

// 实例化 Grid 时，可不指定模板参数，只指定元素类型，或者指定元素类型和宽度，或者指定元素类型、宽度和高度
Grid<> myGrid;
Grid<int> myGrid2;
Grid<int, 5> myGrid3;
Grid<int, 5, 5> myGrid4;

2.4.3 构造函数的模板参数推导

C++17 添加了一些功能，支持通过传递给类模板构造函数的实参自动推导模板参数。在 C++17 之前，必须显式地为类模板指定所有模板参数
例如，标准库有一个类模板 std:pair(在 <utility> 中定义)。pair 存储两种不同类型的两个值，必须将其指定为模板参数
```
std::pair<int, double> pair1(1, 2.3);
```
为避免编写模板参数的必要性，可使用一个辅助的函数模板 std:make_pair()。函数模板始终支持基于传递给函数模板的实参自动推导模板参数。因此，make_pair() 能根据传递给它的值自动推导模板类型参数
```
auto pair2 = std::make_pair(1, 2.3);
```
C++17 中，不再需要这样的辅助函数模板，编译器可以根据传递给构造函数的实参自动推导模板类型参数
```
std::pair pair3(1, 2.3);
```
推导的前提是类模板的所有模板参数要么有默认值，要么用作构造函数中的参数
std::unique_ptr 和 shared_ptr 会禁用类型推导，需要继续使用 make_unique() 和 make_shared() 创建

2.5 方法模板

C++ 允许模板化类中的单个方法，这些方法可以在类模板中，也可以在非模板化的类中

不能用方法模板编写虚方法和析构函数
不能将类型为 Grid<int> 的对象赋给类型为 Grid<double> 的对象，也不能从 Grid<int> 构造 Grid<double>
Grid 复制构造函数和 operator= 都接收 const <Grid> 的引用作为参数
```
Grid(const Grid<T>& src);
Grid<T>& operator=(const Grid<T>& rhs);
```
当实例化 Grid<double> 并试图调用复制构造函数和 operator= 时，编译器通过这些原型生成方法
```
Grid(const Grid<double>& src);
Grid<double>& operator=(const Grid<double>& rhs);
```
在生成的 Grid<double> 类中，构造函数或 operator= 都不接收 Grid<int> 作为参数，但可通过双重模板解决：在 Grid 类中添加模板化的复制构造函数和赋值运算符，可生成将一种网格类型转换为另一种网格类型的方法
```
template <typename T>
class Grid {
public:
    // ...
    template <typename E>
    Grid(const Grid<E>& src);

    template <typename E>
    Grid<T>& operator=(const Grid<E>& rhs);
};
```
- 下面是新的复制构造函数的定义，必须将声明类模板的那一行 (带有 T 参数) 放在成员模板的那一行声明 (带有 E 参数) 的前面
```
template <typename T>
template <typename E>
Grid<T>::Grid(const Grid<E>& src) : Grid(src.getWidth(), src.getHeight()) {
    // ...
}
```

2.6 类模板的特例化

模板的另一个实现称为模板特例化，通过这项特性，当模板类型被特定类型替换时，可为模板编写特殊实现
编写一个模板类特例化时，必须指明这是一个模板，以及正在为哪种特定的类型编写这个模板。下面是为 const char* 特例化
```
// 下述语法告诉编译器，这个类是 Grid 类的 const char* 特例化版本
template <>
class Grid<const char*> {
    // ...
};
```
```
Grid<int> myIntGrid;
Grid<const char*> stringGrid(2, 2);
```
注意，在这个特例化中不要指定任何类型变量，例如 T，而是直接处理 const char*
特例化的主要好处就是可对用户隐藏：当用户创建 int 或 SpreadsheetCell 类型 Grid 时，编译器从原始 Grid 模板生成代码；当用户创建 const char* 类型的 Grid 时，编译器会使用 const char* 的特例化版本，这些全部在后台自动完成
特例化一个模板时，并没有继承任何代码：特例化和派生化不同，必须重新编写类的整个实现，不要求提供具有相同名称或行为的方法
- 例如，Grid 的 const char* 特例仅实现 at() 方法，返回 std::optional<std::string> 而非 std::optional<const char*>

2.7 从类模板派生

可从类模板派生。如果一个派生类从模板本身继承，那么这个派生类也必须是模板。此外，还可从类模板派生某个特定实例，这种情况下，这个派生类不需要是模板
假设通用的 Grid 类没有提供足够的棋盘功能。确切地讲，要给棋盘添加 move() 方法，允许棋盘上的棋子从一个位置移动到另个位置。下面是这个 GameBoard 模板的类定义
- 这个GameBoard 模板派生自 Grid 模板，因此继承了 Grid 模板的所有功能
- 继承的语法和普通继承一样，区别在于基类是 Grid<T>，而不是 Grid
```
#include "Grid.h"

template <typename T>
class GameBoard : public Grid<T> {
public:
    explicit GameBoard(size_t width = Grid<T>::kDefaultWidth,
                       size_t height = Grid<T>::kDefaultHeight);
    void move(size_t xSrc, size_t ySrc, size_t xDest, size_t yDest);
};
```

2.8 继承还是特例化

通过继承来扩展实现和使用多态，通过特例化自定义特定类型的实现

3. 函数模板

还可为独立函数编写模板。例如，可编写一个通用函数，该函数在数组中查找一个值并返回这个值的索引

// size_t 是一个无符号整数类型
// 通过这样的转换，可以将负值转换为等效的正值，以便在使用无符号整数时表示特殊的未找到或无效状态
static const size_t NOT_FOUND = static_cast<size_t>(-1);

template <typename T>
// 这个 Find() 函数可用于任何类型的数组
size_t Find(const T& value, const T* arr, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        if (arr[i] == value) {
            return i;
        }
    }
    return NOT_FOUND;
}

与类模板方法定义一样，函数模板定义(不仅是原型)必须能用于使用它们的所有源文件。因此，如果多个源文件使用函数模板，或使用前面讨论的显式实例化，就应把其定义放在头文件中
函数模板的模板参数可以有默认值，与类模板一样

3.1 函数模板的特例化

template<>
size_t Find<const char*>(const char* const& value, const char* const* arr, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        if (strcmp(arr[i], value) == 0) {
            return i;
        }
    }
    return NOT_FOUND;
}

const char* word = "two";
const char* words[] = {"one", "two", "three", "four"};
const size_t sizeWords = std::size(words);
size_t res;

res = Find<const char*>(word, words, sizeWords);
res = Find(word, words, sizeWords);

3.2 对模板参数推导的更多介绍

编译器根据传递给函数模板的实参来推导模板参数的类型，而对于无法推导的模板参数，则需要显式指定。例如，如下 add() 函数模板需要三个模板参数：返回值的类型以及两个操作数的类型
```
template <typename RetType, typename T1, typename T2>
RetType add(const T1& t1, const T2& t2) {
    return t1 + t2;
}
```
调用这个函数模板时，可指定如下所有三个参数
```
auto result = add<long long, int, int>(1, 2);
```
但由于模板参数 T1 和 T2 是函数的参数，编译器可以推导这两个参数，因此调用 add() 时可仅指定返回值的类型
```
auto result = add<long long>(1, 2);
```

也可提供返回类型模板参数的默认值，这样调用 add() 时可不指定任何类型

template <typename RetType = long long, typename T1, typename T2>
RetType add(const T1& t1, const T2& t2) {
    return t1 + t2;
}
    
auto result = add(1, 2);

3.3 函数模板的返回类型

让编译器推导返回值的类型岂不更好？确实是好，但返回类型取决于模板类型参数，从C++14 开始，可要求编译器自动推导函数的返回类型
```
template <typename T1, typename T2>
auto add(const T1& t1, const T2& t2) {
    return t1 + t2;
}
```
但是，使用 auto 来推导表达式类型时去掉了引用和 const 限定符，C++14 以后可使用 decltype(auto) 编写 add() 函数，以避免去掉任何 const 和引用限定符
```
template <typename T1, typename T2>
decltype(auto) add(const T1& t1, const T2& t2) {
    return t1 + t2;
}
```

4. 可变模板

除了类模板、类方法模板和函数模板外，C++14 还添加了编写可变模板的功能
```
template <typename T>
constexpr T pi = T(3.14159265);
```
上述是 pi 值的可变模板。为了在某种类型中获得 pi 值，可使用如下语法
```
float piFloat = pi<float>;
long double piLongDouble = pi<long double>;
```
这样总会得到在所请求的类型中可表示的 pi 近似值。与其他类型的模板一样，可变模板也可以特殊化