C++模板

C++模板#

C++是一个面向对象编程的语言，提供了类的继承和组合机制，虽然在层次结构上很简单，但使用起来非常糟糕。C++使用关键字template，告诉编译器声明的类或者对象是一个模板。模板不是像继承和组合那样重用目标代码，而是重用源代码。容器不再包含名为 Object 的泛型基类，而是包含未指定的参数。与C语言中的宏定义有点类似，编译器可以将参数替换所需要的类型，使用模板比使用宏更加清晰和简单。

参考：Thinking in C++, Chapter 16

函数模板#

函数模板，顾名思义就是一个模板，用于指定实现函数参数的不同类型的一种模板。语法：template <typename/class T> void func(T&)。

template <typename T>
void func(T&); //声明

template <typename T> //定义
void func(T& t)
{
	....
}

int main()
{
	...
	int a = 5;
	func(a);
	...
}

类模板#

类模板就是将模板用于类，举个Stack类的例子，首先在stack.h中声明一个类模板，注意由于模板不是函数，不能单独编译。模板必须与特定的模板实例化请求一起使用。因此，最简单的方式就是将所有模板信息放在一个头文件中，并在要使用该模板的文件中包含该头文件。在stack类这个例子中就只有stack.h，而没有stack.cpp文件
定义和使用类模板

template <typename T>	//声明
class Stack
{
private:
	T *base;
	...
public:
	Stack();
}

//定义类模板中的函数，Stack::Stack改为Stack<T>::Stack
template <typename T>
Stack<T>::Stack()
{
	...
}

//调用该模板
int main()
{
	...
	Stack<int> s;	//需要加<int>
	...
}

stack.h：

//stack.h
#ifndef _STACK_H
#define _STACK_H

const int size = 128;

//类模板
template <typename T>   //C++11，用typename T代替class T
class Stack
{
private:
    int top;
    T *base;  //栈底指针
    int size;   //栈中元素个数
public:
    Stack(int size);
    bool push(T e);
    bool pop(T& e);
    void peek();
    bool isEmpty();
    void show();    //展示栈中所有元素
};

template <typename T>
Stack<T>::Stack(int size)
{
    this->base = new T[size]; //dynamic memory allocation
    //new如果分配内存失败则会抛出异常
    this->top = 0;  //指向栈顶的元素的下一个位置
    this->size = size;
}

//栈满没有考虑扩容的问题
template <typename T>
bool Stack<T>::push(T e)
{
    if(this->top >= this->size)
        return false;   //栈满
    this->base[top++] = e;    //入栈，栈顶指针+1
    return true;
}

template <typename T>
bool Stack<T>::pop(T& e)
{
    if(this->top == 0)  //栈空
        return false;
    e = this->base[--top];    //通过e传递出去
    return true;
}

//0 1 2 3
template <typename T>
bool Stack<T>::isEmpty()
{
    return (this->top == 0);   
}
#endif

main.cpp：

#include <iostream>
#include "stack.h"

struct customer
{
    char fullname[35];
    double payment;
};

int main()
{
    using namespace std;
    Stack<customer> s(128); //栈大小：128个customer
    customer c1 = {"c1", 23.5};
    customer c2 = {"c2", 39.3};
    customer c3 = {"c3", 14.7};
    customer c4;    //接收出栈的元素

    //元素入栈
    if(s.push(c1)) cout << "c1入栈..\n";
    s.push(c2);
    s.push(c3);
    if(s.pop(c4)) cout << "c4出栈..\n";
    cout << "pop(c4): " << c4.fullname << ", " << c4.payment << endl;


    return 0;
}

参考资料：C++ Primer Plus(第六版) p569

模板重载#

模板语法：template <typename/class T> void func(T &, T &);

其中typename和class都可以表示类或者原始类型(int、double、char等)，后面是函数函数返回类型void，函数名func，参数类型为T&，编译器会将T&转为所需要的类型，如int&、double&。

#include <iostream>

using namespace std;

/****************************/
//template overloading

template <typename T>
void Swap(T &a, T &b);

template <typename T>
void Swap(T *a, T *b, int);

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

int main()
{
    int a = 5, b = 7;
    Swap(a, b);     
    cout << "a:" << a << ", b:" << b <<endl;

    double c = 5.6, d = 7.8;
    Swap(c, d);
    cout << "c:" << c << ", d:" << d <<endl;

    string s("abc");
    string t("def");
    Swap(s, t);
    cout << s << endl;
    cout << t << endl;

    const int n = 3;
    int e[n] = {1,2,3};
    int f[n] = {4,5,6};

    cout << "before swap:" << endl;
    for(int i = 0; i < n; i++)
        cout << e[i] << " ";
    cout << endl;
    for(int i = 0; i < n; i++)
        cout << f[i] << " ";
    Swap(e, f, n);
    cout << endl;
    
    cout << "after swap:" << endl;
    for(int i = 0; i < n; i++)
        cout << e[i] << " ";
    cout << endl;
    for(int i = 0; i < n; i++)
        cout << f[i] << " ";
    
    return 0;
}

//template overloading definition
template <class T>
void Swap(T &a, T &b){
    T temp;
    temp = a;
    a = b;
    b = temp;
}

//template overloading definition
template <class T>
void Swap(T *a, T *b, int n){
    for(int i = 0; i < n; i++){
        T temp;
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
}

输出如下：

显式实例化和显式具体化#

显式实例化(explicit instantiation)，显式具体化(explicit specialization)。

显式实例化对应的是隐式实例化，上面的列子Swap(a, b)就是利用Swap的模板生成一个int类型的实例，即隐式实例化。

显式实例化语法：template void Swap<double>(double &, double &);

显示具体化语法：

template <> void Swap(double &, double &); 或者template<> void Swap<double>(double &, double &);

并且声明了显式具体化还需要对其进行定义，有了显式具体化告诉编译器不要使用Swap的原始模板来生成一个参数类型为double型Swap实例。

C++ Primer Plus书中写到：

#include <iostream>
#include <string>

using namespace std;

template <typename T>
void Swap(T &a, T &b);

template <typename T>
void Swap(T *a, T *b, int);

template <> void Swap<int>(int &, int &);   //explicit specialization，必须定义
template void Swap<double>(double &, double &);  //explicit instantiation


int main()
{
    double a = 3.4, b = 5.6;
    Swap(a, b);
    return 0;
}

//orginal template
template <class T>
void Swap(T &a, T &b){
    T temp;
    temp = a;
    a = b;
    b = temp;
}


//显示具体化 (explicit specialization)
template <> void Swap<int>(int &a, int &b){
    int temp;
    temp = a;
    a = b;
    b = temp;
}