1.1.3 两阶段编译检查（Two-Phase Translation ）

• 语法检查。比如少了分号。
• 使用了未定义的不依赖于模板参数的名称（类型名，函数名，......）。
• 未使用模板参数的 static assertions。

template<typename T>
void foo(T t)
{
undeclared(); // 如果 undeclared()未定义，第一阶段就会报错，因为与模板参
数无关
undeclared(t); //如果 undeclared(t)未定义，第二阶段会报错，因为与模板参
数有关
static_assert(sizeof(int) > 10,"int too small"); // 与模板参数无关，
总是报错
static_assert(sizeof(T) > 10, "T too small"); //与模板参数有关，只会
在第二阶段报错
}

template<typename T>
T max (T const& a, T const& b)
{return b < a ? a : b;
}

template<typename T>
T max (T a, T b); …
int const c = 42;
Int i = 1; //原书缺少 i 的定义
max(i, c); // OK: T 被推断为 int，c 中的 const 被 decay 掉
max(c, c); // OK: T 被推断为 int
int& ir = i;
max(i, ir); // OK: T 被推断为 int， ir 中的引用被 decay 掉
int arr[4];
foo(&i, arr); // OK: T 被推断为 int*

max(4, 7.2); // ERROR: 不确定 T 该被推断为 int 还是 double
std::string s;
foo("hello", s); //ERROR: 不确定 T 该被推断为 const[6] 还是 std::string

template<typename T1, typename T2>
T1 max (T1 a, T2 b)
{return b < a ? a : b;
}…
auto m = ::max(4, 7.2); // OK, 但是返回类型是第一个模板参数 T1 的类型

template<typename T>
T max (T a, T b);…::max<double>(4, 7.2); // max()被针对 double 实例化

template<typename T1, typename T2>
auto max (T1 a, T2 b)
{return b < a ? a : b;
}

1.3.3 将返回类型声明为公共类型（Common Type）

#include <type_traits>
template<typename T1, typename T2>
std::common_type_t<T1,T2> max (T1 a, T2 b)
{return b < a ? a : b;
}

1.4 默认模板参数

#include <type_traits>
template<typename T1, typename T2, typename RT =
std::decay_t<decltype(true ? T1() : T2())>>
RT max (T1 a, T2 b)
{return b < a ? a : b;
}

#include <type_traits>
template<typename T1, typename T2, typename RT =
std::common_type_t<T1,T2>>
RT max (T1 a, T2 b)
{return b < a ? a : b;
}

// maximum of two int values:
int max (int a, int b)
{return b < a ? a : b;
}
// maximum of two values of any type:
template<typename T>
T max (T a, T b)
{return b < a ? a : b;
}int main()
{
::max(7, 42); // calls the nontemplate for two ints
::max(7.0, 42.0); // calls max<double> (by argument deduction)
::max(’a’, ’b’); //calls max<char> (by argument deduction)
::max<>(7, 42); // calls max<int> (by argumentdeduction)
::max<double>(7, 42); // calls max<double> (no argumentdeduction)
::max(’a’, 42.7); //calls the nontemplate for two ints
}

1.6.3 为什么不用 constexpr？

1.7 总结

• 函数模板定义了一组适用于不同类型的函数。
• 当向模板函数传递变量时，函数模板会自行推断模板参数的类型，来决定去实例化出那 种类型的函数。
• 你也可以显式的指出模板参数的类型。
• 你可以定义模板参数的默认值。这个默认值可以使用该模板参数前面的模板参数的类 型，而且其后面的模板参数可以没有默认值。
• 函数模板可以被重载。
• 当定义新的函数模板来重载已有的函数模板时，必须要确保在任何调用情况下都只有一 个模板是最匹配的。
• 当你重载函数模板的时候，最好只是显式地指出了模板参数得了类型。
• 确保在调用某个函数模板之前，编译器已经看到了相对应的模板定义。

第二章 类模版

2.1-2.2 实现与使用

