c++--模板与泛型编程

专题--泛型编程的基础（模板）

　　面向对象编程（OOP）和泛型编程都能处理在编写程序时不知道类型的情况。不同之处在于：OOP能处理类型在程序运行之前都未知的情况（动态绑定）；而泛型编程中，在编译时就能获知类型了。模板是泛型编程的基础。

一、 函数模板

1. 适用情况：如果两个函数几乎是相同的，唯一的差异是参数的类型，函数体则完全一样。

2. 定义

　　template <模板参数列表(以逗号分隔)>

template <typename T>
int compare(const T &v1,const T &v2)
{
    if (v1<v2) return -1;     //假设类型T支持<操作
    if (v2<v1) return 1;
}

3. 实例化函数模板　　

　　当调用一个函数模板时，编译器用函数实参推断模板实参。

4. 模板参数类型

　　类型参数T的用途：指定返回类型，指定函数参数类型，在函数体内用于变量声明，变量类型转换

5. 非类型模板参数

　　一个非类型参数表示一个值而非一个类型。当一个模板被实例化时，非类型参数被一个用户提供的或编译器推断出的值所代替，这些值必须是常量表达式。

　　用途：在模板定义内，模板非类型参数是一个常量值。在需要常量表达式的地方，可以使用非类型参数，例如，指定数组大小。

//编写一个conpare版本处理字符串字面常量。
//由于不能拷贝一个数组，所以我们将参数定义为数组的引用
template <unsigned N,unsigned M>
int compare(const char (&p1)[N],const char (&p2)[M])
{
    return strcmp(p1,p2);
}

//调用compare
compare("hi","mom");
//编译器在字符串字面常量末尾插入一个空字符作为终结符，因此编译器实例化出如下版本
int compare(const char (&p1)[3],const char (&p2)[4])

6. inline和constexpr的函数模板　　

　　template <typename T> inline T min(const T&,const T&)        //注意inline位置

7. 编码原则

　　compare函数编写泛型代码的原则：模板中的参数是const 的引用；函数体中的条件判断仅使用<比较运算；

　　一个原则：模板程序应该尽量减少对实参类型的要求。

8. 模板编译

注意：

　　1）只有当我们实例化出模板的一个特定版本时，编译器才会生成代码；

　　2）函数模板和类模板成员函数的定义通常放在头文件中；

　　3）大多数编译错误发生在实例化期间报告。

　　保证传递给模板的实参支持模板所要求的的操作，以及这些操作能正确工作，是调用者的责任。

二、类模板

　　与函数模板不同之处是，编译器不能为类模板推断参数类型。为了使用类模板，必须在模板名后的< >中提供额外信息（显式模板实参）。

1. 用途：与类不同，模板可以用于更多类型的元素。

2. 定义

template <typename T>
class Blob
{
public:
    typedef T value_type;
    typedef typename std::vector<T>::size_type size_type;
    Blob();
    T& back();
    T& operator[](size_type i);
private:
    std::shared_ptr<std::vector<T>> data;
    void check(size_type i,const std::string &msg) const;
}

 3. 实例化类模板

　　与标准库容器(STL)相同，使用Blob时，用户需要指出元素类型。也就是需要提供显式模板实参。

　　Blob<int> ia;

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

　　Blob<string> names;

　　Blob<double> price;

　　一个类模板的每个实例都形成一个独立的类，类型Blob<string>与任何其他Blob类型都没有关联，也不会对任何其他Blob类型的成员有特殊访问权限。

4. 在类模板作用域中引用模板类型

　　类模板用来实例化类型，而一个实例化的类型总是包含模板参数的。无论何时使用模板都必须显式提供模板实参。但这一规则有一个例外，在类模板自己的作用域中，我们可以直接使用模板名而不提供实参。

5. 类模板的成员函数

　　注意：定义在类模板之外的成员函数，必须以关键字template开始，后接类模板参数列表:

//template <typename T>
//ret-type Blob<T>::member-nam(parm-list)

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

6. 类模板成员函数的实例化　　

　　成员函数只有在被用到时才进行实例化，这一特性使得即使某种类型不能完全符合模板操作的要求，我们仍然能用该类型实例化类。但是，实例化定义（template declaration）则不同(C++ Primer5 P598)，实例化定义会实例化所有成员。

　　当模板被使用时才会进行实例化，这一特性意味着，相同的实例可能出现在多个对象文件中。在大系统中，在多个文件中实例化相同模板的额外开销可能非常严重。在新标准中，我们可以通过显式实例化来避免这种开销。一个显式实例化有如下形式：（分别放在不同的两个.cpp文件）

