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

// 错误，U 之前必须加上 class 或 typename
template <typename T, U>
T calc(const T&, const U&);

template <unsigned N, unsigned M>
int compare(const cahr (&p1)[N], const cahr (&p2)[M])
[
   return strcmp(p1, p2);
}
compare("hi", "mom");
// 上式调用会实例化处如下版本，注意字符串字面常量的末尾有一个空字符！
int compare(const cahr (&p1)[3], const cahr (&p2)[4])

//正确，inline 说明符跟在模板参数列表之后
template <typename T> inline T min(const T&, const T&);
//错误：inline 说明符的位置不正确
inline template <typename T> T min(const T&, const T&);

template <typename T>
class Bolb {
public:
    typedef T value_type;
    typedef typename std::vector<T>::size_type size_type;
    //构造函数
    Bolb();
    Bolb(std::initializer_list<T> il);
    //Bolb中的元素数目
    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:
    std::shared_ptr<std::vector<T>> data;
    //若data[i]无效，则抛出msg
    void check(size_type i, const std::string &msg) const;
};

Bolb<int> ia;   //空 Bolb<int>
Bolb<int> ia2 = {0,1,2,3,4};    //有5个元素的 Bolb<int>

template <typename T>
class BolbPtr {
public:
...
//递增和递减
BolbPtr& operator++();  //前置运算符
BolbPtr& operator--();
...
};

template <typename T>
// 返回类型，处于类的作用域之外，需要提供模板实参
BlobPtr<T> BlobPtr<T>::operator++(int)
{
   // 函数体内，处于类的作用域之内
   BlobPtr ret = *this;
   ...
}

// 为了在 Blob 中声明友元，需要前置声明
template<typename T> class BlobPtr;
template<typename T> class Blob;   // 声明运算符 == 中的参数所需要的
template<typename T>
  bool operator==(const Blob<T> &lhs, const Blob<T> &rhs);
template <typename T>
class Blob
{
   // 每个 Blob 实例将访问权限授予用相同类型实例化的 BlobPtr 和相等运算符
   friend class BlobPtr<T>;
   friend bool operator==<T>
            (const MyBlobPtr &lhs, const MyBlobPtr &rhs);
   // 其它成员定义
};
// BlobPtr<char> 的成员可以访问 ca（或任何其它 Blob<char>对象）的非 public 部分
Blob<char> ca;
Blob<int> ia;

// 前置声明，在将模板的一个特定实例声明为友元时要用到
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 声明为友元
   friend class Pal<T>;   // Pal 的模板声明必须在作用域之内
   // Pal2 的所有实例都是 C2 的每个实例的友元，不需要前置声明
   template<typename X> friend class Pal2;
   // Pal3 是一个非模板类，它是 C2 所有实例的友元
   friend class Pal3;   // 不需要 Pal3 的前置声明
};

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

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

template <typename T>
using partNo = pair<T, unsigned>;
partNo<string> books;   //books 是一个 pair<string, unsigned>
partNo<Vehicle> cars;   //cars 是一个 pair<Vehicle, unsigned>
partNo<Student> kids;   //kids 是一个 pair<Student, unsigned>

template <typename T> class Foo {
public:
   static std::size_t count() { return ctr; }
   // 其它接口成员
private:
   static std::size_t ctr;
   // 其它数据成员
};
// 所有三个对象共享相同的 Foo<int>::ctr 和 Foo<int>::count 成员
Foo<int> fi, fi2, fi3;

Foo<int> fi;                  // 实例化 Foo<int> 类和 static 数据成员 ctr
auto ct = Foo<int>::count();  // 实例化 Foo<int>::count
ct = fi.count();              // 使用 Foo<int>::count
ct = Foo::count();            // 错误，无法确定使用哪个模板实例化的 count

typedef double A;
template <typename A, typename B> void f(A a, B b)
{
   A tmp = a;  // tmp的类型为模板参数 A 的类型，而非 double
   double B;   // 错误，重声明模板参数 B
}

template <typename T> class Blob;  // 声明但不定义

template <typename T>
typename T::value_type top(const T& c)
{
    if (!c.empty())
        return c.back();
    else
        return typename T::value_type();
}

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

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

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));

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};
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>;

