C++课程学习笔记第七周（下）：模板

前言：本文主要是根据MOOC网北大课程——《程序设计与算法（三）：C++面向对象程序设计》内容整理归纳而来，整理的课程大纲详见 https://www.cnblogs.com/inchbyinch/p/12398921.html

本文介绍了函数模板和类模板。

1 函数模板

1.1 函数模板的形式

//函数模板的标准形式
template <class 类型参数1，class 类型参数2,……>
返回值类型 模板名 (形参表)
{
    函数体
};


//示例1：交换两个变量的函数模板
template <class T>
void Swap(T & x,T & y){
    T tmp = x;
    x = y;
    y = tmp;
}
int main(){
    int n = 1, m = 2;
    Swap(n, m);   //编译器自动生成 void Swap(int &, int &)函数
    double f = 1.2, g = 2.3;
    Swap(f, g);   //编译器自动生成 void Swap(double &, double &)函数
    return 0;
}


//示例2：求数组最大元素的MaxElement函数模板
//类型参数表和形参表中可以有固定类型
template <class T>
T MaxElement(T a[], int size){   //size是数组元素个数
    T tmpMax = a[0];
    for( int i = 1;i < size;++i)
        if( tmpMax < a[i])
        tmpMax = a[i];
    return tmpMax;
}


//示例3：可以不通过参数实例化函数模板
template <class T>
T Inc(T n){
    return 1 + n;
}
int main(){
    cout << Inc<double>(4) / 2; //输出 2.5
    return 0;
}


//示例4：函数模板可以重载，只要它们的形参表或类型参数表不同即可
template<class T1, class T2>
void print(T1 arg1, T2 arg2) {
    cout << arg1 << " " << arg2 << endl;
}
template<class T>
void print(T arg1, T arg2) {
    cout << arg1 << " " << arg2 << endl;
}
template<class T, class T2>
void print(T arg1, T arg2){
    cout << arg1 << " " << arg2 << endl;
}

1.2 函数模板和函数的调用顺序

在有多个函数和函数模板名字相同的情况下，编译器处理函数调用语句原则：

• 先找参数完全匹配的普通函数(非由模板实例化而得的函数)。
• 再找参数完全匹配的模板函数。
• 再找实参数经过自动类型转换后能够匹配的普通函数。
• 上面的都找不到，则报错（匹配模板函数时，不进行类型自动转换）

//示例1：同名函数调用原则
template <class T>
T Max( T a, T b) {
    cout << "TemplateMax" << endl; 
    return 0;
}
template <class T,class T2>
T Max( T a, T2 b) {
    cout << "TemplateMax2" << endl; 
    return 0;
}
double Max(double a, double b){
    cout << "MyMax" << endl;
    return 0;
}
int main() {
    int i=4, j=5;
    Max(1.2, 3.4); // 输出MyMax
    Max(i, j);  //输出TemplateMax
    Max(1.2, 3); //输出TemplateMax2
    return 0;
}


//示例2：Map函数
template<class T,class Pred>
void Map(T s, T e, T x, Pred op){
    for(; s != e; ++s,++x) 
        *x = op(*s);
}
int Cube(int x) { return x * x * x; }
double Square(double x) { return x * x; }
int a[5] = {1,2,3,4,5}, b[5];
double d[5] = { 1.1,2.1,3.1,4.1,5.1}, c[5];

int main() {
    Map(a, a+5, b, Square);
    for(int i = 0; i < 5; ++i) 
        cout << b[i] << ",";  //1,4,9,16,25,
    cout << endl;
    Map(a, a+5, b, Cube);
    for(int i = 0;i < 5; ++i) 
        cout << b[i] << ",";  //1,8,27,64,125,
    cout << endl;
    Map(d, d+5, c, Square);
    for(int i = 0;i < 5; ++i) 
        cout << c[i] << ",";  //1.21,4.41,9.61,16.81,26.01,
    cout << endl;
    return 0; 
}

//注：当调用Map(a, a+5, b, Square)时，实例化出以下函数:
void Map(int * s, int * e, int * x, double(*op)(double)) {
    for(; s != e; ++s,++x) 
    *x = op(*s);
}

2 类模板

2.1 类模板的定义与使用

• 为了多快好省地定义出一批相似的类，可以定义类模板，然后由类模板生成不同的类。比如对于一个可变长数组，除了元素的类型不同之外，其他的操作完全相同，因此就可以考虑使用类模板。
• 编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类，叫模板类。
• 同一个类模板的两个模板类是不同的类型，故不兼容。

