《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 近似值。与其他类型的模板一样,可变模板也可以特殊化

你可能感兴趣的:(C++进阶学习笔记,c++,开发语言,算法,学习,笔记)