模板与泛型编程

c primer_模板与泛型编程都是编程范式，用于编写与特定数据类型无关的代码，以增加代码的复用性和灵活性。

1

• 第16章 模板与泛型编程
• 绿色为扩展模式，它会独立地应用于包中的每个元素
• 匹配优先规则：普通非模板函数 > 特例化模板函数 > 通用模板函数
• 四、可变参数模板
  • 定义
    • template <typename T, typename... Args> void foo(const T& t, const Args&... rest);
    • 参数包
      • 模板参数包
        • Args是一个模板参数包，表示有零个或多个模板类型参数
      • 函数参数包
        • rest是一个函数参数包，表示零个或多个函数参数
    • 使用
      • int i; double d; string s; foo(i, d, s); // 包中有2参数，实例化为void foo(const int&, const double&, const string&);
      • sizeof...(Args)或sizeof...(rest)可得出参数包中元素个数
  • 包扩展
    • 定义：将包分解为构成的元素。扩展前需要提供扩展模式，对每个元素应用模式，获得扩展后的列表，通过在模式右边放一个...号来触发扩展操作。
    • 例1
    • template <typename T, typename... Args> ostream& print(ostream &os, const T&t, const Args&... rest) { return print(os, rest...); }
      • 对Args的扩展中，编译器将模式const Args&应用到模板参数包Args中的每个元素，扩展后的结果是以逗号分开的多个类型的列表，每个类型都形如const type&.
      • 在rest扩展中，rest是扩展模式，扩展后得到一个以逗号分隔的元素列表.
    • 例2
    • template <typename... Args> ostream& errmsg(ostream& os, const Args&... rest) { return print(os, debug(rest)...); // 将rest参数包中每个元素传递给debug函数 }
      • errmsg(cerr, fcnName, code.num()); print(cerr, debug(fcnName), debug(code.num())); // 扩展后的样子
  • 转发包参数
    • template <typename... Args> void emplace_back(Args&&... args) { alloc.construct(first++, std::forward<Args>(args)...); } emplace_back( val, str, 60);
    • 为什么使用右值引用？在调用emplace_back时，为了保持实参的类型信息，只有当函数形参为T&&时，才能完全保持实参的属性信息。 为什么使用forward？模板中转发T&&参数时，需要保持参数的类型属性，forward可以做到。
  • 典型应用——递归
    • template <typename T> ostream& print(ostream &os, const T&t) { return os << t; } // 终止递归版本，必须定义在前面,否则在递归到最后一次时编译器找不到该终止版本而报错。 template <typename T, typename... Args> ostream& print(ostream &os, const T&t, const Args&... rest) { return print(os, rest...); }
    • 递归调用关系如下：
      • 1.print(cout, i, s, 42); // 包中有2个参数
        • 2.print(cout, s, 42); // 包中有1个元素
          • 3.print(cout, 42); // 包中无元素，将调用终止版本
• 三、重载与模板
  • 模板函数之间重载
    • template <typename T> string debug(const T& t) {} —— 版本1 template <typename T> string debug(const T* t) {} —— 版本2
    • string s("hi"); debug(s); // 调用版本1，因为版本2需要一个指针，而实参不是指针 debug(&s); // 两个版本都匹配，版本1中T为string*，版本2中T为string，版本2专门针对指针，更精准匹配。
  • 模板与非模板函数重载
    • string debug(const string& s) {} —— 版本3，非模板函数 string s("hi"); debug(s); // 版本1和版本3均匹配，但是编译器优先选择非模板版本3
  • 其他
    • 对于有多个重载版本的函数，将他们的声明放在文件最前面，确保在调用这些函数时编译器能选中期望的重载版本
      • 1.template <typename T> string debug(const T& t)； 2.template <typename T> string debug(const T* t)； 3.string debug(const string& s)； debug(string("hi")); // 调用版本3，若版本3未先声明，编译器将选择版本1
• T&&为万能引用，传递右值时将得到右值的引用，传递左值时将得到左值的引用
• 不管传入左值还是右值，最终返回的都是右值引用
• 顶层const无论在形参中还是实参中都将被忽略
• 二、模板实参推断
  • 模板类型转换
    • 模板实参推导时涉及的类型转换
    • 1.const转换：可将一个非const的引用/指针传递给一个const的引用或指针形参
      • template <typename T> T fref(const T&); string s; fref (s); // s被转为const是允许的
    • 2.数组和函数指针转换：若函数形参不是引用类型，则可将数组或函数转换为指针传递
      • template <typename T> T fobj(T, T); int a[10], b[42]; fobj(a, b); // 数组被转为指针，实例化为 int* fobj(int*, int*);
  • 函数模板显示实参
    • 某些场景下，编译器无法推断出模板实参的类型，或我们希望能控制模板实例化出想要的版本。
    • 例1
      • template <typename T1, typename T2, typename T3> T1 sum(T2 a, T3 b) { return a+b; }
      • sum(4, 5); // 错误，调用时并未提供返回类型，故编译器无法推导返回类型 sum<int>(4, 5); // 显式指定返回类型为int
    • 例2
      • template <typename T> int compare(T v1, T v2) { }
      • long lng; compare<int>(lng, 1024); // 我们希望实例化int版本, 故lng被转换为int
  • 尾置返回类型
    • 某些场景下，使用显式模板实参表示模板函数的返回类型会带来负担，使用尾置方式更优雅
    • 例1
      • template <typename It> // 期望？？处是decltype(*beg)，但编译遇到函数参数列表前，beg都是不存在的 ?? &fn (It beg, It end) { return *beg; }
      • vector<int> vi = {1,2,3}; fcn(vi.begin(), vi.end()); // 如何指定返回类型？
      • 方法1. 增加返回类型模板参数，调用时显式指定 template <typename T, typename It> T& fcn(It beg, It end) {} fcn<int>(vi.begin(), vi.end())；
      • 方法2. 使用尾置类型 auto &fn (It beg, It end) -> decltype(*beg) {}
  • 函数指针和实参推断
    • 例1
      • template <typename T> int compare(const T&, const T&); int (*pf1) (const int&, const int&) = compare; //根据指针参数类型，T被推导为int
    • 例2
      • void func(int (*) (const string&, const string&)); void func(int (*) (const int&, const int&)); func(compare); // 错误，compare的T被推断为string还是int？无法确定 func(compare<int>); // 显示指定用int版本
  • 模板实参推断和引用
    • 从左引用函数参数 推断类型
      • 为什么f1(ci)，T被推导为const int？？若T被推导为int，那么就变成了左侧黄色部分的场景，这种场景是不允许的，故模板推导中T带了const属性。
    • 从右值引用函数参 数推断类型
      • template <typename T> void f3(T&& val); f3(42); // 实参是int类型的右值，模板参数T是int f3(i); // i是左值,T被推导为int&，根据折叠规则val最终类型为int&
    • 引用折叠
      • X& &、X& &&、X&& &都将折叠为X&
      • X&& &&折叠为X&&
  • std::move
    • 功能：获得一个绑定到左值上的右值引用
    • 实现
      • template <typename T> typename remove_reference<T>::type&& move(T&& t) { return static_cast<typename remove_reference<T>::type&&>(t); }
    • 原理
      • string s1("hello"), s2; s2 = std::move(s1);
      • 解释：传入左值，T推导为string&，经引用折叠后参数t类型为string&，remove_reference<T>::type 为string，最终为string&& move(string& t);
      • string s2; s2 = std::move(string("hello"));
      • 解释：传入右值，T被推导为string, remove_reference<T>::type为string,最终即为string&& move(string&& t);
  • 完美转发std::forward
    • 功能：将函数参数连同类型不变地转发给其他函数，我们需要保持参数的所有性质，包括const和左右值属性。一般用于那些定义为模板类型参数的右值引用的函数参数（T&&)
    • 实现
      • template <typename T> T&& forward(typename std::remove_reference<T>::type& __t) { return static_cast<T&&>(__t); } template <typename T> T&& forward(typename std::remove_reference<T>::type&& __t) { return static_cast<T&&>(__t); }
    • 原理
      • void process(const Widget& lval); void process(Widget&& rval); template <typename T> void logProcess(T&& t){ process(std::forward<T>(t)); }
      • Widget w; logProcess(w);
      • 解释：传入左值，T为Widget&，forward返回一个左值引用，调用process左值版本
      • logProcess(std::move(w));
      • 解释：传入右值，T为Widget，t为左值，forward后得到一个右值引用
    • 总结： 1. 一个函数参数为右值引用（T&& t),那么它对应的实参的const属性和左值右值属性将得到保持，会全部传到t。 2. 当需要把参数 t 转发给其他函数时，使用forward会保持实参的所有细节.