　　extern template declaration;                                 //实例化声明

　　template declaration;                                            //显式实例化定义

declaration是一个类或函数声明，其中所有模板参数已被替换为模板实参。例如：

　　extern template class Blob<string>                     //声明

　　template int compare(const int&,const int&);    //定义

　　当编译器遇到extern模板声明时，它不会在本文件中生成实例化代码。将一个实例化声明为extern就表示承诺程序在其他位置有该实例化的一个非extern定义。对于一个给定的实例化版本，可能有多个extern声明，但必须只有一个定义。

7. 类模板和友元

（C++ Primer P588）

//func.h
#ifndef __FUNC_H__
#define __FUNC_H__

/*对于一个模板类C*/
template <typename> class Pal;  //类模板Pal的前置声明
template <typename T>
class C
{
    //C的每个实例将相同实例化的Pal声明为友元.类模板Pal必须有前置声明
    friend class Pal<T>;                     //相同实例(T)
    //类模板Pal2的所有实例都是C的每个实例的友元。不需要前置声明，友元声明中必须使用与类模板本身不同的模板参数X
    template <typename X> friend class Pal2; //所有实例
    //Pal3是普通类(非模板类)，它是C所有实例的友元
    friend class Pal3;
};

/***************************************************/

/*对于一个普通类(非模板类)C2*/
template <typename T> class PP;   //前置声明
class C2
{
    //用类C2实例化的Pal是C2的一个友元。需要前置声明
    friend class PP<C2>;                     //特定实例
    //PP2的所有实例都是C2的友元。无需前置声明
    template <typename T> friend class PP2;  //所有实例
};

#endif // __FUNC_H__

//main.cpp
#include <iostream>
#include "func.h"         //
using namespace std;

int main()
{
    return 0;
}

总结：

　　1. "特定实例"或"相同实例"作为友元时，必须前置声明。

　　2. "所有实例"成为友元时，不需要前置声明。

　　3. 为了让所有实例成为友元，友元声明中必须使用与类模板本身不同的模板参数(如 X)。

8. 模板类型别名（感觉用处不大）

　　1) typdef引用实例化的类： typedef Blob<string> StrBlob;

　　2) 为类模板定义一个类型别名

　　　　template <typename T> using twin=pair<T,T>;            //一组类的别名

　　　　twin<double> authors;                                                   //pair<double,double> authors;

　　　　twin<int> win_loss;                                                        //pair<int,int> win_loss;

　　3) 定义一个模板类型别名时，可以固定一个或多个模板参数：

　　　　template <typename T> using partNo=pair<T,unsigned>  //固定一个参数unsigned

　　　　partNo<string> books;                                   //pair<string> books;

　　　　partNo<Student> kids;                                   //pair<Student> kids;

9. 类模板的static成员

　　模板类的每个static成员必须有且仅有一个定义。但是，类模板的每个实例都有一个独有的static对象（也就是相同类型对象共用同一个static成员）。类似任何其他成员函数，一个static成员函数只有在使用时才会被实例化。

template <typename T>
class Foo
{
public:
    static std::size_t count() {return str;}
private:
    static std::size_t ctr;
}

//实例化static成员Foo<string>::ctr和Foo<string>::count
Foo<string> fs;
//所有3个对象共享相同的Foo<int>::ctr和Foo<int>::count成员
Foo<int> fi,fi2,fi3;

 三、模板参数

1. 两条原则：

　　1) 模板参数会隐藏外层作用域中声明的相同名字；

　　2) 与大多数其他上下文不同，在模板内不能重用模板参数名；

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

2. 使用类的类型成员

　　默认情况下，C++语言假定通过作用域运算符访问的名字不是类型。因此，如果希望使用一个模板类型参数的类型成员，就必须显式告诉编译器改名字是一个类型。只能通过关键字typename来实现这一点。

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


//区别：
//T::value_type                 访问静态成员
//typename T:：value_type  访问类型成员

 四、成员模板

　　成员模板不能是虚函数。

1. 普通类（非模板）的成员模板

2. 类模板的成员模板

　　在类模板外定义一个成员模板时：必须同时为类模板和成员模板提供模板参数列表。类模板的参数列表在前，后跟成员自己的模板参数列表：

