C++ 16模版和泛型编程

  • 面向对象编程和泛型编程都能处理在编写程序时不知道类型的情况
    • OOP能处理类型在程序运行之前都未知的情况
    • 泛型编程中，在编译时就可以获知类型

定义模板

  • 模板：模板是泛型编程的基础。一个模板就是一个创建类或函数的蓝图或者说公式

函数模板

  • template <typename T> int compare(const T &v1, const T &v2){}
  • 模板定义以关键字 template开始，后接模板形参表，模板形参表是用尖括号<>括住的一个或多个模板形参的列表，用逗号分隔，不能为空
  • 使用模板时，我们显式或隐式地指定模板实参，将其绑定到模板参数上
  • 模板类型参数：类型参数前必须使用关键字class或者typename，这两个关键字含义相同，可以互换使用。旧的程序只能使用class
  • 非类型模板参数：表示一个值而非一个类型。实参必须是常量表达式。template <typename T, size_t N> void array_init(T (&parm)[N]){}
    • 整型（没有浮点型）
    • 函数指针
    • 指向具有静态性的对象的指针
    • 绑定到具有静态性的对象的左值引用
  • 函数模板可以声明为inline或constexpr的，如同非模板函数一样。inline或constexpr说明符放在模板参数列表之后。template <typename T> inline T min(const T&, const T&);
  • 模板程序应该尽量减少对实参类型的要求
  • 函数模板和类模板成员函数的定义通常放在头文件中
  • 模版实例化：当我们使用（而不是定义）模板时，编译器才生成代码

类模板

  • 类模板用于生成类的蓝图
  • 不同于函数模板，编译器不能推断模板参数类型
  • 定义类模板
    • template <typename Type> class Queue {};
  • 实例化类模板：提供显式模板实参列表，来实例化出特定的类
  • 一个类模板中所有的实例都形成一个独立的类
  • 模板形参作用域：模板形参的名字可以在声明为模板形参之后直到模板声明或定义的末尾处使用
  • 类模板的成员函数
    • template <typename T> ret-type Blob<T>::member-name(parm-list)
  • 类模板的名字不是一个类型名
  • 在一个类模板的作用域内，我们可以直接使用模板名而不必指定模板实参
  • 默认情况下，对于一个实例化了的类模板，其成员只有在使用时才被实例化
  • 新标准允许模板将自己的类型参数成为友元。template <typename T> class Bar{friend T;};
  • 模板类型别名：因为模板不是一个类型，因此无法定义一个typedef引用一个模板，但是新标准允许我们为类模板定义一个类型别名：template<typename T> using twin = pair<T, T>; twin<int> test;//等价pair<int, int>
  • static：模版的每一个实例都有自己的static对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include <memory>
#include <vector>

template<typename T> class Blob
{
public:
	typedef T value_type;
	typedef typename std::vector<T>::size_type size_type; //使用作用域运算符时,typename告诉编译器std::vector<T>::size_type是一个类型而不是一个成员

	// constructors
	Blob();
	Blob(std::initializer_list<T> il);

	// number of elements in the Blob
	size_type size() const { return data->size(); }
	bool      empty() const { return data->empty(); }

	void push_back(const T& t) { data->push_back(t); }
	void push_back(T&& t) { data->push_back(std::move(t)); }
	void pop_back();

	// element access
	T& back();
	T& operator[](size_type i);

	const T& back() const;
	const T& operator [](size_type i) const;
    static int ref;

private:
	std::shared_ptr<std::vector<T>> data;
	// throw msg if data[i] isn't valid
	void check(size_type i, const std::string &msg) const;
};

template<typename T> int Blob<T>::ref = 0;

// constructors
template<typename T>
Blob<T>::Blob() : data(std::make_shared<std::vector<T>>())
{}

template<typename T>
Blob<T>::Blob(std::initializer_list<T> il) :
data(std::make_shared<std::vector<T>>(il))
{}

template<typename T>
void Blob<T>::check(size_type i, const std::string &msg) const
{
	if (i >= data->size())
		throw std::out_of_range(msg);
}

template<typename T>
T& Blob<T>::back()
{
	check(0, "back on empty Blob");
	return data->back();
}

template<typename T>
const T& Blob<T>::back() const
{
	check(0, "back on empty Blob");
	return data->back();
}


template<typename T>
T& Blob<T>::operator [](size_type i)
{
	// if i is too big, check function will throw, preventing access to a nonexistent element
	check(i, "subscript out of range");
	return (*data)[i];
}