//类模板的标准形式
template <class 类型参数1，class 类型参数2，……> //类型参数表
class 类模板名{
    成员函数和成员变量
};

//类模板里成员函数的写法：
template <class 类型参数1，class 类型参数2，……> //类型参数表
返回值类型 类模板名<类型参数名列表>::成员函数名（参数表）{
    ……
}

//用类模板定义对象的写法：
类模板名<真实类型参数表> 对象名(构造函数实参表);


//示例1：Pair类模板
template <class T1,class T2>
class Pair{
public:
    T1 key; //关键字
    T2 value; //值
    Pair(T1 k,T2 v):key(k),value(v) { };
    bool operator < ( const Pair<T1,T2> & p) const;
};
template<class T1,class T2>  //Pair的成员函数 operator <
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const {
    return key < p.key;
}
int main(){
    Pair<string,int> student("Tom",19);
    //实例化出一个类 Pair<string,int>
    cout << student.key << " " << student.value; //输出：Tom 19
    return 0; 
}


//示例2：函数模版作为类模板成员
template <class T>
class A{
public:
    template<class T2>
    void Func(T2 t) { cout << t; } //成员函数模板
};
int main(){
    A<int> a;
    a.Func('K'); //成员函数模板 Func被实例化
    a.Func("hello"); //成员函数模板 Func再次被实例化
    return 0;  
} //输出：KHello

2.2 类模板与派生

• 类模板从类模板派生
• 类模板从模板类派生
• 类模板从普通类派生
• 普通类从模板类派生

//示例1：类模板从类模板派生
template <class T1, class T2>
class A {
    T1 v1; T2 v2;
};
template <class T1, class T2>
class B : public A<T2, T1> {
    T1 v3; T2 v4;
};
template <class T>
class C : public B<T, T> {
    T v5;
};
int main() {
    B<int, double> obj1; //自动生成两个模板类：B<int,double>和A<double,int>
    C<int> obj2;
    return 0;
}
    
    
//示例2：类模板从模板类派生
template <class T1,class T2>
class A {
    T1 v1; T2 v2;
};
template <class T>
class B : public A<int,double> {
    T v;
};
int main() {
    B<char> obj1; //自动生成两个模板类：A<int,double>和B<char>
    return 0;
}
    
    
//示例3：类模板从普通类派生
class A {
    int v1;
};
template <class T>
class B : public A {  //所有从B实例化得到的类，都以A为基类
    T v;
};
int main() {
    B<char> obj1;
    return 0;
}
    
    
//示例4：普通类从模板类派生
template <class T>
class A{
    T v1;
    int n;
};
class B : public A<int> {
    double v;
};
int main() {
    B obj1;
    return 0;
}

2.3 类模板与友元

• 函数、类、类的成员函数作为类模板的友元
• 函数模板作为类模板的友元
• 函数模板作为类的友元
• 类模板作为类模板的友元

//示例1：函数、类、类的成员函数作为类模板的友元
void Func1() { }
class A { };
class B{
public:
    void Func() { }
};
template <class T>
class Tmpl{
    friend void Func1();
    friend class A;
    friend void B::Func();
}; //任何从Tmp1实例化来的类，都有以上三个友元


//示例2：函数模板作为类模板的友元
template <class T1,class T2>
class Pair{
    T1 key; //关键字
    T2 value; //值
public:
    Pair(T1 k, T2 v):key(k),value(v) { };
    bool operator < ( const Pair<T1,T2> & p) const;
    template <class T3,class T4>
    friend ostream & operator<< (ostream & o, const Pair<T3,T4> & p);
};
template<class T1,class T2>
bool Pair<T1,T2>::operator < ( const Pair<T1,T2> & p) const { //"小"的意思就是关键字小
    return key < p.key;
}
template <class T1,class T2>
ostream & operator<< (ostream & o,const Pair<T1,T2> & p){
    o << "(" << p.key << "," << p.value << ")" ;
    return o;
}
//注：任意从template <class T1,class T2>
//ostream & operator<< (ostream & o,const Pair<T1,T2> & p)
//生成的函数，都是任意Pair模板类的友元

int main(){
    Pair<string,int> student("Tom", 29);
    Pair<int,double> obj(12, 3.14);
    cout << student << " " << obj;  //输出：(Tom,29) (12,3.14)
    return 0;
}


//示例3：函数模板作为类的友元
class A{
    int v;
public:
    A(int n):v(n) { }
    template <class T>
    friend void Print(const T & p);
};
template <class T>
void Print(const T & p){
    cout << p.v;
}
//注：所有从 template <class T> void Print(const T & p)生成的函数，都成为 A 的友元
//但是自己写的函数void Print(int a) { } 不会成为A的友元