template <typename T>         //类的类型参数
template <typename It>        //构造函数的类型参数
Blob<T>::Blob(It b,It e):data(std::make_shared<std::vetor<T>>(b,e)){}

 五、模板实参推断

　　从函数实参来确定模板实参的过程被称为模板实参推断。

1. 类型转换与模板类型参数

---

　　C++中类型转换有以下几种：

　　 1) const转换：可以将一个非const对象的引用（或指针）传递给一个const的引用（或指针）形参。

　　2) 数组或函数指针转换：如果函数形参不是引用类型，则可以对数组或函数类型的实参应用正常的指针转换。一个数组实参可以转换为一个指向其首元素的指针。类似的，一个函数实参可以转换为一个该函数类型的指针。

　　3) 算术转换：运算符的运算对象将转换成最宽的类型。（c++ primer P142）

　　4) 派生类向基类的转换：派生类向基类的隐式转换（包括动态绑定）。（c++ primer P530）

　　5) 用户定义的转换：类型转换函数的一般形式 "operator type() const;" （c++ primer P263&&P514）

---

　　其中，只有很有限的几种类型转换会自动地应用于函数实参。编译器通常不是对实参进行类型转换，而是生成一个新的模板实例：与往常一样，顶层const无论在形参还是实参中，都会被忽略。在其他类型转换中，能在调用中应用于函数模板的包括如下两项：

　　1) const转换：可以将一个非const对象的引用（或指针）传递给一个const的引用（或指针）形参。

　　2) 数组或函数指针转换：如果函数形参不是引用类型，则可以对数组或函数类型的实参应用正常的指针转换。一个数组实参可以转换为一个指向其首元素的指针。类似的，一个函数实参可以转换为一个该函数类型的指针。

2. 函数模板显式实参

　　当函数返回类型与参数列表中任何类型都不相同时，经常会出现以下两种情况：

　　1) 在某些情况下，编译器无法推断出模板实参的类型；

　　2) 在一些情况下，我们希望允许用户控制模板实例化。

举例：

//编译器无法推断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)

　　显式模板实参按由左至右的顺序与对应的模板参数匹配：第一个模板实参与第一个模板参数匹配，第二个实参与第二个参数匹配，一次类推。只有尾部（最右）参数的显式模板实参才可以忽略，而且前提是它们可以从函数参数中推断出来。

template <typename T1,typename T2,typename T3>
T3 sum(T2,T1);

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

3. 尾置返回类型与类型转换

　　用途：当返回类型不确定时。

1） 尾置返回类型

举例：我们希望编写而一个函数，接受表示序列的一对迭代器和返回序列中一个元素的引用：由于尾置返回出现在参数列表之后，它可以使用函数的参数。

//尾置返回类型
template <typename It>
auto fcn(It beg,It end) ->decltype(*beg)
{
    //处理序列操作
    return *beg;          //返回序列中一个元素的引用
}

//decltype(*beg) 不能写在auto 的位置，是因为在参数列表之前，beg 都是不存在的。

2） 进行类型转换的标准库模板类
　　所需头文件 #include<type_traits>

//remove_reference::type脱去引用，剩下元素类型本身

//为了使用模板参数的成员，必须使用typename
template <typename It>
auto fcn2(It beg,It end) -> 
        typename remove_reference<decltype(*beg)>::type   
{
    //处理序列
    return *beg
}

//typename 告诉编译器，type表示一个类型

4. 函数指针和实参推断

　　当用一个函数模板初始化一个函数指针或为一个函数指针赋值时，编译器使用指针的类型来推断模板实参。

template <typename T> int compare(const T&,const T&);
//pf1指向实例int compare(const int&,const int&);
int (*pf1)(const int&,const int&)=compare;
/****************************************/
//func的重载版本
func(int (*)(const int&,const int&));
func(int (*)(const string&,const string&));
//错误：使用compare的哪个实例
func(compare);
//正确：显式指出实例化哪个版本
func(compare<int>);

　　略（c++ primer P607）

5. 模板实参推断和引用（比较绕）

两个正常绑定规则：

5.1 从左值引用函数参数推断类型

　　1. 当一个函数参数是模板类型参数(T) 的一个普通（左值）引用时（T&），绑定规则告诉我们，只能传递给它一个左值（如一个变量或一个返回引用类型的表达式）。实参可以是const类型，也可以不是。

　　2. 如果一个函数参数的类型是const T&，可以传递给它任何类型的实参--一个对象（const或非const）、一个临时对象或是一个字面值常量值。

