模板

模板是一种参数化多态性工具

一.函数模板

template<class T1, class T2>
T1 max(T1 x, T2 y)
{
    return x > y ? x : (T1)y;
}

函数模板是对一组函数的描述，不是一个实实在在的函数，编译时不产生任何可执行代码。

当编译系统在程序中，发现有与函数模板中相匹配的函数调用时，便生成一个重载函数。

#include<iostream>
using namespace std;

template<class T>
T max(T x, T y)
{
    return x > y ? x : y;
}

int main()
{
    int a = 10; float b = 1.1;
    cout << max(a, b) << endl;// error，必须类型相同

    return 0;
}

T max(T1 a, T2 b);

Max(1.2, 3.4);//ok
Max(4, 5);//ok
Max(1.2, 3);//ok

二.重载

template<class T>
T max(T a, T b);

template<class T>
T max(T a, int n);

int max(int a, int b);

//先找参数完全匹配的普通函数
//再找完全匹配的模板
//经过动态类型转换的普通函数

T max(T a, T b) { cout << 1; }
T max(T1 a, T2 b) { cout << 2; }
double max(double a, double b) { cout << 3; }

Max(1.2, 3.4);//3
Max(4, 5);//1
Max(1.2, 3);//2

三.类模型

1.

template<class T>
class XX
{
    T x;
    T getX(){}
};
int main()
{
    XX<int> x;
}

void XX<T>::setX(T a)
{

}

模板可拥有多个类参数

template<class T1, class T2, class T3>
class S
{
public:
    T2 m(T3 p){}
private:
    T1 x;
};

2.实例化

类模板是调用函数时实参的类型来确定具体类型

Array<int> a(50); // ok

编译器先用int替代类模板定义中的类型参数T，生成一个类型确定的类，再利用这个类创建对象a。

类模板可作为一种数据类型出现在参数表中。

void xx(const Array<T> &a);

3.类模板可以有非类参数，函数型参数

template<class T, int X, int Y>
class C {};


template<class T, int a>
class C
{
    C()
    {
        x = a;
    }

private:
    T x;
};

C<double, 8> c;

template<class T, int SIZE>
class CArray
{
private:
    T array[SIZE];
public:
    void Print()
    {
        for (int i = 0; i < SIZE; i++)
        {
            cout << array[i] << endl;
        }
    }
};

CArray<double, 40> a1;
CArray<int, 50> a2;

4.模板类可以继承也可以派生

template<class T>
class A{};

A<int> aint;
A<double> adouble;
//不存在A这个基类，没有公共基类，无法多态

class Abase{};

template<T> class A: public Abase{};
A<int> aInt;
A<double> aDouble;
//可多态

template<T> class A{static char a};
A<int> aint1, aint2;
A<double> adouble1, adouble2;
//aint1与adouble1并没有一个共同静态成员
//aint1与aint2有共同静态成员

5.同一个类模板的2个模板类不兼容

Pair<int, double> *p;
Pair<int, string> a;
p = &a;//error

四.派生

1.类模板从类模板

template<class T1, class T2>
class A
{
public:
    T1 v1;
    T2 v2;
};

template<class T1, class T2>
class B : public A<T1, T2>
{
public:
    T1 v3;
    T2 v4;
};

int main()
{
    return 0;
}

2.类模板从模板类

template<class T1, class T2>
class A
{
public:
    T1 v1;
    T2 v2;
};

template<class T>
class B : public A<int, double>
{
public:
    T a;
};

int main()
{
    return 0;
}

3.类模板从普通类

class A
{
};

template<class T>
class B : public A
{
public:
    T a;
};

int main()
{
    return 0;
}

4.普通类从模板类

template<class T>
class A
{
public:
    T a;
};

class B : public A<int>
{
};

int main()
{
    return 0;
}