一文说清楚c++模板Template的用法

一、引言

模板（Template）指c++程序设计语言中采用类型作为参数的程序设计。

二、函数模板

1.通用格式

函数模板定义格式

template <class identifier> 返回类型 函数名(参数列表)
{
    函数体
}

其中，template和class是关键字，class可以用template替换；<>括号中的参数叫做模板形参，模板形参需要调用该模板函数时提供的模板实参来初始化模板形参，一旦编译确定了实参类型就称实例化了函数模板的一个实例。以函数swap为例：

template<class T>void swap(T & a, T&b)

当调用这样的模板函数时，类型T就会被调用时的类型代替，比如swap(a, b)，其中a,b为int类型，这时模板函数swap中的形参T就会被int所代替，即swap(int &a, int &b); 而当调用，swap(c, d)其中c,d为float类型，这时模板函数swap中的形参T就会被float所代替，即swap(float &a, float &b)。如此就实现了类型通用函数，即和函数形参类型无关。

2.举例

以函数swap举例

void swap(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

从上述函数看出，函数形参类型为int类型。若需支持float、string等其它类型，就需要定义几乎相同的函数只是形参类型不一致而已。如果有一种机制可以复用函数，则可很方便解决此类问题，于是函数模板就出现了。

三、类模板

1.通用格式

类模板定义格式

template <class identifier> class 类名
{
    ...
}
template <class identifier, identifier def_val> class 类名
{
    ...
}

和函数模板一样，内模板也是以template开始后接模板形参。

2.举例

以一个simple的stack 类为例，要求stack可以支持int类型，float类型，string类型等等。若不使用类模板则需要根据不同类型定义不同的类。于是类模板就出现了。

//statck.h
template <class T> class Stack {
    public:
        Stack();
        ~Stack();
        void push(T t);
        T pop();
        bool isEmpty();
    private:
        T *m_pT;        
        int m_maxSize;
        int m_size;
};

//stack.cpp
#include "stack.h"
template <class  T>  Stack<T>::Stack(){
   m_maxSize = 100;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T>  Stack<T>::~Stack() {
   delete [] m_pT ;
}
        
template <class T> void Stack<T>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T> T Stack<T>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T> bool Stack<T>::isEmpty() {
    return m_size == 0;
}

上述定义了一个simple的stack 类模板，接下来看如何使用。

include "stdio.h"
include "stack.h"

int main()
{
	Stack<int> intStack;
	intStack.push(1);
	intStack.push(2);
	intStack.push(3);

	while(!intStack.isEmpty()) {
		printf("num:%d\n", intStack.pop());
	}

	return 0;
}

上述定义的内模板最多只支持m_maxSize = 100个元数，于是我们可以通过内模板参数配置，实现最大支持元素可配置。

//statck.h
template <class T, int maxsize = 100> class Stack {
    public:
        Stack();
        ~Stack();
        void push(T t);
        T pop();
        bool isEmpty();
    private:
        T *m_pT;        
        int m_maxSize;
        int m_size;
};

//stack.cpp
#include "stack.h"
template <class T, int maxsize>  Stack<T>::Stack(){
   m_maxSize = 100;      
   m_size = 0;
   m_pT = new T[m_maxSize];
}
template <class T, int maxsize>  Stack<T>::~Stack() {
   delete [] m_pT ;
}
        
template <class T, int maxsize> void Stack<T>::push(T t) {
    m_size++;
    m_pT[m_size - 1] = t;
    
}
template <class T, int maxsize> T Stack<T>::pop() {
    T t = m_pT[m_size - 1];
    m_size--;
    return t;
}
template <class T, int maxsize> bool Stack<T>::isEmpty() {
    return m_size == 0;
}

使用如下：

#include "stdio.h"
#include "stack.h"
int main() 
{
	int maxsize = 1024;
	Stack<int, 1024>intStack;
	for(i = 0; i<maxsize; i++) {
		intStack.push(i);
	}
	while(!intStack.isEmpty()) {
		printf("num:%d\n", intStack.pop());
	}
	return 0;
}

四、参考

1.https://blog.csdn.net/fuhanghang/article/details/112563711
2.https://www.cnblogs.com/yangxiaoping/p/8268209.html