//1.
template <typename T>
void f1(T&);        //实参必须是一个左值

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

//2.
template <typename T>
void f2(const T&);      //可以接受一个右值

f2(i);                 //i是一个int;模板参数T是int
f2(ci);               //ci是一个const int,但模板参数T是int
f2(5);                //一个const & 参数可以绑定道一个右值；T是int

5.2 从右值引用函数参数推断类型

　　当一个函数参数是一个右值引用（T&&）时，可以传递给它一个右值。

template <typename T>
void f3(T&&);

f3(42);    //实参是一个int；模板参数T 是int

两条例外规则

　　C++在正常绑定规则之外定义了两个例外规则，允许一个右值引用绑定到一个左值上。这连个例外规则是move这种标准库设施正确工作的基础。

　　1. 第一个例外规则影响右值引用参数的推断如何进行。当我们将一个左值(如i )传递给函数的右值引用参数，且此右值引用指向模板类型参数（如T&&）时，编译器推断推断模板类型参数为实参的左值引用类型。因此，当我们调用f3(i)时，编译器推断T的类型为int&，而非int。

　　2. 第二个规则：如果我们间接创建一个引用的引用，则这些引用形成了“折叠”。在所有情况下（除第一个例外），引用会折叠成一个普通的左值引用类型。在新标准下，折叠规则扩展到右值引用。只在一种特殊情况下引用会折叠成右值引用：右值引用的右值引用。即对于一个给定类型X:

1) X& &、X& &&和X&& &都折叠成类型X&；

2) 类型X&& &&折叠成X&&。

　　这两个规则导致了两个重要结果：

　　1. 如果一个函数参数是 "T&&"，则它可以被绑定到一个左值；且

　　2. 如果实参是一个左值，则推断出的模板实参类型将是一个左值引用，且函数参数将被实例化为一个（普通）左值引用参数（T&）。

template <typename T>
void f3(T&& val)
{
    T t=val;   //拷贝还是绑定一个引用
    t=100;
    if(val==t)
        cout<<"绑定一个引用"<<endl;
    else
        cout<<"拷贝"<<endl;
}

int main()
{
    int i=10;
    f3(i);     //推断T为int&，因此T&&是int& &&，会折叠为int&
    f3(10);    //推断T为int
    return 0;
}

　　注意15行注释：推断T为int&，因此T&&是int& &&，会折叠为int&.

　　在实际中，右值引用通常用于两种情况：模板转发其实参或模板被重载。使用右值引用的函数模板通常使用(P481)中介绍的方式进行重载：

template <typename T> void f(T&&);        //绑定到非const右值
template <typename T> void f(const T&); //绑定到左值和const右值

　　略（c++ primer P608）

 六、重载与模板

　　函数模板可以被另一个模板或一个普通非模板函数重载。与往常一样，名字相同的函数必须具有不同数量或类型的参数。

　　函数匹配规则：《C++ primer》 P615，值得注意的是，如果有多个函数提供同样好的匹配，则：

　　--若同样好的函数中只有一个是非模板函数，则选择此函数；（同等条件下，优先选非模板函数）

　　--若同样好的函数中没有非模板函数，而有多个函数模板，且其中一个模板比其他模板更特例化，则选择此模板；（同等条件下，选择更特例化的函数模板）

　　--否则，此调用有歧义。

#include <iostream>
#include <sstream>
using namespace std;

template <typename T>
string debug_rep(const T &t)
{
    cout<<"debug_rep版本"<<endl;
    ostringstream ret;
    ret<<t;
    return ret.str();
}
template <typename T>
string debug_rep(T *p)
{
    cout<<"debug_rep1版本"<<endl;
    ostringstream ret;
    ret<<"pointer:"<<p; //打印指针本身的值
    if(p)
        ret<<" "<<debug_rep(*p);
    else
        ret<<"null pointer";
    return ret.str();
}
//非模板和模板重载
string debug_rep(const string &s)
{
    cout<<"非模板函数版本"<<endl;
    return '"'+s+'"';   //
}
int main()
{
    string s("hello");
    cout<<debug_rep(s)<<endl<<endl;
    cout<<debug_rep(&s)<<endl<<endl;

    const string *sp=&s;
    cout<<debug_rep(sp)<<endl<<endl;  //多个函数模板，优先匹配"更特例化的模板"

    string s1("hi");
    cout<<debug_rep(s1)<<endl<<endl;  //同等条件下，优先匹配"非模板函数"
    return 0;
}

---