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 element
    void pop(); // pop element
    T const& top() const; // return top element
    bool empty() const { // return whether the stack is empty
        return 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 ints
    Stack<std::string> stringStack; // stack of strings
    // manipulate int stack
    intStack.push(7);
    std::cout << intStack.top() << std::ends;
    // manipulate string stack
    stringStack.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 element
    void pop(); // pop element
    std::string const& top() const; // return top element
    bool empty() const { // return whether the stack is empty
        return 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)==0
        print(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 coll
    typename T::const_iterator end(coll.end()); // end position

    for (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 value
    int* 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
    }
};