C/C++模板

一.函数模板
在一个int 型数组中，查找最大的数…
在一个double 型数组中，查找最大的数…
在一个float 型数组中，查找最大的数…
在一个Objext[] 型数组中，查找最大的数…

算法都是一样的：遍历数组，找出最大的数，只是元素的类型不一样而已

如果每一种类型都重载一个函数，那么就太麻烦了。

模板：template 定义一个模子，自动适应各个类型。

语法：template
T findmax(T arr[],int len)
{
T val = arr[0];
…
}

算法相同，元素类型不同，用T替代

使用时，用<>来具体制指定typename的类型

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
template <typename T>
T findmax(T arr[],int len)
{
	T val = arr[0];
	for(int i = 0;i<len;i++)
	{
		if(arr[i] > val)
		{
			val = arr[i];
		}
	}
	return val;
}

int main()
{
	int arr[4] = {1,5,7,80};
	int result1 = findmax <int>(arr,4);
	//在使用函数名为findmax<int>时，表示把int类型带入模板
	printf("MAX = %d\n",result1);
	
	double abc[3] = {1.0,5.1,6.2};
	double result2 = findmax<double>(abc,3);
	printf("MAX = %.1f\n",result2);
	
	return 0;
} 

二.模板相关问题
1.区分模板参数和函数参数
模板参数：template<typename _T1,typename _T2>
通常是一个类型的名字：int ,double, float.

2.模板的语法检查
例如自己定义一个类别，可能无法直接用 < >等符号直接比较，需要重载操作符

3.模板通常定义在头文件里

4.模板参数可以是多个

三.类模板
背景：

需求：
写一个各边长度的数组类Array
用于存放各种元素，个数未知
设计：
内部动态申请一个buffer
capacity：表示buffer的大小
size：表示buffer已经存放元素的个数
接口：
Size():
Capacity():最大容量
Clear():清空，使size为0，capacity不变
PushBack():添加一个元素。

问题：这个类只适用于double类型，如果要存放int，char，以致任何类型呢？

函数原型：
 

#include <stdio.h>
#include <string.h>

 用于存放double类型的对象
class Array
{
public:
	Array(int capacity=4)
	{
		m_buffer = new double[capacity];
		m_capacity = capacity;
		m_size = 0;
	}

	void PushBack(double val)
	{
		if(m_size >= m_capacity)
		{
			Resize();
		}
		m_buffer[m_size] = val;
		m_size ++;
	}
	int Capacity()
	{
		return m_capacity;
	}
	int Size()
	{
		return m_size;
	}

private:
	void Resize()
	{
		 创建一个更大的缓冲区
		int n = m_capacity + 4;
		double* buf = new double[n];

		 拷贝原有的内容
		memcpy(buf, m_buffer, m_capacity * sizeof(double));

		 删除旧的内容,释放其内存
		delete [] m_buffer;

		 更新一下成员变量
		m_capacity = n;
		m_buffer = buf;
	}

private:
	double* m_buffer;
	int m_capacity; // 容量
	int m_size; // 已经存放的对象的个数
};

int main()
{
	Array a; // 长度可变的数组
	a.PushBack(1);
	a.PushBack(2);
	a.PushBack(3);
	a.PushBack(4);
	a.PushBack(5);

	int size = a.Size();

	return 0;
}

改变成类模板：

//Array.h
#ifndef _ARRAY_H
#define _ARRAY_H

// 用于存放double类型的对象
template <typename _TT>
class Array
{
public:
	Array(int capacity=4)
	{
		m_buffer = new _TT[capacity];
		m_capacity = capacity;
		m_size = 0;
	}

	void PushBack(_TT val)
	{
		if(m_size >= m_capacity)
		{
			Resize();
		}
		m_buffer[m_size] = val;
		m_size ++;
	}
	int Capacity()
	{
		return m_capacity;
	}
	int Size()
	{
		return m_size;
	}

private:
	void Resize()
	{
		// 创建一个更大的缓冲区
		int n = m_capacity + 4;
		_TT* buf = new _TT[n];

		// 拷贝原有的内容
		memcpy(buf, m_buffer, m_capacity * sizeof(_TT) );

		// 删除旧的内容,释放其内存
		delete [] m_buffer;

		// 更新一下成员变量
		m_capacity = n;
		m_buffer = buf;
	}

private:
	_TT* m_buffer;
	int m_capacity; // 容量
	int m_size; // 已经存放的对象的个数
};


#endif

//main.cpp
#include <stdio.h>
#include <string.h>

#include "Array.h"

int main()
{
	Array<int> a; // 长度可变的数组
	a.PushBack(1);
	a.PushBack(2);
	a.PushBack(3);
	a.PushBack(4);
	a.PushBack(5);

	int size = a.Size();

	Array<float> b;
	b.PushBack(2.3f);

	return 0;
}