模板
函数模板
函数模板（Template function）是C++中一种强大的特性，允许编写通用的函数代码，能够处理多种数据类型而不需要重复编写多个函数。下面是关于函数模板的语法结构、定义、示例和注意事项的详细介绍。
语法结构
函数模板的基本语法结构如下：
template <typename T>
T functionName(T parameter1, T parameter2, ...) {
// 函数体
}
或者可以使用 class 关键字代替 typename：
template <class T>
T functionName(T parameter1, T parameter2, ...) {
// 函数体
}
定义
template 或 template ：声明一个模板，T 是类型参数，可以是任何合法的类型，包括内置类型（如 int, double）或自定义类类型。
T functionName(T parameter1, T parameter2, …)：定义一个模板函数，参数和返回类型都是类型参数 T。函数体内的操作可以使用类型参数 T 定义的任何操作。
示例
示例 1：模板函数求最大值
#include <iostream>
template <typename T>
T maxValue(T a, T b) {
return (a > b) ? a : b;
}
int main() {
std::cout << maxValue(5, 10) << std::endl; // 输出：10
std::cout << maxValue(3.5, 1.2) << std::endl; // 输出：3.5
return 0;
}
在这个例子中，maxValue 函数模板可以处理 int 和 double 类型的参数，返回相应类型的最大值。
示例 2：模板函数交换值
#include <iostream>
template <typename T>
void swapValues(T &a, T &b) {
T temp = a;
a = b;
b = temp;
}
int main() {
int x = 5, y = 10;
std::cout << "Before swap: x = " << x << ", y = " << y << std::endl;
swapValues(x, y);
std::cout << "After swap: x = " << x << ", y = " << y << std::endl;
double a = 3.5, b = 1.2;
std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;
swapValues(a, b);
std::cout << "After swap: a = " << a << ", b = " << b << std::endl;
return 0;
}
这个示例展示了模板函数 swapValues 可以交换任意类型的值，包括 int 和 double。
注意事项
模板参数类型推导：通常情况下，编译器能够从函数参数推导出模板参数类型，但在某些情况下可能需要显式指定类型。
模板特化和偏特化：可以为模板定义特定类型的特化版本或部分特化版本，以处理特定类型的操作或优化实现。
编译器支持：不同的编译器对C++模板的支持程度不同，有些旧版本的编译器可能存在限制或bug。
模板函数的代码重用：函数模板允许代码重用，避免了为不同类型写多个函数的重复劳动，提高了代码的可维护性和灵活性。
类模板
类模板（Class Template）是C++中用于创建通用类的工具，允许定义一种类的蓝图，以便处理多种数据类型而无需为每种类型编写不同的类定义。以下是关于类模板的语法结构、定义、示例和注意事项的详细解释：
语法结构
类模板的基本语法结构如下：
template <typename T>
class ClassName {
public:
// 成员变量和成员函数的定义，可以使用类型参数 T
};
或者可以使用 class 关键字代替 typename：
template <class T>
class ClassName {
public:
// 成员变量和成员函数的定义，可以使用类型参数 T
};
定义
template 或 template ：声明一个模板，T 是类型参数，可以是任何合法的类型，包括内置类型（如 int, double）或自定义类类型。
class ClassName：定义一个模板类，类名后跟模板参数 （或 ），以表示这是一个模板类。
在类模板中可以定义成员变量、成员函数和构造函数，这些都可以使用模板参数 T。
示例
示例 1：类模板实现堆栈（Stack）
#include <iostream>
#include <vector>
template <typename T>
class Stack {
private:
std::vector<T> elements;
public:
void push(const T& element) {
elements.push_back(element);
}
void pop() {
if (!elements.empty()) {
elements.pop_back();
}
}
T top() const {
if (!elements.empty()) {
return elements.back();
}
throw std::out_of_range("Stack<>::top(): empty stack");
}
bool empty() const {
return elements.empty();
}
};
int main() {
Stack<int> intStack;
intStack.push(1);
intStack.push(2);
intStack.push(3);
while (!intStack.empty()) {
std::cout << intStack.top() << " ";
intStack.pop();
}
std::cout << std::endl;
Stack<std::string> stringStack;
stringStack.push("Hello");
stringStack.push("World");
while (!stringStack.empty()) {
std::cout << stringStack.top() << " ";
stringStack.pop();
}
std::cout << std::endl;
return 0;
}
在这个示例中，Stack 类模板定义了一个通用的堆栈数据结构，可以处理任意类型的数据，包括 int 和 std::string。
注意事项
模板参数类型推导：类模板可以根据使用时传递的参数推导出类型，但有时可能需要显式指定类型。
成员函数定义：类模板的成员函数可以在类外定义，也可以在类内定义，但通常推荐将较复杂的函数定义放在类外。
模板特化和偏特化：类模板可以像函数模板一样进行特化和偏特化，以处理特定类型或特定情况下的优化。
编译器支持：不同的编译器对类模板的支持程度可能有所不同，需要注意兼容性和遵循C++标准。
模板实例化：在使用类模板时，编译器会根据具体的模板参数生成相应的类实例（实例化过程），并处理类模板中的每个成员。.
常见错误
当使用类模板时，常见的容易犯的错误包括以下几种：
忘记模板参数列表：
template <typename T>
class MyClass {
// 类定义
};
// 错误示例：忘记模板参数列表 <>
MyClass obj; // 编译器会报错，需要指定模板参数 MyClass<T>
模板成员函数的实现位置错误：
template <typename T>
class MyClass {
public:
// 正确的成员函数实现位置
void memberFunction() {
// 函数定义
}
};
// 错误示例：将成员函数定义放在类外
template <typename T>
void MyClass<T>::memberFunction() {
// 错误的位置，应在类内实现
}
未提供模板参数或提供错误的模板参数：
template <typename T>
class MyClass {
// 类定义
};
// 错误示例：提供了错误的模板参数类型
MyClass<int> obj; // MyClass 需要一个类型参数 T，不是 int
模板类的友元函数定义：
template <typename T>
class MyClass {
template <typename U>
friend void friendFunction(MyClass<U>& obj); // 友元函数的正确定义方式
};
// 错误示例：未正确定义友元函数
template <typename T>
friend void friendFunction(MyClass<T>& obj); // 错误的定义方式
访问模板类的私有成员：
template <typename T>
class MyClass {
private:
int privateMember;
public:
void setPrivateMember(int value) {
privateMember = value;
}
};
int main() {
MyClass<int> obj;
obj.setPrivateMember(5);
// 错误示例：不能直接访问私有成员 privateMember
// int value = obj.privateMember; // 编译器会报错，privateMember 是私有的
return 0;
}
未处理模板类中的异常情况：
template <typename T>
class MyClass {
private:
T data;
public:
MyClass() {
// 构造函数可能需要处理异常
}
T getData() {
// 函数可能会抛出异常
}
};
使用模板类时忘记包含模板头文件：
// 错误示例：未包含模板类的头文件
#include "MyClass.h"
int main() {
MyClass<int> obj; // 编译器无法找到 MyClass 类的定义，会报错
return 0;
}