• 一个特例化版本本质上是一个实例，而非函数名的一个重载版本
• 五、模板特例化
  • 函数模板特例化
    • // 通用模板 template <typename T> int compare(const T&, const T&); // 下面是特例化版本 template <> int compare(const char* const &p1, const char* const &p2){}
    • 存在多个函数模板都可匹配时，匹配优先级：
      • 1.非模板函数
        • 2.特例化版本
          • 3.普通模板函数
  • 类模板特例化
    • 全特化
      • // 通用模板 template <typename T> class Blob {}; // 特例化版本 template <> class Blob<int> {};
    • 偏特化：指定一部分而非所有模板参数，或是指定参数的一部分特性而非全部特性
      • 函数模板不支持偏特化，必须为每个参数提供实参
      • // 通用版本 template <class T> struct remove_reference { typedef T type; } // 偏特化版本，针对引用的场景 template <class T> struct remove_reference<T &> { typedef T type; } template <class T> struct remove_reference<T &&> { typedef T type; }
    • 特例化类成员
      • template <typename T> struct Foo { void Bar() {} }; // 特例化成员函数Bar template <> void Foo<int>::Bar() {} // T为int时，特例化Foo函数 // 使用 Foo<int> fi; fi.Bar(); // 调用特例化的版本,Foo<int>::Bar() Foo<double> fi; fi.Bar(); // 调用普通版本,Foo<double>::Bar()