template <typename T>
T fobj(T, T);   //实参被拷贝
template <typename T>
T fref(const T&, const T&); //引用捕获方式；c 显示捕获，值捕获方式
string s1("a value");
const string s2("another value");
fobj(s1, s2);   //调用 fobj(string, string);const 被忽略
fref(s1, s2);   //调用 fref(const string&, const string&),将 s1 转换为 const 是允许的

int a[10], b[42];
fobj(a, b); //调用 f(int*, int*)
fref(a, b); //错误：数组类型不匹配

template <typename T>
ostream &print(ostream &os, const T &obj)
{
    return os << obj;
}
//第一个函数参数是一个已知类型 ostream&。第二个参数 obj 则是模板参数类型
//由于 os 的类型是固定的，因此当调用 print 时，传递给它的实参会进行正常的
//类型转换
print(const , 42);  //实例化 print(ostream&, int)
ofstream f("output");
print(f, 10);   //使用 print(ostream&, int);将 f 转换为 ostream&

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

//T1 是显示指定的，T2 和 T3 是从函数实参类型推断而来的
auto val3 = sum<long long>(i, lng); //long long sum(int, long)

long lng;
compare(lng, 1024);           // 错误，模板参数不匹配
compare<long>(lng, 1024);     // 正确，1024自动转化为 long

//尾置返回允许我们在参数列表之后声明返回类型
template <typename It>
auto fcn(It beg, It end) -> decltype(*beg)
{
    //处理序列
    return *beg;    //返回序列中一个元素的引用
}

// 返回一个序列中的元素值
// 为了使用模板参数的类型成员，必须使用 typename
template <typename It>
auto fcn(It beg, It end) ->
   typename remove_reference<decltype(*beg)>::type;
{
   // 处理序列
   return *beg;
}

template <typename T> int compare(const T&, const T&);
// func 的重载版本，每个版本接受一个不同的函数指针类型
void func(int(*)(const string&, const string&));
void func(int(*)(const int&, const int&));
func(compare);   // 错误，不能确定使用哪一个实例
// 正确的做法是可以显式指出实例化哪个版本
func(compare<int>);

template <typename T> void f3(T&&)
{
   T t = val;    // 实参为右值时，赋值语句
                 // 实参为左值时，绑定引用
   t = fcn(t);   // 实参为右值时，只改变 t
                 // 实参为左值时，既改变 t，也改变 val
}
// 定义一组重载函数，解决上述问题
template <typename T> void f(T&&);         // 绑定到非 const 右值
template <typename T> void f(const T&);    // 绑定到左值和 const 右值

//在返回类型和类型转换中也要用到 typename
template <typename T>
typename remove_reference<T>::type&& move(T&& t)
{
    //特例：可以使用 static_cast 显式地将左值转换为右值
    return static_cast<typename remove_reference<T>::type&&>(t);
}

// 该模板将两个额外参数逆序传递给指定的可调用对象
template<typename F, typename T1, typename T2>
   void flip1(F f, T1 t1, T2 t2)
{
   f(t2, t1);
}
// flip1 一般情况下工作的很好，但是当用它调用一个接受引用参数的函数时会出现问题
void f(int v1, int &v2)
{
    cout << v1 << " " << ++v2 << endl;
}
f(42, i);        // f 改变了实参 i
flip1(f, j, 42)  // j 的值不会改变

// 该模板将两个额外参数逆序传递给指定的可调用对象
template<typename F, typename T1, typename T2>
   void flip2(F f, T1 &&t1, T2 &&t2)
{
   f(t2, t1);
}
// flip2 对接受左值引用函数工作的很好，但不能用于接受右值引用的函数
void g(int &&v1, int &v2)
{
    cout << v1 << " " << v2 << endl;
}
g(42, i);        // 正确
flip1(g, i, 42)  // 错误，g 中接收到的 “42” 是左值

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

