《C++Primer》第十六章 模板与泛型编程

template <typename T>
int compare(const T &v1, const T &v2)
{
    if (v1 < v2) return -1;
    if (v2 < v1) return 1;
    return 0;
}

template <typename T> T foo(T* p) {
    T tmp = *p;  // tmp的类型是指针p指向的类型
    // ...
    return tmp;
}

template<unsigned N, unsigned M>
int compare(const char (&p1)[N], const char (&p2)[M])
{
    return strcmp(p1, p2);
}

// 调用
compare("hi", "mom");
// 编译器相当于实例化如下版本:
int compare(const char (&p1)[3], const char(&p2)[4])

template <typename T> class Blob {
public:
    typedef T value_type;
    typedef typename std::vector<T>::size_type size_type;
    // 构造函数
    Blob();
    Blob(std::initializer_list<T> il);
    // 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();
    // 元素访问
    T& back();
    T& operator[](size_type i);
private:
    // Q: 为什么使用智能指针?
    std::shared_ptr<std::vector<T>> data;
    // 若data[i]无效，则抛出msg
    void check(size_type i, const std::string &msg) const;
};

Bolb<int> ia;
Blob<int> ia2 = {0,1,2,3,4};

std::shared_ptr<std::vector<T>> data;

template <typename T>
ret-type Bolb<T>::member-name(param-list)

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

template <typename T>
// 构造函数分配一个空vector, 并将指向vector的指针保存在data中
Bolb<T>::Blob() : data(std::make_shared<std::vector<T>>()) { }

// 接受一个initializer_list参数的构造函数将其类型参数为T作为initializer_list参数的元素类型
template <typename T>
Blob<T>::Blob(std::initializer_list<T> il) : data(std::make_shared<std::vector<T>>(il)) { }

// 使用方法: 在这条语句中构造函数的参数类型为initializer_list<string>,列表中每个字符串字面常量会被隐式地转换为一个string
Blob<string> articles = {"a", "an", "the"};

// 后置: 递增/递减对象但返回原值
template <typenname T>
BlobPtr<T> BlobPtr<T>::operator++(int)
{
    // 此处无须检查, 调用前置递增时会进行检查
    BlobPtr ret = *this; // 保存当前值, 这里等价于BlobPtr<T> ret = *this; 在类模板作用域内简化模板类名的使用
    ++ *this;    // 推进一个元素, 前置++检查递增是否合法
    return ret;  // 返回保存的状态
}

// 首先将Blob、BlobPtr和operator==声明为模板, 这些声明是operator==函数的参数声明及Blob中的友元声明所需要的
template <typename> class BlobPtr;
template <typename> class Blob; // 运算符==中的参数所需要的
template <typename T>
    bool operator==(const Blob<T>&, const Blob<T>&);

template <typename T> class Blob {
    // 每个Blob实例将访问权限授予相同类型实例化的BlobPtr和相等运算符
    friend class BlobPtr<T>;
    friend bool operator==<T>
        (const Blob<T>&, const Blob<T>&);
}

// 友元的声明用Blob的模板形参作为他们自己的模板形参，因此友好关系被限定在用相同类型实例化的Blob与BlobPtr相等运算符之间
Blob<char> ca;   // BlobPtr<char>和operator==<char>都是本对象的友元
Blob<int> ia;    // BlobPtr<int>和operator==<int>都是本对象的友元
// BlobPtr<char>的成员可以访问ca(或者任意其他Blob<char>对象)的非public部分, 但对ia或任何其他Blob<int>对象或Blob的其他实例都没有特殊访问权限

// 前置声明, 在将模板的一个特定实例声明为友元时将要用到
template <typename t> class Pal;
class C { // C时一个普通的非模板类
    friend class Pal<C>;   // 用类C实例化的Pal是C的一个友元
    // Pal2的所有实例都是C的友元, 这种情况无须前置声明
    template <typename T> friend class Pal2;
};

template <typename T> class C2 { // C2本身是一个类模板
    // C2的每个实例将相同实例化的Pal声明Pal声明成友元
    friend class Pal<T>;  // Pal的模板声明必须在作用域之内
    // Pal2的所有实例都是C2的每个实例的友元，不需要前置声明
    template <typename X> friend class Pal2;
    // Pal3是一个非模板类，它是C2所有实例的友元
    friend class Pal3;
}

template <typename Type> class Bar {
friend Type; // 将访问权限授予用来实例化Bar的类型
    // ...
}

typedef Blob<string> StrBlob;d

template <typename T> using twin = pair<T, T>;
twin<string> authors;  // authors是一个pair<string, string>

