一、函数模板的核心概念与价值

函数模板是C++​泛型编程的基石，它允许我们编写与类型无关的通用代码。通过模板，我们可以创建一个函数家族而非单个函数，这些函数具有相同的逻辑但能操作不同的数据类型

1.1 模板的基本语法形式

函数模板的基本语法如下所示：

template <typename T>  // 或者 template <class T>
返回值类型 函数名(参数列表) {
    // 函数体
}

这里的 typename T（也可用 class T）定义了一个类型占位符，编译器会在编译时根据实际调用类型替换这个占位符。

.2 模板的实例化过程

当编译器遇到模板函数调用时，它会执行模板实例化过程

：

1. 分析函数模板的调用上下文
2. 根据实参类型推导模板参数的具体类型
3. 生成对应类型的具体函数代码

二、类型推导的详细规则

C++编译器的模板类型推导有一套复杂但明确的规则，理解这些规则对正确使用模板至关重要。

2.1 按值传递参数的类型推导

当模板参数按值传递时，编译器会去除实参的引用和const/volatile限定符​

：

template<typename T>
void func(T param);

int x = 10;
const int cx = x;
const int& rx = x;

func(x);   // T 被推导为 int
func(cx);  // T 被推导为 int（去除了const）
func(rx);  // T 被推导为 int（去除了引用和const）

这种推导方式称为普通类型推导，会丢失类型的一些修饰属性。

2.2 按引用传递参数的类型推导

当模板参数按引用传递时，编译器会保留实参的const/volatile属性​

：

template<typename T>
void func(T& param);

int x = 10;
const int cx = x;
const int& rx = x;

func(x);   // T 被推导为 int, param类型为int&
func(cx);  // T 被推导为 const int, param类型为const int&
func(rx);  // T 被推导为 const int, param类型为const int&

2.3 万能引用与引用折叠

C++11引入了万能引用的概念，使用T&&语法，它可以接受左值和右值

：

template<typename T>
void func(T&& param);  // 万能引用

int x = 10;
const int cx = x;

func(x);   // T 被推导为 int&, param类型为int&
func(cx);  // T 被推导为 const int&, param类型为const int&
func(10);  // T 被推导为 int, param类型为int&&

万能引用的推导遵循引用折叠规则​：

• T& && 折叠为 T&
• T&& && 折叠为 T&&

2.4 数组和函数指针的特殊处理

当数组或函数作为模板参数时，类型推导有特殊行为

：

template<typename T>
void arrayFunc(T param);  // 按值传递

template<typename T>
void arrayRefFunc(T& param);  // 按引用传递

const char name[] = "example";  // 类型为const char[8]

arrayFunc(name);     // T 被推导为 const char*（数组退化为指针）
arrayRefFunc(name);  // T 被推导为 const char[8]（保留数组类型）

void someFunc(int, double);
arrayFunc(someFunc);     // T 被推导为 void(*)(int, double)
arrayRefFunc(someFunc);  // T 被推导为 void(&)(int, double)

三、函数模板的高级特性

3.1 显式指定模板参数

除了依赖自动类型推导，我们可以显式指定模板参数​

template<typename T>
T processValue(T value) {
    return value * 2;
}

// 显式指定模板参数
double result = processValue<double>(5);  // 返回10.0而不是10

显式指定在以下场景特别有用：

• 避免类型推导不符合预期
• 函数返回值类型与参数类型不同
• 模板参数无法通过函数参数推导

• 3.2 多模板参数

  函数模板可以包含多个类型参数

  ：

  template<typename T1, typename T2>
  auto multiply(T1 a, T2 b) -> decltype(a * b) {
      return a * b;
  }
  
  // 使用示例
  auto result1 = multiply(3, 4.5);      // 返回double类型13.5
  auto result2 = multiply(2.5f, 3);    // 返回float类型7.5

3.3 C++14的自动返回类型推导

C++14引入了自动返回类型推导，使模板函数编写更简洁：

template<typename T1, typename T2>
auto multiply(T1 a, T2 b) {
    return a * b;  // 返回类型由表达式a*b的类型决定
}

与普通函数的区别：

#include<iostream>
using namespace std;
/*
函数模板
建立一个通用的函数
函数类型在调用前可以不指定
在调用时指定
定义：
template<typename T>//T 可以自由命名

*/
int addint(int a, int b)//实现int 类型函数加法
{
	int c = a + b;
	return c;
}

double adddoubled(double a, double b)//实现double 类型函数加法
{
	double c = a + b;
	return c;
}
template<typename T>//用模板实现加法可以自由的变化类型
T add(T a,T b)
{
	T c = a + b;
	return c;

}



int main()
{
	int a = 1;
	int b = 2;
	int c = addint(a, b);
cout << c << endl;
double aa = 1.2;
double bb = 1.9;
double cc = adddoubled(a, b);
cout << cc << endl;

c = add(a, b);//会自动推导到类型int.
cout << c << endl;
cc = add(aa, bb);//推导为double
cout << cc << endl;

//显示指定类型
double d=add<double>(5.9, 4);//自己定义类型 double
cout << d << endl;

return 0;
}

用模板函数可以显著的减少代码重复，看起来更简洁，用起来更方便

总结

函数模板是C++泛型编程的核心机制，通过自动类型推导和编译期实例化实现了代码的通用性和复用性。掌握类型推导规则、理解各种参数传递方式的差异、熟悉模板特化和重载决议规则，是高效使用函数模板的关键。

模板编程虽然有一定复杂性，但它能显著减少代码重复、提高类型安全性和运行时效率。随着C++标准的发展（C++17、C++20、C++23），模板编程的能力不断增强，同时使用也变得越发简便。

建议读者从简单模板开始实践，逐步探索更复杂的应用场景，最终熟练掌握这一强大的编程技术。