// 通用模板，返回 T 型对象 t 的 string 表示
template <typename T>
string debug_rep(const T &t)
{
    std::ostringstream ret;
    ret << t;
    return ret.str();
}
// 通用模板，返回 T 型指针 p 的 string 表示
template <typename T>
string debug_rep(T *p)
{
    std::ostringstream ret;
    // 打印指针本身的值
    ret << "pointer: " << p;
    // p不为空，则打印 p指向的值
    if (p)
        ret << " " << debug_rep(*p);
    else
        ret << " null pointer";
    return ret.str();
}
// 对于下面的代码调用，只会使用第一个模板
string s("hi");
cout << debug_rep(s) << endl;
// 对于下面的代码调用，最终会调用第二个模板
cout << debug_rep(&s) << endl;
// 对于下面的代码调用，最终会调用第二个模板
const string *sp = "hi";
cout << debug_rep(sp) << endl;
// 再定义一个普通非模板函数，打印双引号包围的 string
string debug_rep(const string &s)
{
    cout << '"' + s + '"';
}
// 对于下面的代码调用，会使用普通非模板函数
cout << debug_rep(s) << endl;
// 对于下面的代码调用，最终会调用第二个模板
cout << debug_rep("hi") << endl;

template <typename T> string debug_rep(const T &t);
template <typename T> string debug_rep(T *p);
// 为了使 debug_rep(char*) 的定义正确工作，下面的声明必须在作用域中
string debug_rep(const string &);
string debug_rep(char *p)
{
   // 如果接受一个 const string&的版本的声明不在作用域中，
   // 返回语句将调用 debug_rep(const T &t) 的 T 实例化为 string 的版本
   return debug_rep(string(p));
}

// Args 是一个模板参数包； rest 是一个函数参数包
// Args 表示零个或多个模板类型参数
// rest 表示零个或多个函数参数
template <typename T, typename... Args>
void foo(const T &t, const Args& ... rest);
// 对于下面调用
int i = 0;
foo(i, "hi");  // 包中有一个参数，实例化为 foo(const int &, const char[3]&);
foo("hi");     // 空包，实例化为 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, rest...);  // 递归调用，打印其他实参
}

template<typename T, typename... Args>
ostream& print(ostream &os, const T &t, const Args&... rest)  // 扩展 Args
{
   os << t << ", ";
   return print(os, rest...);                                 // 扩展 rest
}
// 对 Args 的扩展中，将模式 const Arg& 应用到模板参数包 Args 中的每个元素
print(cout, i, s, 42);
// 实例化的形式为
ostream&
print(ostream &, const int&, const string&, const int&);

template<typename... Args>
ostream& errorMsg(ostream &os, const Args&... rest)
{
   print(os, debug_rep(rest)...);
   // 上式等价于
   print(os, debug_rep(a1), debug_rep(a2), ..., debug_rep(a3));
   // 注意，不可以写成下式形式
   print(os, debug_rep(rest...));  // 错误，此调用无匹配函数
   return os;
}

// 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 cahr (&p1)[N], const cahr (&p2)[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);
}
// 参数类型为指针，不能调用第二个版本，这里调用的是特例化版本
compare(p1, p2);

template <typename T> struct std::hash;
class Sales_data
{
   friend struct std::hash<Sales_data>;
   // 其它数据成员
};
// 为了使 Sales_data 能存储在无序容器中，特例化 hash 模板
// 注意， Sales_data 类应支持 == 操作
namespace std {
    template <>
    struct hash<Sales_data>
    {
        typedef size_t result_type;
        typedef Sales_data argument_type;
        size_t operator()(const Sales_data &s) const;
    };
    inline size_t
    hash<Sales_data>::operator()(const Sales_data & s) const
    {
        std::cout << "hash模板的 Sales_data特例化版本" << std::endl;
        return hash<string>()(s.bookNo) ^
            hash<unsigned>()(s.units_sold) ^
            hash<double>()(s.revenue);
    }
}

template <typename T> struct Foo {
   Foo(cosnt T &t = T()) : men(t) {}
   void Bar() { /* ... */ }
   T men;
   // Foo 的其他成员
};
template<>                  // 表示正在特例化一个模板
void Foo<int>::Bar()        // 正在特例化 Foo<int> 的成员 Bar
{
   // 进行应用于 int的特例化处理
}
Foo<string> fs;        // 实例化 Foo<string>::Foo()
fs.Bar();              // 实例化 Foo<string>::Bar()
Foo<int> fi;           // 实例化 Foo<int>::Foo()
fi.Bar();              // 使用特例化版本的 Foo<int>::Bar()