• 一、定义模板
  • 函数模板
    • template <typename T> int compare(T v1, T v2) { }
      • compare(3, 5); T将被推导为int
    • 模板参数：根据实参类型自动推导模板实参，并实例化一个特定版本的函数
  • 类模板
    • template <typename T> class Blob { };
      • Blob<int> obj; T 被推导为int
    • 模板参数：无法自动推导，必须显示给出模板实参
    • 成员函数
      • template <typename T> void Blob<T>::check(int val, string str) {}
        • 类外定义时，必须要有模板参数声明；类内定义不需要.
  • 模板参数
    • 作用域：在声明之后至声明结束之前，且会隐藏外层作用域中相同的名字
    • 参数分类
      • 类型参数
        • 用typename或class指定
      • 非类型参数
        • 指针/左引用：必须具有静态生存期
        • 整数：必须是常量表达式：std::array<int, 10> arr;
    • 默认模板实参
      • 类：template <typename T = int> class Blob {};Blob<> b;
      • 函数：template <class T, class F = less<T>> void fun(T t, F f) {} fun(a); // 默认使用less
  • 成员模板
    • 不能是虚函数
    • 普通类的 成员模板
      • class Debug { template <typename T> void check(T* p) { ... } //类内定义 template <typename T> void func(T* p); // 类外定义 };
      • template <typename T> void Debug::func(T* p) { ... } // 类外定义
      • Debug d; d.check(p); d.func(p); //使用时不需要显式指定类型，编译器自动推导
    • 类模板的成员模板：类和成员各自有自己的独立模板参数
      • template <typename T> class Blob { template <typename It> Blob(It b, It e); // 构造函数有自己的模板参数 }; // 类外定义必须先写类的模板参数，再写成员函数的模板参数 template <typename T> template <typename It> Blob<T>::Blob(It b, It e) : ...
      • Blob<int> b (vec.begin(), vec.end()); // 使用时，类的类型参数显式指定，成员函数的类型参数与普通函数一样自动推导
  • 模板编译
    • 1
      • 编译模板本身——只简单检查模板语法：漏分号、变量名未定义等
    • 2
      • 编译实例化代码——再次编译模板代码，检查类型错误等