// testtemplate.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//#include <iostream>#include <vector>
#include <cassert>
template<typename T>
class Stack {
private:std::vector<T> elems; // elements
public:void push(T const& elem); // push elementvoid pop(); // pop elementT const& top() const; // return top elementbool empty() const { // return whether the stack is emptyreturn elems.empty();}
};
template<typename T>
void Stack<T>::push(T const& elem)
{elems.push_back(elem); // append copy of passed elem
}
template<typename T>
void Stack<T>::pop()
{assert(!elems.empty());elems.pop_back(); // remove last element
}
template<typename T>
T const& Stack<T>::top() const
{assert(!elems.empty());return elems.back(); // return copy of last element
}int main()
{Stack< int> intStack; // stack of intsStack<std::string> stringStack; // stack of strings// manipulate int stackintStack.push(7);std::cout << intStack.top() << std::ends;// manipulate string stackstringStack.push("hello");std::cout << stringStack.top() << std::ends;stringStack.pop();return 0;
}

template<typename T>
class Stack { …
void printOn() (std::ostream& strm) const {for (T const& elem : elems) {strm << elem << ’ ’; // call << for each element}
}
};

template<typename T>
class C
{static_assert(std::is_default_constructible<T>::value,"Class C requires default-constructible elements");…
};

2.4 友元

void Stack<std::string>::push (std::string const& elem)
{elems.push_back(elem); // append copy of passed elem
}

template<>
class Stack<std::string> {
private:std::deque<std::string> elems; // elements
public:void push(std::string const&); // push elementvoid pop(); // pop elementstd::string const& top() const; // return top elementbool empty() const { // return whether the stack is emptyreturn elems.empty();}
};
void Stack<std::string>::push(std::string const& elem)
{elems.push_back(elem); // append copy of passed elem
}
void Stack<std::string>::pop()
{assert(!elems.empty());elems.pop_back(); // remove last element
}
std::string const& Stack<std::string>::top() const
{assert(!elems.empty());return elems.back(); // return copy of last element
}

Alias Templates（别名模板）

Stack< int> intStack1; // stack of strings
Stack< int> intStack2 = intStack1; // OK in all versions
Stack intStack3 = intStack1; // OK since C++17

template<typename T>
class Stack {
private:std::vector<T> elems; // elements
public:Stack () = default;Stack (T const& elem) // initialize stack with one element: elems({elem}) {}…
};

• firstArg 的值是“hello”，其类型 T 是 char const *。
• args 是一个可变模板参数，它包含的参数类型是 std::string。

• firstArg 的值是“world”，其类型 T 是 std::string。
• args 是一个空的可变模板参数，它没有任何值。

4.1.2 变参和非变参模板的重载

上面的例子也可以这样实现：

// testtemplate.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//#include <iostream>template<typename T>
void print(T arg)
{std::cout << arg << std::endl;
}
template<typename T, typename ... Types>
void print(T firstArg, Types... args)
{print(firstArg);print(args...); // call print() for remaining arguments
}int main()
{std::string s("world");print(7.5, "hello", s);return 0;
}

template<typename T, typename… Types>
void print (T firstArg, Types… args)
{std::cout << firstArg << ’\n’;if (sizeof…(args) > 0) { //error if sizeof…(args)==0print(args…); // and no print() for no arguments declared
}
}

template<typename T, typename ... Types>
void print(T const& firstArg, Types const&... args)
{std::cout << firstArg << "\n";if constexpr (sizeof...(args) > 0) {print(args...); }
}

// testtemplate.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//#include <iostream>template<typename ...args>
auto foldSum(args... arg) {return (... + arg);
}int main()
{std::cout << foldSum(1, 2, 3);return 0;
}

template<typename ...Types>
auto print(Types... args) {(std::cout << ... << args) << "\n";
}

// print elements of an STL container
template<typename T>
void printcoll(T const& coll)
{typename T::const_iterator pos; // iterator to iterate over colltypename T::const_iterator end(coll.end()); // end positionfor (pos = coll.begin(); pos != end; ++pos) {std::cout << *pos << "";}std::cout << "\n";
}int main()
{std::string test = "hello";printcoll(test);return 0;
}

5.2零初始化

template<typename T>
void foo()
{T x; // x has undefined value if T is built-in type
}

void foo()
{int x{}; // x has undefined valueint* ptr{}; // ptr points to anywhere (instead of nowhere)std::cout << x << "  " << ptr;
}

template<typename T>
void foo()
{T x{}; // x is zero (or false) if T is a built-in type
}

template<typename T>
class MyClass {
private:
T x{}; // zero-initialize x unless otherwise specified …
};

template<typename T>
void foo(T p = T{}) { //OK (must use T() before C++11) …
}

template<typename T>
class Base {
public:void bar();
};template<typename T>
class Derived : Base<T> {
public:void foo() {bar(); // calls external bar() or error}
};