template<typename T>
const T& Blob<T>::operator [](size_type i) const
{
	// if i is too big, check function will throw, preventing access to a nonexistent element
	check(i, "subscript out of range");
	return (*data)[i];
}

template<typename T>
void Blob<T>::pop_back()
{
	check(0, "pop_back on empty Blob");
	data->pop_back();
}

模板参数

  • 模板参数与作用域：一个模板参数名的可用范围是在声明之后，至模板声明或定义结束前
  • 一个特定文件所需要的所有模板的声明通常一起放置在文件开始位置
  • 当我们希望通知编译器一个名字表示类型时，必须使用关键字typename
  • 默认模板实参 
    1
    2
    3
    4
    5
    6
    7
    template <typename T = int> class Numbers{}; 
    Numbers<> nm;

    template<typename T, typename B = std::vector<std::string>>
    void test(const T &a, const B &vec = {"aa", "bb"}) {
        std::cout << vec.size() << std::endl;
    }

成员模板

  • 成员模板（member template）：本身是模板的函数成员
    • 普通（非模板）类的成员模板
    • 类模板的成员模板
      1
      2
      3
      4
      //在类模板外定义一个成员模板时
      template<typename T> //类模版
      template<typename It> //成员函数模版
      Blob<T>::Blob(It begin, It end):data(std::make_shared<std::vector<T>>(begin, end)) {} //构造函数

控制实例化

  • 动机：在多个文件中实例化相同模板的额外开销可能非常严重
  • 显式实例化
    • extern template declaration; // 实例化声明
    • template declaration; // 实例化定义
  • 一个类模板的实例化定义会实例化该模板的所有成员，包括内联的成员函数。当编译器遇到一个实例化定义时，它不了解程序使用哪些成员函数。因此，与处理类模板的普通实例化不同,编译器会实例化该类的所有成员,即使我们不使用某个成员，它也会被实例化。

模板实参推断

  • 对函数模板，编译器利用调用中的函数实参来确定其模板参数，这个过程叫模板实参推断

类型转换与模板类型参数

  • 和其他函数一样，实参顶层const会被忽略
  • 能够自动转换类型的只有
    • 将一个非const对象的引用（或指针）传递给一个const的引用（或指针）形参
    • 数组实参或函数实参转换为指针

函数模板显式实参

  • 某些情况下，编译器无法推断出模板实参的类型
  • 定义：template <typename T1, typename T2, typename T3> T1 sum(T2, T3);
  • 使用函数显式实参调用：auto val3 = sum<long long>(i, lng); // T1是显式指定，T2和T3都是从函数实参类型推断而来
  • 注意：正常类型转换可以应用于显式指定的实参

尾置返回类型与类型转换

  • 使用场景：并不清楚返回结果的准确类型，但知道所需类型是和参数相关的
  • template <typename It> auto fcn(It beg, It end) -> decltype(*beg)
  • 尾置返回允许我们在参数列表之后声明返回类型

标准库的类型转换模板

  • 定义在头文件type_traits中
对Mod<T>，其中Mod是 若T是 则Mod<T>::type是
remove_reference X&或X&& X
否则 T
add_const X&或const X或函数 T
否则 const T
add_lvalue_reference X& T
X&& X&
否则 T&
add_rvalue_reference X&或X&& T
否则 T&&
remove_pointer X* X
否则 T
add_pointer X&或X&& X*
否则 T*
make_signed unsigned X X
否则 T
make_unsigned 带符号类型 unsigned X
否则 T
remove_extent X[n] X
否则 T
remove_all_extents X[n1][n2]... X
否则 T

函数指针和实参推断

  • 当使用一个函数模板初始化一个函数指针或为一个函数指针赋值时，编译器使用指针的类型来推断模板实参
    1
    2
    3
    4
    template<typename T1>
    void test(const T1 &t) {}

    void (*fp)(const int &) = test;

