1.函数模板初级，如果想使用模板，需要实例化，实例化的方式是加上<数据类型>
#include <iostream>
//函数模板可以对类型进行优化重载，根据类型会覆盖
//如果仍然要使用模板函数，需要实例化
template<class T>
T add(T a, T b)
{
std::cout << "T add " << std::endl;
return a + b;
}
int add(int a, int b)
{
std::cout << "int add " << std::endl;
return a + b;
}
void main()
{
int a = 10, b = 20;
double db1 = 10.9, db2 = 10.8;
add(db1, db2);
add(a, b);
//这里加上了<int>相当于实例化，调用了模板
add<int>(a, b);
std::cin.get();
}
运行结果如下：
2.模板的重载，模板的重载会根据数据类型自动匹配
#include <iostream>
#include <array>
using std::array;
template<typename T>
void showarray(array<T, 10> myarray, int n)
{
using namespace std;
cout << "TTTTT" << endl;
for (int i = 0; i < n; i++)
{
cout << myarray[i] << " ";
}
cout << endl;
}
template<typename T>
void showarray(array<T*, 10> myarray, int n)
{
using namespace std;
cout << "T*T*T*T*T*" << endl;
for (int i = 0; i < n; i++)
{
cout << *myarray[i] << " ";
}
cout << endl;
}
void main()
{
array<int, 10> intarray = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
array<int*, 10> pintarray;
for (int i = 0; i < 10; i++)
{
pintarray[i] = &intarray[i];
}
array<int**, 10> ppintarray;
for (int i = 0; i < 10; i++)
{
ppintarray[i] = &pintarray[i];
}
showarray(intarray, 10);
showarray(pintarray, 10);
showarray(ppintarray, 10);
std::cin.get();
}
运行结果如下：
3.通用函数可变参数模板
#include <iostream>
//通用可变参数模板 处理不限定个数的参数，处理不同类型
//空函数，接口，用于最后结束递归 适用于新版本的编译器
void showall(){}
template<typename T, typename...Args>
void showall(const T &value, const Args &...args)
{
std::cout << value << std::endl;
showall(args...); //继续传递
}
//设计可以修改原来的数据的T &value, Args&...args
//设计可以修改副本 T value, Args ...args
//设计不可以修改原来的数据，不可以修改副本const T value, const Args...args
//设计引用原来的数据不可以修改 const T &value, const Args &...args
void main()
{
int num1 = 10, num2 = 9, num3 = 11;
double db1 = 10.8, db2 = 10.9;
char str[40] = "yincheng";
char ch = 'A';
showall(num1);
std::cout << "\n";
showall(num1, num2, num3);
std::cout << "\n";
showall(db1, db2, num1, ch);
std::cout << "\n";
showall(db1, db2, num1, ch, str);
std::cin.get();
}
运行截图如下：
4.函数模板覆盖，并实现参数互换
#include <iostream>
//函数模板实现通用，可以根据自有数据类型，进行优化
//结构体和类没有私有变量时才可以直接赋值初始化
//所有成员都是公有的类型可以赋值初始化
struct info
{
char name[40];
double db;
int data;
};
template<typename T>
void swap(T &a, T &b)
{
std::cout << "通用函数模板" << std::endl;
T temp = a;
a = b;
b = temp;//交换变量
}
//模板为空，明确参数类型，覆盖函数模板的类型
//template<> //这里可有可无
void swap(info &info1, info &info2)
{
std::cout << "特有函数模板" << std::endl;
//通过模板可以实现通用，针对自己的数据类型做出优化
info temp = info1;
info1 = info2;
info2 = temp;
}
void main()
{
info info1 = {"tuzuoquan",20.9,10};
info info2 = { "quanzuotu",9.2,1 };
swap(info1, info2);
std::cout << info1.name << info1.db << info2.data << std::endl;
std::cout << info2.name << info2.db << info2.data << std::endl;
std::cin.get();
}
运行结果：
5.通过引用的方式实现参数互换
#include <iostream>
//函数模板实现通用，可以根据自有数据类型，进行优化
//结构体和类没有私有变量时才可以直接赋值初始化
//所有成员都是公有的类型可以赋值初始化
template<typename T>
void swap(T &a, T &b)
{
std::cout << "通用函数模板" << std::endl;
T temp = a;
a = b;
b = temp;//交换变量
}
void main()
{
int num1 = 100;
int num2 = 10;
swap(num1, num2);//实现交换
std::cout << num1 << " " << num2 << std::endl;
char ch1 = 'Z';
char ch2 = 'A';
//注意，要指定使用模板，这里要使用<类型名称>
swap<char>(ch1, ch2);
std::cout << ch1 << " " << ch2 << std::endl;
std::cin.get();
}
6.可变参数模板
#include <iostream>
#include <cstdarg>
void showall(){} //预留一个
template <typename T>
void show(T t, ...)
{
std::cout << t << std::endl;
}
template <typename T, typename...Args>
void showall(T t, Args...args)
{
std::cout << t << std::endl;
showall(args...);
}
void main()
{
int num1 = 10, num2 = 9, num3 = 11;
double db1 = 10.8, db2 = 10.9;
char str[40] = "yincheng";
char ch = 'A';
show(num1);
showall(num2, num3);
showall(num2, num3, num1, str, ch);
std::cin.get();
}
运行结果如下：
