第十天2017/04/21（2、泛型编程：模板 / 全特化、偏特化）

1、什么是模板？  template<class T1,class T2,.....>
类属————类型参数化，又称参数模板
    使得程序可以从逻辑功能上抽象，把被处理的对象（数据）的类型作为参数传递。

【1】函数模板
#include <iostream>
using namespace std;
//函数模板
template <class T1,class T2>
void show(T1 a,T2 b)
{
    cout<<a<<"+"<<b<<endl;
}

int main()
{
//自动类型推导
    show(111,2.222);
//具体类型调用
    show<int,float>(111,2.222); //类型参数化
}
【注意】
    函数模板可以像普通函数一样被重载
    函数模板不允许自动类型的转换，普通函数可以进行自动类型转换
【C++编译器怎么实现函数模板的？】函数模板实现本质探究！
    ——编译器并不是把函数模板处理成能够处理任意类型的函数
    --编译器从函数模板通过具体类型产生不同的函数
    --编译器会对函数模板进行两次编译
    --在调用的地方对参数替换后的代码进行编译
换句话说：只不过是C++编译器帮我们写出了自己想要的函数而已！


【2】类模板
知识1.类模板遇上继承
#include <iostream>
using namespace std;
//类模板
template <class T1,class T2>
class A
{
public:
    void show(T1 a,T2 b);
};
template <class T1,class T2>
void A<T1,T2>::show(T1 a,T2 b)
{
    cout<<a<<"+"<<b<<endl;
}
//继承类模板的语法：类A必须类型具体化为A<int,int>
class B:public A<int,int> 
{
public:
    void show_B(int a,int b);
};
template <class T1,class T2>
void B::show_B(int a,int b)
{
    cout<<a<<"+"<<b<<endl;
}
int main()
{
    A<int,char> a; //必须把类模板具体化类型后，才能实例化
    a.show(1,'A');
    //继承类模板
    B b;
    b.show_B(100,200);
}

知识2：类模板遇上友元函数
    在类模板中，如果有友元函数，那么该友元函数的实现必须在类中进行（如果在类外实现不管用何种方式，都会编译错误）。
#include <iostream>
using namespace std;

template <class T>
class Complex
{
public:
//类的成员函数
    Complex(T r=0, T i=0);
    void print();
//类的友元函数
    friend Complex operator+(const Complex<T> &c1,const Complex<T> &c2)
    {
        return Complex<T>(c1.real+c2.real,c1.imag+c2.imag);
    }
    friend ostream& operator<<(ostream& out,const Complex& c)
    {
        out<<c.real<<"+"<<c.imag;
        return out;
    }
private:
    T real;
    T imag;
};
//成员函数
template<class T> 
Complex<T>::Complex(T r=0,T i=0)  
{
    real = r;
    imag =i;
}
//成员函数
template<class T>
void Complex<T>::print()
{
    cout<<real<<"+"<<imag<<endl;
}
int  main()
{
    Complex<int> c1(1,1);
    Complex<int> c2(2,2);
    Complex<int> c3;
    c3 = c1+c2;
    c3.print();
    cout<<c3<<endl;
    return 0;
}

知识3：类模板遇上static静态成员
//每一种类型A<int>、A<char>、A<float>对应自己各自的静态成员
#include <iostream>
using namespace std;

template<class T>
class A
{
public:
    A();
    static int get_count();
    ~A();
private:
    static int count;
};
//下面是成员属性的初始化、成员函数的实现
template<class T>
int A<T>::count = 0;

template<class T>
A<T>::A()
{
    count++;
}

template<class T>
int A<T>::get_count()
{
    return count;
}

template<class T>
A<T>::~A()
{
    count--;
}

int main()
{
    A<int> a1;
    A<int> a2;
    A<int> a3;
    cout<<A<int>::get_count()<<endl;  //3个A<int>类型的对象
---------------------------------------------------------------
    A<char> aa1;
    A<char> aa2;
    cout<<A<char>::get_count()<<endl; //2个A<char>类型的对象
}

（函数/类模板）的（偏特化/全特化）
详解见C++中的博客