模板实参推断和引用

  • 从左值引用函数推断类型：若形如T&，则只能传递给它一个左值。但如果是const T&，则可以接受一个右值
  • 从右值引用函数推断类型：若形如T&&，则只能传递给它一个右值
  • 引用折叠和右值引用参数：
    • 规则1：当我们将一个左值传递给函数的右值引用参数，且右值引用指向模板类型参数时（如T&&），编译器会推断模板类型参数为实参的左值引用类型
    • 规则2：如果我们间接创造一个引用的引用，则这些引用形成了折叠。折叠引用只能应用在间接创造的引用的引用，如类型别名或模板参数。对于一个给定类型X
      • X& &、X& &&和X&& &都折叠成类型X&
      • 类型X&& &&折叠成X&&
    • 上面两个例外规则导致两个重要结果
      • 1.如果一个函数参数是一个指向模板类型参数的右值引用（如T&&），则它可以被绑定到一个左值上
      • 2.如果实参是一个左值，则推断出的模板实参类型将是一个左值引用，且函数参数将被实例化为一个左值引用参数（T&）

理解std::move

  • 标准库move函数是使用右值引用的模板的一个很好的例子
  • 从一个左值static_cast到一个右值引用是允许的
1
2
3
4
5
template <typename T>
typename remove_reference<T>::type&& move(T&& t)
{
  return static_cast<typename remove_reference<T>::type&&>(t);
}
  • 一个左值static_cast到一个右值引用是允许的

转发

  • 使用一个名为forward的新标准库设施来传递参数，它能够保持原始实参的类型
  • 定义在头文件utility中
  • 必须通过显式模板实参来调用
  • forward返回显式实参类型的右值引用。即，forward<T>的返回类型是T&&, 如果T是左值引用,基于引用折叠forward返回左值引用
  • 与std::move相同，对std::forward不使用using声明,防止和自定义的重名函数冲突

重载与模板

  • 多个可行模板：当有多个重载模板对一个调用提供同样好的匹配时，会选择最特例化的版本
  • 非模板和模板重载：对于一个调用，如果一个非函数模板与一个函数模板提供同样好的匹配，则选择非模板版本
  • 如果使用了一个忘记声明的函数，代码将编译失败。但对于重载函数模板的函数而言,如果编译器可以从模板实例化出与调用匹配的版本，则缺少的声明就不重要了
  • 在定义任何函数之前，记得声明所有重载的函数版本

可变参数模板

可变参数模板就是一个接受可变数目参数的模板函数或模板类

  • 可变数目的参数被称为参数包
    • 模板参数包：标识另个或多个模板参数
    • 函数参数包：标识另个或者多个函数参数
  • 用一个省略号来指出一个模板参数或函数参数，表示一个包
  • template <typename T, typename... Args>，Args是一个模板参数包
  • void foo(const T &t, const Args& ... rest);，rest是一个函数参数包
  • sizeof...()运算符，返回参数的数目

编写可变参数函数模板

  • 可变参数函数通常是递归的：第一步调用处理包中的第一个实参，然后用剩余实参调用自身
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    template<typename Printable>
    std::ostream& print(std::ostream& os, Printable const& printable)
    {
        return os << printable;
    }
    // recursion
    template<typename Printable, typename... Args>
    std::ostream& print(std::ostream& os, Printable const& printable, Args const&... rest)
    {
        return print(os << printable << ", ", rest...);
    }

包扩展

  • 对于一个参数包，除了获取它的大小，唯一能做的事情就是扩展（expand）
  • 扩展一个包时，还要提供用于每个扩展元素的模式（pattern）
  • 在模式右边放一个省略号(…)来触发扩展操作

转发参数包

  • 新标准下可以组合使用可变参数模板和forward机制，实现将实参不变地传递给其他函数
    1
    2
    3
    4
    template<typename... Args>
    void fun(Args&&... args) {
        work(std::forward<Args>(args)...);  //对args所有元素完美转发
    }

模板特例化（Specializations）

通用的模版没法满足某些特殊类型的需求

  • 定义函数模板特例化：关键字template后面跟一个空尖括号对（<>）
  • 特例化的本质是实例化一个模板，而不是重载它。特例化不影响函数匹配
  • 模板及其特例化版本应该声明在同一个头文件中。所有同名模板的声明应该放在前面，然后是特例化版本
  • 我们可以部分特例化类模板(只对类模板部分模板参数提供实参)，但不能部分特例化函数模板
1
2
3
4
5
6
7
8
9
template<typename T>
void test(const T& t) {
    std::cout << t << std::endl;
}

template<>
void test(const char* const &t){
    std::cout << t << "special" << std::endl;
}

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

二线城市码农，方向偏OS多一点，热爱技术但更热爱生活<br><br>喜欢撸铁，爱玩HIFI但囊中羞涩，梦想开一家属于自己的照相馆，虽然我现在还不会拍照(=_=)