// 我们也可以固定一个或者多个模板参数
template <typename T> using partNo = pair<T, unsigned>;
partNo<string> books;  // books类型是pair<string, unsigned>

template <typename T> class Foo {
public:
    static std::size_t count() { return ctr; }
    // 其他接口成员
private:
    static std::size_t ctr;
};

template <typename T>
size_t Foo<T>::ctr = 0;

T::size_type *p
// 编译器需要知道我们是正在定义一个名为`p`的变量，还是将一个名为size_type的static数据成员与名为p的变量相乘

template <typename T>
typename T::value_type top(const T& c)
{
    if (!c.empty())
        return c.back();
    else 
        return typename T::value_type(); // 使用T的类型
}

// compare有一个默认模板实参less<T>和一个默认函数实参F()
template <typename T, typename F = less<T>>
int compare(const T &v1, const T &v2, F f = F())
{
    if (f(v1, v2)) return -1;
    if (f(v2, v1)) return 1;
    return 0;
}

template <class T = int> class Numbers { // T 默认为int
public:
    Numbers(T v = 0) : val { }
    // 其他操作
private:
    T val;
};

Number<long double> lots_of_precision;
Number<> average_precision; // 空<>表示我们希望使用默认类型

// 函数对象类. 对给定指针执行delete
class DebugDelete {
public:
    DebugDelete(std::ostream &s = std::cerr) : os(s) { }
    // 与任何函数模板相同, T的类型由编译器推断
    template <typename T> void operator()(T *p) const
        { os << "deleting unique_ptr" << std::endl; delete p; }
private:
    std::ostream &os;
}

double* p = new double;
DebugDelete d; // 可像delete表达式一样使用的对象
d(p); // 调用DebugDelete::operator()(double*), 释放p
int* ip = new int;
// 在一个临时DebugDelete对象上调用operator()(int*)
DebugDelete()(ip);

// 删除p指向的对象
// 实例化DebugDelete::operator()<int>(int *)
unique_ptr<int, DebugDelete> p(new int, DebugDelete());
//销毁sp执行的对象
unique_ptr<string, DebugDelete> sp(new string, DebugDelete());

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) : data(std::make_shared<std::vector<T>>(b, e)) { }

int ia[] = {0,1,2,3,4,5,6,7,8,9};
vector<long> vi = {0,1,2,3,4,5,6,7,8,9};
list<const char*> w = {"now", "is", "the", "time"};
// 实例化Blob<int>类及其接受两个int*参数的构造函数
Blob<int> a1(begin(ia), end(ia));
// 实例化Blob<int>类及其接受两个vector<long>::iterator的构造函数
Blob<int> a2(vi.begin(), vi.end());
// 实例化Blob<string>及其接受两个list<const char*>::iterator参数的构造函数
Blob<string> a3(w.begin(), w.end());

extern template declaration; // 实例化声明
template declaration;        // 实例化定义

// 实例化声明与定义
extern template class Blob<string>;            // 声明
template int compare(const int&, const int&);  // 定义

// Application.cc
// 这些模板类型必须在程序其他位置进行实例化
extern template class Blob<string>;
extern template int compare(const int&, const int&);
Blob<string> sa1, sa2;  // 实例化会出现在其他位置
// Blob<int>及其接受initializer_list的构造函数在本文件中实例化
Blob<int> a1 = {0,1,2,3,4,5,6,7,8,9};
Blob<int> a2(a1);  // 拷贝构造函数在本文件中实例化
int i = compare(a1[0], a2[0]);  // 实例化出现在其他位置

// templateBuild.cc
// 实例化文件必须为每个在其他文件中声明为extern的类型和函数提供一个非extern的定义
template int compare(const int&, const int&);
template class Blob<string>; // 实例化类模板的所有成员

// compare函数接受两个const T&参数, 其实参必须是相同类型
long lng;
compare(lng, 1024); // 错误, 不能实例化compare(long, int)

template <typename T> ostream &print(ostream &os, const T &obj)
{
    return os << obj;
}

// 由于低于一个参数的类型不依赖于模板参数, 因此编译器会将f隐式转换为ostream&
ofstream f("output");
print(f, 10);

// 编译器无法推断T1, 它不会出现在函数参数列表中
template <typename T1, typename T2, typename T3>
T1 sum(T2, T3)

auto val3 = sum<long long>(i, lng); // long long sum(int, long)

// 糟糕的设计, 用户必须指定所有三个模板参数
template <typename T1, typename T2, typename T3>
T3 alternative_sum(T1, T2);