int main() {
    A a(4);
    Print(a);  //输出：4
    return 0;
}


//示例4：类模板作为类模板的友元
template <class T>
class B {
    T v;
public:
    B(T n):v(n) { }
    template <class T2>
    friend class A;
};
template <class T>
class A {
public:
    void Func( ){
        B<int> o(10);
        cout << o.v << endl;
     }
};
//注：任何从A模版实例化出来的类，都是任何B实例化出来的类的友元

2.4 类模板与静态成员变量

类模板中可以定义静态成员，那么从该类模板实例化得到的所有类，都包含同样的静态成员。

template <class T>
class A{
    static int count;
public:
    A() { count ++; }
    ~A() { count -- ; }
    A(A &) { count ++ ; }
    static void PrintCount() { cout << count << endl; }
};
    
template<> int A<int>::count = 0;
template<> int A<double>::count = 0;
int main(){
    A<int> ia;
    A<double> da;
    ia.PrintCount(); //输出：1
    da.PrintCount(); //输出：1
    return 0;
}

3 小结

• 函数模板的定义与使用；
• 类模板用法与普通类基本相同，仅需注意定义和使用方式。

4 练习

//003:简单的Filter http://cxsjsxmooc.openjudge.cn/2019t3fall7/003/
//补充程序，使得输出为：
//Mike Jack Lucy
//3,4,5,
#include <iostream>
#include <string>
using namespace std;

/*************Your code start here*************/
template<class T, class T1>
T Filter(T p1, T p2, T p, T1 op){
    while(p1 != p2){
        if(op(*p1)){
            *p = *p1;
            p++;
         }
        p1++;
     }
    return p;
}
/*************Your code end here*************/
bool LargerThan2(int n){ return n > 2; }
bool LongerThan3(string s){ return s.length() > 3; }

string as1[5] = {"Tom", "Mike", "Jack", "Ted", "Lucy"};
string as2[5];
int a1[5] = { 1,2,3,4,5};
int a2[5];
int main() {
    string * p = Filter(as1, as1+5, as2, LongerThan3);
    for(int i = 0;i < p - as2; ++i)
        cout << as2[i] << " ";
    cout << endl;
    int * p2 = Filter(a1, a1+5, a2, LargerThan2);
    for(int i = 0;i < p2-a2; ++i)
        cout << a2[i] << ",";
    return 0;
}


//004:你真的搞清楚为啥while(cin >> n)能成立了吗？
//读入两个整数，输出相同的两个整数，若整数中含有-1则退出
//比如输入为：45 68[回车] 2 -1[回车] 则输出为：45 68
#include <iostream>
using namespace std;
/*************Your code start here*************/
class MyCin{
    bool valid;
public:
    MyCin():valid(true){}
    operator bool(){ return valid; } //类型强制转换符
    MyCin& operator>>(int& k){
        cin >> k;
        if(k == -1) valid = false;
        return *this;
    }
};
/*************Your code end here*************/
int main(){
    MyCin m;
    int n1,n2;
    while(m >> n1 >> n2) //此处将函数返回值强制转为bool
        cout << n1 << " " << n2 << endl;
    return 0;
}


//005:山寨版istream_iterator http://cxsjsxmooc.openjudge.cn/2019t3fall7/005/
//模仿STL中istream_iterator用法，实现CMyistream_iterator使得程序按要求输出
//例如输入：2[回车]79 90 20 hello me[回车]12 34 19 take up
//输出：79[换行]79 90 20 hello me[换行]12[换行]12 34 19 take up
#include <iostream>
#include <string>
using namespace std;
/*******************code start here*******************/
template <class T>
class CMyistream_iterator{
    istream& in;
    T val;
public:
    CMyistream_iterator(istream& i):in(i){ in >> val; }
    T operator*(){ return val; }
    void operator++(int){ in >> val; }
};
/*******************code end here*******************/

int main()  {
    int t;
    cin >> t;
    while( t -- ) {
         CMyistream_iterator<int> inputInt(cin);
         int n1,n2,n3;
         n1 = * inputInt; //读入 n1
         int tmp = * inputInt;
         cout << tmp << endl;
         inputInt ++;
         n2 = * inputInt; //读入 n2
         inputInt ++;
         n3 = * inputInt; //读入 n3
         cout << n1 << " " << n2<< " " << n3 << " ";
         CMyistream_iterator<string> inputStr(cin);
         string s1,s2;
         s1 = * inputStr;
         inputStr ++;
         s2 = * inputStr;
         cout << s1 << " " << s2 << endl;
    }
    return 0;
}