C++ -模板

博客主页：【夜泉_ly】
本文专栏：【C++】
欢迎点赞收藏⭐关注❤️

引言：为什么需要模板？

在C语言中，
当我们需要为不同类型实现相同逻辑时（如交换两个变量的值），
必须为每个类型编写重复的代码：

void Swap(int& a, int& b) { /*...*/ }
void Swap(double& a, double& b) { /*...*/ }
void Swap(char& a, char& b) { /*...*/ }

这种代码冗余不仅增加维护成本，
也限制了代码的复用性。

C++模板的引入完美解决了这个问题，
让我们能够编写与类型无关的通用代码。

---

一、函数模板

1.1 基本语法

template<typename T>
void Swap(T& x, T& y) {
    T tmp = x;
    x = y;
    y = tmp;
}

• template：声明模板参数
  • 普通的函数参数定义的是变量、对象，
    而模板参数定义的是类型
  • 声明模板参数时 typename 可以和 class 互换，
    的作用是完全一致的，
    主要区别在于语法的习惯和历史原因。
• T 为类型占位符，在编译时根据实际类型实例化

1.2 实例化机制

int a = 0, b = 1;
double c = 1.1, d = 2.2;
Swap(a, b);  // 生成并调用Swap
Swap(c, d);  // 生成并调用Swap

• 编译器根据调用时的实参类型推导模板参数
• 生成对应类型的函数版本称为"实例化"

显式实例化：
有的时候 T 的类型不能自动推：

template<typename T>
T* Alloc(int n) {
	return new T[n];
}

此时需要显式实例化：

int* arr = Alloc(10);
char* ch = Alloc(10);

1.3 类型约束

模板代码中的类型操作必须适用于所有可能的类型参数。
如：

Date d1(2011,1,1), d2(2000,2,2);
Swap(d1, d2); 

• Swap 合法的前提是 Date 支持拷贝构造和赋值
  其中：

  T tmp = x1; // 调用拷贝构造
  x1 = x2;  x2 = tmp; // 调用赋值
  

---

二、类模板

2.1 基本定义

template<class T>
class Stack {
public:
    Stack(size_t capacity = 4);
    // ...
private:
    T* _array;
    size_t _size;
    size_t _capacity;
};

在类外定义时，
需要显式地使用模板名来限定作用域：

// 类外定义成员函数
template<class T>
Stack<T>::Stack(size_t capacity) {
    // 实现
}

模板函数尽量不要声明和定义分离（不同文件），
有时会出问题。

2.2 使用示例

Stack<int> intStack;     // 整型栈
Stack<double> dblStack;  // 双精度栈
Stack<char> charStack;   // 字符栈

• 实例化之前 Stack 是模板类型
• 实例化之后，T 变为具体的类型

---

三、模板特化

3.1 全特化（Full Specialization）

为特定类型提供特殊实现：

template<>
class Stack<bool> {  // 针对bool类型的特化实现
public:
    // 位压缩存储实现
};

这里有个好玩的：

// 原始模板
template <class T1, class T2 = int> class MyClass {
public:
    MyClass() { cout << "1"; }
};

// 全特化
template <> class MyClass<int, int> {
public:
    MyClass() { cout << "2"; }
};

int main() {
	MyClass<int>();
}

运行结果是 2

3.2 偏特化（Partial Specialization）

对模板参数进行部分约束：

// 原始模板
template<typename T1, typename T2 = int>
class MyClass { /*...*/ };

// 全特化
template<>
class MyClass<int, int> { /*...*/ };

// 指针类型的偏特化
template<typename T>
class MyClass<T*, int> { /*...*/ };

// 引用类型的偏特化
template<typename T>
class MyClass<T&, int> { /*...*/ };

// const类型的偏特化
template<typename T>
class MyClass<const T, int> { /*...*/ };

3.3 注意

函数模板的特化中，
函数形参表必须要和函数模板的基础参数类型完全相同，
如果不同编译器可能会报一些奇怪的错误。

template<typename T>
bool Less(const T& left, const T& right) {
	return left < right;
}

template<>
bool Less<int*>(int* const& left, int* const& right) {
	return *left < *right;
}

特化为 int* 时必须把 const 放在 * 和 & 中间。
错误写法：const int* &left

• 基础模板的类型 : const T&
  表示 const 的 T 的引用
• 特化模板的类型 : int* const&
  表示 const 的 int* 的引用
• 错误特化的类型 : const int*&
  表示 const int* 的引用

类模板的特化同理。

---

四、高级主题

4.1 分离编译问题

• 最好不要分离编译

通常情况下，
模板的声明和定义应放在同一个文件中，
尤其是在头文件中。

因为：

1. 编译器需要看到完整定义才能实例化模板
2. 链接器无法解析模板的实例化代码

解决方案：
在.cpp文件中显式实例化，
告诉编译器为特定类型生成代码

template class Stack<int>;  
template class Stack<double>;

如果模板的声明和定义被分开到不同的文件中，
且没有显式实例化，会发生链接错误。
因为示例化的模板并没有生成。

4.2 typename关键字

在依赖模板参数的类型前必须使用typename：

template<class T>
void func() {
    typename T::const_iterator it;  // 告诉编译器这是类型
}

因为 T::const_iterator 可能是个静态成员。

---

希望本篇文章对你有所帮助！并激发你进一步探索编程的兴趣！
本人仅是个C语言初学者，如果你有任何疑问或建议，欢迎随时留言讨论！让我们一起学习，共同进步！