// 错误: 不能推断前几个模板参数
auto val3 = alternative_sum<long long>(i, lng);
// 正确: 显式指定了所有三个参数
auto val2 = alternative_sum<long long, int, long>(i, lng);

long lng;
compare(lng, 1024);       // 模板参数不匹配
compare<long>(lng, 1024); // 正确: 实例化compare(long, long);
compare<int>(lng, 1024);  // 正确: 实例化compare(int, int);

template <typename It>
auto fcn(It beg, It end) -> decltype(*beg) // 通知编译器fcn的返回类型与解引用beg参数的结果类型相同, 解引用类型返回一个左值, 因此通过decltype推断的类型为beg表示的元素的类型的引用
{
    // 处理负担
    return *beg; // 返回序列中一个元素的引用
}

template <typename It>
auto fcn2(It beg, It end) ->
    typename remove_reference<decltype(*beg)>::type
{
    // 处理序列
    return *beg;  // 返回序列中一个元素的拷贝
}

template <typename T> int compare(const T&, const T&);
// pf1指向实例int compare(const int&, const int&)
int (*pf1)(const int&, const int&) = compare;

// func的重载版本: 每个版本接受一个不同的函数指针类型
void func(int(*)(const string&, const string&));
void func(int(*)(const int&, const int&));
func(compare); // 错误: 使用compare哪个实例?

// 我们可以通过显式模板实参来消除func调用的歧义
func(compare<int>); // 传递compare(const int&, const int&)

template <typename T> void f(T &p);

template <typename T> void f1(T&);   // 实参必须是一个左值
f1(i);   // i是一个int; 模板参数类型T是int
f1(ci);  // ci是一个const int; 模板参数T是const int
f1(5);   // 错误: 传递给一个&参数的实参必须是一个左值

template <typename T> void f2(const T&);   // 可以接受一个右值
// f2中的参数是const &; 实参中的const是无关的
// 在每个调用中, f2的函数参数都被推断为const int&
f2(i);   // i是一个int;模板参数T是int
f2(ci);  // ci是一个const int, 但模板参数T是int
f2(5);   // 一个const &参数可以绑定到一个右值; T是int

template <typename T> void f3(T&&);
f3(42);   // 实参是一个int类型的右值; 模板参数T是int

template <typename T> void f3(T&& val)
{
    T t = val; // 实参是左值时, 模板参数T是int&, 那么是绑定一个引用; 实参是右值时, 模板参数T是int, 那么是拷贝val值到t
    t = fcn(t);   // 赋值是只改变t还是既改变t又改变val
    if (val == t) { /*...*/ }  // 如果T是引用类型, 则一直为true
}

// 右值会调用第一个函数, 排除歧义的问题
template <typename T> void f(T&&);       // 绑定到非const右值
template <typename T> void f(const T&);  // 左值和cosnt右值

// 在返回类型和类型转换中也要用到typename
template <typename T>
typename remove_reference<T>::type&& move(T&& t)
{
    return static_cast<typename remove_reference<T>::type&&>(t);
}

string s1("hi!"), s2;
s2 = std::move(string("bye!"))；   // 正确: 从一个右值移动数据
s2 = std::move(s1);                // 正确: 但是赋值之后, s1的值是不确定的

s2 = std::move(string("bye!"))；

string&& move(string &&t)
// 参数t的类型已经是string&&, 因此函数体类型转换什么都不做, 返回它所接受的右值引用

s2 = std::move(s1); 

string&& move(string &t)

// 对"翻转"的参数调用给定的可调用对相关
// flip1是一个不完整的实现: 顶层const和引用丢失了
template <typename F, typename T1, typename T2>
void flip1(F f, T1 t1, T2 t2)
{
    f(t2, t1);
}

void f(int v1, int &v2) // v2是一个引用
{
    cout << v1 << " " << ++v2 << endl;
}

template <typename Type> intermediary(Type &&arg)
{
    finalFcn(std::forward<Type>(arg));
    // ...
}

template <typename F, typename T1, typename T2>
void flip(F f, T1 &&t1, T2 &&t2)
{
    f(std::forward<T2>(t2), std::forward<T1>(t1));
}

template <typename T> string debug_rep(const T &t)
{
    ostringstream ret;
    ret << t;  // 使用T的输出运算符打印t的一个表示形式
    return ret.str();  // 返回ret绑定的string的一个副本
}

