在C++中，模板（Template） 是一种泛型编程技术，用于编写能够处理不同数据类型的代码，而无需为每种类型单独编写多个版本。模板允许函数、类和结构体在不指定具体数据类型的情况下定义，使得代码更加通用和可复用。
模板主要分为两种类型：
- 函数模板（Function Template）
- 类模板（Class Template）
通过模板，程序员可以编写类型无关的代码，编译器会根据实际传入的类型实例化出具体的函数或类的版本。
可以通过模板实现容器！
1. 函数模板
函数模板用于定义一个可以处理多种类型的函数。它的核心思想是：我们并不为特定类型编写函数，而是编写能够接受任何类型的函数定义。
语法：
template <typename T>
T functionName(T param1, T param2) {
// 函数体
}
template: 表示这是一个模板。typename T: 定义模板参数T，T可以代表任何类型（也可以用class T，两者是等价的）。T: 是模板函数的类型参数。
示例：
#include <iostream>
using namespace std;
// 一个函数模板，用于返回两个值中的最大值
template <typename T>
T getMax(T a, T b) {
return (a > b) ? a : b;
}
int main() {
cout << getMax(10, 20) << endl; // 输出：20 (int类型)
cout << getMax(3.5, 7.2) << endl; // 输出：7.2 (double类型)
cout << getMax('a', 'z') << endl; // 输出：z (char类型)
return 0;
}
在这个例子中，getMax是一个模板函数，可以用于处理不同的数据类型（如int、double、char等）。编译器会根据函数调用时传入的参数类型自动实例化出对应版本的函数。
2. 类模板
类模板允许创建能够处理不同类型数据的类。与函数模板类似，类模板也通过将类型参数化，使得类可以用于多个不同的类型，而不需要为每个类型分别编写类定义。
语法：
template <typename T>
class ClassName {
T member; // 使用模板参数T作为类型
public:
ClassName(T value) : member(value) {}
T getMember() { return member; }
};
示例：
#include <iostream>
using namespace std;
// 定义一个类模板
template <typename T>
class Box {
T value; // 用模板类型T来定义数据成员
public:
Box(T v) : value(v) {} // 构造函数
T getValue() { return value; } // 返回存储的值
};
int main() {
Box<int> intBox(10); // Box类实例化为int类型
Box<double> doubleBox(3.14); // Box类实例化为double类型
cout << intBox.getValue() << endl; // 输出：10
cout << doubleBox.getValue() << endl; // 输出：3.14
return 0;
}
在这个例子中，Box类是一个模板类，可以实例化为不同类型的Box对象，如Box<int>和Box<double>。
3. 模板特化
模板特化（Template Specialization）允许为特定的类型提供特殊的实现，替代通用模板的默认行为。
示例：
#include <iostream>
using namespace std;
// 通用模板
template <typename T>
T getMax(T a, T b) {
return (a > b) ? a : b;
}
// 模板特化，专门为char类型定义
template <>
char getMax<char>(char a, char b) {
cout << "Comparing characters: " << a << " and " << b << endl;
return (a > b) ? a : b;
}
int main() {
cout << getMax(10, 20) << endl; // 输出：20
cout << getMax('a', 'z') << endl; // 输出：Comparing characters: a and z, z
return 0;
}
在这个例子中，getMax函数模板有一个特化版本专门用于char类型，当传入char类型参数时，会调用这个特化的版本。
4. 模板的优势
- 代码复用：模板允许编写通用的代码，可以处理不同类型的对象，减少代码重复。
- 类型安全：模板实例化是在编译时进行的，编译器会根据具体类型进行类型检查，保证类型安全。
- 效率高：模板通过编译时生成具体类型的代码，不会带来额外的运行时开销。
5. 模板的缺点
- 代码膨胀：每个模板函数或类在不同类型下都会实例化出不同版本的代码，这可能导致生成的二进制文件变得庞大。
- 编译时间增加：模板实例化会增加编译时间，特别是当模板类或函数大量使用时。
- 调试复杂：模板代码在错误时产生的编译信息往往比较难以理解，调试难度较大。
6. 模板的常见使用场景
- STL（标准模板库）：C++的STL（Standard Template Library）广泛使用了模板技术，提供了如
vector、list、map等容器类，以及一系列的通用算法（如sort、find等），这些容器和算法都能够支持不同类型的数据。 - 泛型算法：通过模板编写的算法可以应用于不同类型的容器或数据结构，而无需针对每种类型分别实现。
- 自定义容器和数据结构：通过类模板，可以实现自定义的容器和数据结构，如泛型的链表、队列、栈等。
7. 模板与宏的区别
虽然C语言中可以使用宏来实现类似的泛型效果，但模板比宏要更加类型安全，且更加灵活。
- 类型安全：模板在编译时进行类型检查，而宏只是文本替换，缺乏类型检查机制。
- 功能强大：模板支持复杂的类型推导和重载，宏只能做简单的文本替换。
- 错误定位：模板的错误发生在编译时，宏的错误发生在预处理时，宏错误往往更加难以调试。
宏示例：
#define MAX(a, b) ((a) > (b) ? (a) : (b))
int main() {
int x = MAX(10, 20); // 使用宏
return 0;
}
虽然宏可以达到类似的功能，但它不具备类型检查，也容易产生一些隐蔽的错误，如运算符优先级问题。
总结
- 模板是C++中一种支持泛型编程的机制，可以编写不依赖于具体类型的函数或类，编译时根据传递的类型生成对应的具体代码。
- 函数模板用于定义可以处理不同数据类型的函数，类模板用于定义可以处理不同数据类型的类。
- 模板特化允许为特定类型提供特殊的实现。
- 模板提高了代码的复用性和灵活性，但也可能带来代码膨胀和编译时间增加的问题。
模板是C++中极其重要的特性，广泛应用于STL和其他泛型库中，使得C++在处理多种数据类型时更加高效和灵活。
C++中的模板函数
模板函数是C++中一种泛型编程的方式，它允许编写能够处理不同数据类型的函数，而无需为每种数据类型分别编写多个函数。模板函数的主要思想是将类型参数化，使得函数可以在编译时根据传递的具体类型实例化为对应的版本。通过模板函数，代码可以更加简洁和复用，同时避免类型的重复代码。
1. 模板函数的定义
模板函数使用关键字template来定义，之后跟随一对尖括号<>，其中指定类型参数（通常使用typename或class关键字）。这些类型参数相当于占位符，在调用模板函数时，编译器会根据实际传入的类型进行实例化。
基本语法：
template <typename T>
T functionName(T param) {
// 函数体，可以使用类型T的变量或参数
}
template：声明这是一个模板。typename T：T是类型参数的占位符，表示可以传入任意类型。class T在这里也是一样的作用。- 函数体：可以根据传入的具体类型进行操作。
示例：简单的模板函数
#include <iostream>
using namespace std;
// 定义一个模板函数，计算两数中的最大值
template <typename T>
T getMax(T a, T b) {
return (a > b) ? a : b;
}
int main() {
// 使用模板函数计算不同类型的最大值
cout << getMax(10, 20) << endl; // 输出：20
cout << getMax(5.5, 3.8) << endl; // 输出：5.5
cout << getMax('a', 'z') << endl; // 输出：z
return 0;
}
在这个例子中，getMax函数可以处理不同的类型（如整数、浮点数、字符），而不需要为每种类型单独定义函数。编译器根据调用时传递的参数类型来自动生成对应的函数版本。
2. 模板函数的实例化
当模板函数被调用时，编译器根据传递的参数类型自动生成具体类型的函数。这一过程称为模板实例化。模板函数的本质是提供一个通用的函数定义，而实际的类型是在使用时确定。
例如：
getMax(10, 20); // 编译器实例化出int类型的getMax函数
getMax(5.5, 3.8); // 编译器实例化出double类型的getMax函数
getMax('a', 'z'); // 编译器实例化出char类型的getMax函数
在每次调用时，编译器会根据不同的类型生成适合的函数版本。
3. 模板函数的特化
在某些情况下，你可能希望为特定类型提供专门的实现，而不是使用通用模板函数。这可以通过模板特化（Template Specialization）实现。模板特化允许为某些特定类型定义定制的模板函数版本。
示例：模板函数的特化
#include <iostream>
using namespace std;
// 通用模板函数
template <typename T>
T getMax(T a, T b) {
return (a > b) ? a : b;
}
// 模板特化：为char类型提供特化版本
template <>
char getMax(char a, char b) {
cout << "Comparing characters: " << a << " and " << b << endl;
return (a > b) ? a : b;
}
int main() {
cout << getMax(10, 20) << endl; // 输出：20
cout << getMax('a', 'z') << endl; // 输出：Comparing characters: a and z, z
return 0;
}
在这个例子中，getMax模板被特化为处理char类型时输出额外的信息。特化后的版本仅适用于char类型，其他类型仍然使用通用的模板函数。
4. 模板的默认参数
类似于普通函数，模板也可以有默认的模板参数。如果没有提供相应的模板参数，编译器会使用默认值。
示例：模板函数的默认参数
#include <iostream>
using namespace std;
template <typename T = int>
T getMin(T a, T b) {
return (a < b) ? a : b;
}
int main() {
cout << getMin(10, 20) << endl; // 输出：10, 使用默认的int类型
cout << getMin(3.5, 2.1) << endl; // 输出：2.1, 使用double类型
return 0;
}
在这个例子中，T有一个默认类型int，因此如果不明确指定类型，函数会默认实例化为int类型。
5. 非类型模板参数
除了类型参数，模板还可以接受非类型模板参数，这类参数通常是常量表达式，可以在模板定义时作为参数传递。
示例：非类型模板参数
#include <iostream>
using namespace std;
// 非类型模板参数
template <typename T, int size>
class Array {
private:
T arr[size]; // 数组大小由模板参数决定
public:
void set(int index, T value) {
if (index >= 0 && index < size) {
arr[index] = value;
}
}
T get(int index) const {
if (index >= 0 && index < size) {
return arr[index];
}
return T(); // 返回默认值
}
};
int main() {
Array<int, 5> myArray; // 创建大小为5的int数组
myArray.set(0, 10);
cout << myArray.get(0) << endl; // 输出：10
return 0;
}
在这个例子中，Array模板类接受了一个非类型模板参数size，它决定了数组的大小。
6. 模板函数的优点
- 代码复用：模板函数能够减少重复代码，因为它可以处理多种数据类型，避免了为每个类型单独编写相似的函数。
- 类型安全：模板函数在编译时实例化，因此类型检查发生在编译期，这确保了类型安全。
- 灵活性：通过模板，程序员可以编写更加通用的代码，适用于不同的数据类型和操作。
7. 模板函数的缺点
- 代码膨胀：由于模板函数在每次使用时都会被实例化为不同的版本，因此可能会导致生成大量不同的函数版本，从而增加代码体积。
- 调试复杂：由于模板代码是在编译时实例化，编译器产生的错误信息有时可能难以理解和调试。
- 编译时间增加：模板代码的实例化可能会增加编译时间，特别是在涉及大量模板实例化时。
8. 模板函数与函数重载
模板函数可以和普通函数以及函数重载共存。当模板函数与普通函数之间存在匹配时，C++编译器会优先选择非模板函数。只有当没有合适的非模板函数时，才会使用模板函数。
示例：模板函数与函数重载
#include <iostream>
using namespace std;
// 普通函数
int getMax(int a, int b) {
cout << "Using non-template function" << endl;
return (a > b) ? a : b;
}
// 模板函数
template <typename T>
T getMax(T a, T b) {
cout << "Using template function" << endl;
return (a > b) ? a : b;
}
int main() {
cout << getMax(10, 20) << endl; // 输出：Using non-template function, 20
cout << getMax(3.5, 2.1) << endl; // 输出：Using template function, 3.5
return 0;
}
在这个例子中，getMax(10, 20)调用的是普通函数，因为存在精确匹配，而getMax(3.5, 2.1)则调用了模板函数，因为没有非模板版本能匹配浮点类型。
总结：
- 模板函数是C++中的泛型编程技术，允许编写能够处理不同数据类型的函数。
- 模板函数的类型参数化：通过类型参数
typename或class，可以编写不依赖于具体数据类型的通用函数。 - 模板特化：可以为某些特定类型提供专门的实现。
- 非类型模板参数：模板参数不仅可以是类型，也可以是常量。
- 优点：提供了代码复用和类型安全性。
- 缺点：可能会导致代码膨胀和编译时间
C++ 中的模板类是一种泛型编程机制，它允许类（或者函数）在定义时不指定具体的数据类型，而是在使用时通过模板参数来传递具体类型。这种特性提高了代码的复用性和灵活性，因为你可以编写通用的代码而不必为不同的数据类型重复编写相同的逻辑。
模板类的定义和使用
模板类使用 template 关键字定义。模板可以接受一个或多个类型参数，编译器在实例化模板类时会根据实际类型生成相应的类。
1. 基本语法
template <typename T>
class MyClass {
public:
MyClass(T val) : value(val) {}
void display() const {
std::cout << "Value: " << value << std::endl;
}
private:
T value; // 使用模板类型 T 作为成员变量类型
};
- template <typename T>：声明一个模板，其中
T是一个类型参数（可以理解为一个占位符）。 - T value：
T是模板参数，表示数据类型，可以是任意类型，如int,double,std::string等。 - MyClass(T val)：构造函数接受一个类型为
T的参数。
2. 模板类的实例化
使用模板类时，需要在尖括号 < > 中指定实际的类型。模板类会在编译时根据你指定的类型参数生成实际的类。
int main() {
MyClass<int> obj1(10); // 实例化一个 MyClass<int> 对象
MyClass<double> obj2(3.14); // 实例化一个 MyClass<double> 对象
MyClass<std::string> obj3("Hello");
obj1.display(); // 输出: Value: 10
obj2.display(); // 输出: Value: 3.14
obj3.display(); // 输出: Value: Hello
return 0;
}
3. 模板类中的多个类型参数
你可以为模板类定义多个类型参数，这样可以让类更加灵活。例如，定义一个类可以存储两个不同类型的值：
template <typename T1, typename T2>
class Pair {
public:
Pair(T1 firstVal, T2 secondVal) : first(firstVal), second(secondVal) {}
void display() const {
std::cout << "First: " << first << ", Second: " << second << std::endl;
}
private:
T1 first;
T2 second;
};
使用时，可以分别为 T1 和 T2 指定不同的类型：
int main() {
Pair<int, double> pair1(1, 3.14);
Pair<std::string, int> pair2("Age", 30);
pair1.display(); // 输出: First: 1, Second: 3.14
pair2.display(); // 输出: First: Age, Second: 30
return 0;
}
4. 模板类的特化
模板特化是指为某个具体的类型提供一个特定的实现，而不使用默认的模板版本。
4.1 全特化
为某种特定类型提供完全不同的实现：
template <>
class MyClass<char> {
public:
MyClass(char val) : value(val) {}
void display() const {
std::cout << "Character: " << value << std::endl;
}
private:
char value;
};
在这种情况下，如果实例化 MyClass<char>，将使用专门定义的特化版本，而不是默认的模板版本。
4.2 偏特化
偏特化是指为部分模板参数指定特化版本，其他参数仍然保持泛型。
template <typename T>
class MyClass<T*> { // 对指针类型进行偏特化
public:
MyClass(T* ptr) : value(ptr) {}
void display() const {
std::cout << "Pointer to value: " << *value << std::endl;
}
private:
T* value;
};
5. 模板类的限制与编译期特性
-
编译期生成：模板是在编译时生成特定类型的类。这意味着每次实例化模板类时，编译器会生成一份具体类型的类代码。如果模板实例化次数过多，可能导致代码膨胀，即编译生成的二进制文件体积增大。
-
类型安全：模板类是类型安全的，因为模板类会根据传入的类型进行类型检查。例如，
MyClass<int>和MyClass<double>是不同的类，它们各自有不同的成员函数和类型。 -
错误提示复杂：模板类的错误提示在编译时可能会比较复杂，尤其是模板嵌套时，可能产生长而难以理解的错误信息。
6. 模板类的应用场景
模板类主要用于实现通用算法和数据结构，而无需为每种数据类型重复编写代码。常见的应用场景包括：
-
标准模板库（STL）：STL 是 C++ 中模板类的一个经典应用，它提供了许多常用的数据结构（如
std::vector,std::list,std::map）和算法（如std::sort,std::find）。 -
智能指针：如
std::shared_ptr<T>,std::unique_ptr<T>等都是通过模板实现的，用于通用的资源管理。
示例：实现一个简单的模板栈类
template <typename T>
class Stack {
private:
std::vector<T> elements; // 使用 std::vector 存储元素
public:
void push(const T& elem) {
elements.push_back(elem); // 添加元素
}
void pop() {
if (!elements.empty()) {
elements.pop_back(); // 移除最后一个元素
} else {
throw std::out_of_range("Stack<>::pop(): empty stack");
}
}
T top() const {
if (!elements.empty()) {
return elements.back(); // 返回最后一个元素
} else {
throw std::out_of_range("Stack<>::top(): empty stack");
}
}
bool isEmpty() const {
return elements.empty();
}
};
int main() {
Stack<int> intStack;
intStack.push(10);
intStack.push(20);
std::cout << "Top element: " << intStack.top() << std::endl; // 输出 20
Stack<std::string> stringStack;
stringStack.push("Hello");
stringStack.push("World");
std::cout << "Top element: " << stringStack.top() << std::endl; // 输出 World
return 0;
}
总结
- 模板类 是 C++ 泛型编程的一种重要手段，允许类的定义中使用类型参数，以便在编译时生成不同类型的类。
- 优点：代码复用、类型安全、提高灵活性。
- 缺点：可能导致代码膨胀，模板错误信息复杂。
- 注意： 每个模板类前都要独立使用模板申明