#include <iostream>
#include <vector>
// 通用冒泡排序
template <typename T>
void bubbleSort(std::vector<T>& arr) {
int n = arr.size();
for (int i = 0; i < n - 1; ++i) {
for (int j = 0; j < n - i - 1; ++j) {
if (arr[j] > arr[j + 1]) {
std::swap(arr[j], arr[j + 1]);
}
}
}
}
// 快速排序分区函数
int partition(std::vector<int>& arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; ++j) {
if (arr[j] <= pivot) {
++i;
std::swap(arr[i], arr[j]);
}
}
std::swap(arr[i + 1], arr[high]);
return i + 1;
}
// 快速排序
void quickSort(std::vector<int>& arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
// 类模板定义
template <typename T>
class Sorter {
public:
static void sort(std::vector<T>& arr) {
bubbleSort(arr);
}
};
// 针对int类型的类模板特化
template <>
class Sorter<int> {
public:
static void sort(std::vector<int>& arr) {
quickSort(arr, 0, arr.size() - 1);
}
};
// 函数模板特化和类模板特化区别说明:
// **语法区别**:
// - **函数模板特化**:
// - 函数模板特化需要显式指定模板参数列表,并且函数参数列表要与原函数模板一致(除了模板参数替换为具体类型)。例如:
// ```cpp
// template <>
// void func<int>(int param) {
// // 特化实现
// }
// ```
// - **类模板特化**:
// - 类模板特化是针对整个类的特化,语法为在`template<>`后紧跟类名,类名后可带模板参数(全特化时为空,偏特化时可能有部分模板参数)。例如:
// ```cpp
// template <>
// class ClassName<int> {
// public:
// // 特化实现
// };
// ```
// **使用场景区别**:
// - **函数模板特化**:
// - 当需要针对特定类型提供不同的函数行为时使用。比如在一些通用算法中,某些类型可能有更高效的实现方式,像针对`int`类型的快速排序特化,相比于通用的排序方式可能性能更好。
// - **类模板特化**:
// - 当一个类模板在不同类型下需要有完全不同的数据成员、成员函数实现时使用。例如,一个通用的序列化类模板,对于`int`类型可能有简单高效的序列化方式,而对于复杂对象类型则需要更复杂的处理,此时可以使用类模板特化。
int main() {
std::vector<int> intArr = {64, 25, 12, 22, 11};
Sorter<int>::sort(intArr);
std::cout << "Sorted int array: ";
for (int num : intArr) {
std::cout << num << " ";
}
std::cout << std::endl;
std::vector<double> doubleArr = {64.5, 25.3, 12.1, 22.7, 11.9};
Sorter<double>::sort(doubleArr);
std::cout << "Sorted double array: ";
for (double num : doubleArr) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}