// 注意此函数不能用于char*对象, 因为IO库为char*定义了一个<<版本, 此版本假定指针表示一个空字符结尾的字符数组, 并打印数组的内容而非地址
template <typename T> string debug_rep(T *p)
{
    ostringstream ret;
    ret << "pointer: " << p;  // 打印地址值
    if (p)
        ret << " " << debug_rep(*p);  // 打印p指向的值
    else
        ret << " null pointer";       // 指出p为空
    return ret.str();
}

// 只有第一个版本是可行的, 因为编译器无法从一个费指针参数实例化一个期望值真类型参数的函数模板
string s("hi");
cout << debug_rep(s) << endl;

// 如果用指针调用, 则两个版本都是可行的
cout << debug_rep(&s) << endl;
// 第一个版本的T被绑定到string*, 实例化debug_rep(const string*&)
// 第二个版本的T被绑定到string, 实例化debug_rep(string*)

cout << debug_rep("hi world!") << endl;  // 调用debug_rep(T*)

// Args是一个模板参数包; rest是一个函数参数包
// Args表示零个或多个模板类型参数
// rest表示零个或多个函数参数
template <typename T, typename... Args>
void foo(const T &t, const Args& ... rest)

// 调用方式
int i = 0; double d = 3.14; string s = "how now brown cow";
foo(i, s, 42, d);   // 包中三个参数
foo(s, 42, "hi");   // 包中两个参数
foo(d, s);          // 包中一个参数
foo("hi");          // 空包

// 编译器会分别实例化对应的版本
void foo(const int&, const string&, const int&, const double&);
void foo(const string&, const int&, const char[3]&);
void foo(const double&, const string&);
void foo(const char[3]&);

template <typename ... Args> void g(Args ... args) {
    cout << sizeof...(Args) << endl;  // 类型参数的数目
    cout << sizeof...(args) << endl;  // 函数参数的数目
}

// 用于终止递归并打印最后一个元素的函数
// 此函数必须在可变参数版本的print定义之前声明
template <typename T>
ostream &print(ostream &os, const T &t)
{
    return os << t; // 包中最后一个元素之后不打印分隔符
}

// 包中除了最后一个元素之外的其他元素都会调用这个版本的print
template <typename T, typename... Args>
ostream &print(ostream &os, const T &t, const Args&... rest)
{
    os << t << ", ";    // 打印第一个实参
    return print(os, rset...); // 递归调用, 打印其他实参
}
// 调用:
print(cout, i, s, 42);  // 包中有两个参数
// 依次执行:
print(cout, i, s, 42);  // t:i, rset:s, 42
print(cout, s, 42);     // t:s, rset:42
print(cout, 42);        // 调用非可变参数版本的print

template <typename T, typename... Args>
ostream &print(ostream &os, const T &t, const Args&... rest) // 扩展Args
{
    os << t << ", ";   
    return print(os, rset...);                               // 扩展rest
}

// 在print调用中对每个实参调用debug_rep
template <typename... Args>
ostream &errorMsg(ostream &os, const Args&... rest)
{
    // 等价于print(os, debug_rep(a1), debug_rep(a2), ..., debug_rep(an))
    return print(os, debug_rep(rset)...);
}

// fun有零个或多个参数, 每个参数都是一个模板参数类型的右值引用
template<typename... Args>
void fun(Args&&... args)   // 将Args扩展为一个右值引用的列表
{
    // work的实参既扩展Args又扩展args
    work(std::forward<Args>(args)...);
}

// 第一个版本: 可以比较任意两个类型
template <typename T> int compare(const T&, const T&);
// 第二个版本处理字符串字面常量
template<size_t N, size_t M>
int compare(const char (&)[N], const char (&)[M]);

const char *p1 = "hi", *p2 = "mom";
compare(p1, p2);      // 调用第一个模板版本
compare("hi", "mom"); // 调用第二个版本

// compare的特殊版本, 处理字符数组的指针
template<>
int compare(const char* const&p1, const char* const &p2)
{
    return strcmp(p1, p2);
}

// 原始的通用的版本
typename <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; };
    
// 调用
int i;
// decltype(42)为int, 使用通用版本
remove_reference<decltype(42)>::type a;
// decltype(i)为int&, 使用第一个版本T&
remove_reference<decltype(i)>::type b;
// decltype(std::move(i))为int&&, 使用第二个版本T&&
remove_reference<decltype(std::move(i))>::type c;

template <typename T> struct Foo {
    Foo(const T &t = T()) : mem(t) { }
    void Bar() { /*...*/ }
    T mem;
    // Foo其他成员
};
template<>       // 我们正在特例化一个模板
void Foo<int>::Bar()   // 我们正在特例化Foo<int>的成员Bar