C++模板(函数模板 & 类模板)

模板编程可称范型编程，是一种忽视数据类型的编程方式，这样的好处是什么？且看下面一个例子:

简单使用

求解最值问题，返回两个值中的较大值:

int Max(int a, int b)
{
	return a>b?a:b;
}
double Max(int a, int b)
{
	return a>b?a:b;
}
string Max(string a,string b)
{
	return a>b?a:b;
}

使用Max函数处理数据类型不同的变量时，不得不重复写相同函数体的函数，于是引入了模板编程，可将类型当作未知量，使用template <typename type>来修饰函数:

template <typename type>
type Max(type a, type b)
{
    return a>b?a:b;
}

或者

template <class T>
void print(T data)
{
	cout << data << endl;
}

这两种声明方法是等价的

调用方法分为隐式调用和显式调用

在main函数中隐式调用:

int main(void)
{
    cout << Max(1, 2) << endl;
    cout << Max(1.1,2.2) << endl;
    cout << Max(string("ILoveYou"),string("IMissYou")) << endl;
    return 0;
}

输出:

2
2.2
IMissYou

显式调用，使用<>传类型的参数，也就是在<>填写上数据类型，放到参数和函数名之间

int main(void)
{
    cout << Max<int>(1, 2) << endl;
    cout << Max<float>(1.1, 2.2) << endl;
    cout << Max<string>("ILoveYou","IMissYou") << endl;
    return 0;
}

输出:

2
2.2
IMissYou

函数模板

此处着重讨论函数模板和普通函数的使用注意点

如果在代码中存在同名的普通函数和模板函数:

int Max(int a, int b)
{
    cout << "comman function..." << endl;
    return a > b? a:b;
}

template <class T>
T Max(T a, T b)
{
    cout << "function template..." << endl;
    return a > b? a:b;
}

那么使用模板的显式调用时，调用的一定是模板函数，隐式调用时，优先调用类型确定的函数

int main(void)
{
    cout << Max<int>(1, 2) << endl;
    cout << Max(1, 2) << endl;
    return 0;
}

如上所示，第一个Max调用模板函数，第二个Max调用普通函数

如果代码中存在同名的模板函数，但参数个数不同:

template <class T1, class T2, class T3>
void print(T1 one, T2 two, T3 three)
{
    cout << "three types" << endl;
}

template <class T1, class T2>
void print(T1 one, T2 two, T2 three)
{
    cout << "two types" << endl;
}

template <class T>
void print(T one, T two, T three)
{
    cout << "one type" << endl;
}

这可以理解为函数模板的重载(类型个数的不同也可以认为是重载)，在显式调用情况下:

int main(void)
{
    print<int, double, string>(1, 1.1, string("AAA"));
    print<int, double>(1, 1.22, 1.1);
    print<int>(1, 2, 3);
    return 0;
}

输出:

three types
two types
one type

这里要注意的是，数据类型要和参数匹配

隐式调用略显麻烦，有时发现多个模板都能使用，常常优先调用需要传参较少的函数模板，如下所示:

int main(void)
{
    print(1, 1, 1);
    return 0;
}

输出 one type

可见类型参数最少的模板(只要传入一个类型)被调用了，但如果参数的类型各不相同，那也只能调用3个类型参数的函数模板了:

int main(void)
{
    print(1, 1.1, string("AAA"));
    return 0;
}

输出: three types

类中的方法也可以应用函数模板:

class Test
{
public:
    template <class T>
    void print(T data) {
        cout << data << endl;
    }
};

同样可以忽视数据类型，调用时通过对象调用即可

函数模板的类型参数可以缺省，这和普通函数参数的缺省是一样的规则，只能从右往左缺省

int main(void)
{
    printData<int>(1, string("Hello"));
    return 0;
}

这里类型参数就有缺省，但是因为声明了默认参数，所以就将第二个类型认为是string

函数模板还可以向类型参数中传常量:

template <class T,size_t size>
void printArray(T* array)
{
    for (int i=0;i<size;i++) {
        cout << array[i] << " ";
    }
    cout << endl;
}

int main(void)
{
    int num[3] = {1, 2, 3};
    printArray<int, 3>(num);
    return 0;
}

输出: 1 2 3

类模板

类也可以应用模板，类模板不是一个完整的类型，所以任何用到类名的地方都要用类名<未知类型>的方式使用，同时在多文件中不能分开写，定义和声明位于同一文件，可以写在.hpp文件中(声明和实现放在一起)，并且类模板只支持显示调用方式

如下案例，对C++结构体使用模板:

template <class T1, class T2>
struct my_pair
{
    T1 first;
    T2 second;
};
int main(void)
{
    my_pair<int,int> pairData = {1, 2};
    cout << pairData.first << " " << pairData.second << endl;
    my_pair<int, string>* p = new my_pair<int, string>;
    p->first = 1;
    p->second = "2";
    cout << p->first << " " << p->second << endl;
    return 0;
}

输出:

1 2
1 2

如下使用类模板:

template <class type1,class type2>
class Test
{
public:
    // constructor
    Test(type1 one,type2 two):one(one),two(two) {

    }
    void printTest();
protected:
    type1 one;
    type2 two;
};

template <class type1,class type2>
void Test<type1,type2>::printTest()
{
    cout << one << " " << two << endl;
}

template <class type1, class type2>
class Data :public Test<type1,type2>
{
public:
    Data(type1 one, type2 two) :Test<type1,type2>(one,two) {

    }
protected:
};

int main(void)
{
    Data<int,int> data(1,2);
    data.printTest();

    return 0;
}

上述代码中首先定义了一个使用template修饰的类模板，声明了变量、构造函数和方法，在实现类模板的方法时也必须加上template进行修饰，在声明Data类继承Test时，也必须加上template修饰，在实例化时，使用<>显式的指定出数据类型