《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 访问说明符必须在 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，可通过类型别名指定一个更简单的名称

  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 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(在 中定义)。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 的对象赋给类型为 Grid 的对象，也不能从 Grid 构造 Grid

• Grid 复制构造函数和 operator= 都接收 const 的引用作为参数

  Grid(const Grid<T>& src);
  Grid<T>& operator=(const Grid<T>& rhs);
  

• 当实例化 Grid 并试图调用复制构造函数和 operator= 时，编译器通过这些原型生成方法

  Grid(const Grid<double>& src);
  Grid<double>& operator=(const Grid<double>& rhs);
  

• 在生成的 Grid 类中，构造函数或 operator= 都不接收 Grid 作为参数，但可通过双重模板解决：在 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::optional

2.7 从类模板派生

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