目录

一、模板编程的核心概念

1.1 什么是模板编程？

二、函数模板详解

2.1 函数模板的定义与使用

2.1.1 基本语法

2.1.2 示例：通用交换函数

2.1.3 类型推导规则

2.2 函数模板的注意事项

2.2.1 普通函数与函数模板的调用规则

2.2.2 隐式类型转换问题

2.2.3 函数模板的重载

三、类模板详解

3.1 类模板的定义与使用

3.1.1 基本语法

3.1.2 示例：通用 Pair 类

3.1.3 显式指定类型

3.2 类模板的注意事项

3.2.1 成员函数的实例化

3.2.2 分文件编写问题

3.2.3 特化与部分特化

四、函数模板与类模板的对比

五、模板编程的常见错误与解决方案

5.1 错误：类型推导失败

5.2 错误：类模板未显式指定类型

5.3 错误：分文件编写时未包含实现

六、总结

6.1 核心要点

6.2 最佳实践

---

一、模板编程的核心概念

1.1 什么是模板编程？

• 定义：模板编程是 C++ 中实现泛型编程的核心机制，通过将类型参数化，编写与具体数据类型无关的通用代码。
• 核心思想：
  • 函数模板：通过类型参数化，定义可适用于多种数据类型的通用函数。
  • 类模板：通过类型参数化，定义可适用于多种数据类型的通用类。
• 优势：
  • 代码复用：避免为每种数据类型重复编写相同逻辑的代码。
  • 类型安全：在编译时检查类型兼容性，减少运行时错误。
  • 灵活性：支持对任意数据类型的通用操作（如排序、查找等）。

---

二、函数模板详解

2.1 函数模板的定义与使用

2.1.1 基本语法

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

2.1.2 示例：通用交换函数

// 函数模板定义
template <typename T>
void mySwap(T& a, T& b) {T temp = a;a = b;b = temp;
}int main() {int x = 10, y = 20;mySwap(x, y);  // 自动类型推导：T = intstd::cout << "x = " << x << ", y = " << y << std::endl;double a = 3.14, b = 2.71;mySwap<double>(a, b);  // 显式指定类型：T = doublestd::cout << "a = " << a << ", b = " << b << std::endl;return 0;
}

2.1.3 类型推导规则

• 自动类型推导（隐式实例化）：
  • 编译器根据传入参数的类型自动推导 T 的具体类型。
  • 要求：所有参数必须推导出一致的类型。
• 显式类型指定（显式实例化）：
  • 通过 <类型> 显式指定模板参数的类型。
  • 适用于类型不一致或需要强制指定类型的情况。

---

2.2 函数模板的注意事项

2.2.1 普通函数与函数模板的调用规则

• 优先调用普通函数：

  void myAdd(int a, int b) { /* 普通函数 */ }
  template <typename T> T myAdd(T a, T b) { return a + b; }int main() {int x = 10, y = 20;myAdd(x, y);  // 优先调用普通函数myAdd<>(x, y);  // 强制调用函数模板
  }

2.2.2 隐式类型转换问题

• 自动类型推导不支持隐式类型转换：

  char c = 'a';
  int a = 10;
  mySwap(a, c);  // 错误：无法自动推导 T 的类型
  mySwap<int>(a, c);  // 正确：显式指定类型后允许隐式转换

2.2.3 函数模板的重载

• 支持重载：

  template <typename T>
  void print(T a) {std::cout << "Generic print: " << a << std::endl;
  }template <>
  void print<int>(int a) {std::cout << "Specialized print for int: " << a << std::endl;
  }int main() {print(3.14);   // 调用通用模板print(10);     // 调用特化版本
  }

---

三、类模板详解

3.1 类模板的定义与使用

3.1.1 基本语法

template <typename T1, typename T2, ...>
class 类名 {// 类定义
};

3.1.2 示例：通用 Pair 类

// 类模板定义
template <typename T>
class Pair {
public:T first;T second;Pair(T a, T b) : first(a), second(b) {}void print() const {std::cout << "(" << first << ", " << second << ")" << std::endl;}
};int main() {Pair<int> p1(10, 20);          // T = intp1.print();                    // 输出: (10, 20)Pair<std::string> p2("Hello", "World");  // T = std::stringp2.print();                    // 输出: (Hello, World)return 0;
}

3.1.3 显式指定类型

• 必须显式指定类型：

  Pair<int, std::string> p3(100, "C++");  // 支持多个模板参数

---

3.2 类模板的注意事项

3.2.1 成员函数的实例化

• 延迟实例化：
  • 类模板的成员函数只有在被调用时才会实例化。
  • 例如：p1.print() 会实例化 print() 函数。

3.2.2 分文件编写问题

• 头文件中定义全部实现：
  • 类模板的声明和定义通常放在头文件中，因为编译器需要在实例化时看到完整的定义。
  • 如果分文件编写，需使用 #include "Pair.cpp" 或使用 export template（C++11 已弃用）。

3.2.3 特化与部分特化

• 完全特化：

  template <>  // 完全特化：T = int
  class Pair<int> {
  public:int first, second;void print() const { std::cout << "Specialized Pair<int>: (" << first << ", " << second << ")" << std::endl; }
  };

• 部分特化：

  template <typename T>
  class Pair<T, T> {  // 部分特化：当两个类型相同时
  public:T first, second;void print() const { std::cout << "Partial specialization for Pair<T, T>" << std::endl; }
  };

---

四、函数模板与类模板的对比

特性	函数模板	类模板
类型参数化	函数的返回值和参数类型可参数化	类的数据成员和成员函数类型可参数化
实例化方式	自动类型推导或显式指定	必须显式指定类型
成员函数实例化时机	在函数调用时实例化	在成员函数被调用时实例化
分文件编写	可分文件编写（需包含实现文件）	通常需将定义放在头文件中
特化支持	支持完全特化	支持完全特化和部分特化

---

五、模板编程的常见错误与解决方案

5.1 错误：类型推导失败

mySwap(10, 3.14);  // 错误：无法推导出一致的 T

解决方案：显式指定类型：

mySwap<double>(10, 3.14);

5.2 错误：类模板未显式指定类型

Pair p(10, 20);  // 错误：未指定模板参数

解决方案：显式指定类型：

Pair<int> p(10, 20);

5.3 错误：分文件编写时未包含实现

解决方案：将类模板的实现放在头文件中，或在源文件中显式实例化：

// Pair.cpp
template <typename T>
void Pair<T>::print() const {std::cout << "(" << first << ", " << second << ")" << std::endl;
}// 显式实例化
template class Pair<int>;
template class Pair<std::string>;

---

六、总结

6.1 核心要点

• 函数模板：通过类型参数化实现通用函数，支持自动类型推导和显式指定类型。
• 类模板：通过类型参数化实现通用类，必须显式指定类型，成员函数延迟实例化。
• 模板编程的优势：代码复用、类型安全、灵活适应多种数据类型。
• 注意事项：处理隐式类型转换、分文件编写问题、特化需求。

6.2 最佳实践

• 优先使用函数模板：适用于通用算法（如排序、查找）。
• 使用类模板设计通用数据结构：如 std::vector、std::map。
• 避免过度特化：除非有特殊需求，否则保持通用性。
• 合理使用显式实例化：减少编译时间并避免链接错误。