C++模板编程深入解析与应用实践一、引言 C++模板是实现泛型编程的强大工具，它使得代码具有高度复用性和灵活性。模板不仅

一、引言

C++模板是实现泛型编程的强大工具，它使得代码具有高度复用性和灵活性。模板不仅支持函数和类的泛化，还能实现复杂的元编程，提升程序效率和表达能力。

本文将系统讲解C++模板的基本用法、高级特性以及实战应用，帮助读者深入理解和掌握模板编程技巧。

二、模板基础

1. 函数模板

函数模板用于定义通用函数。

cpp复制编辑template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

调用时自动推导类型：

cpp复制编辑int a = 3, b = 5;
std::cout << max(a, b) << std::endl;

2. 类模板

类模板定义通用数据结构或类。

cpp复制编辑template<typename T>
class Stack {
    std::vector<T> elems;
public:
    void push(const T& elem) { elems.push_back(elem); }
    void pop() { elems.pop_back(); }
    T top() const { return elems.back(); }
};

三、模板特化

1. 全特化

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

cpp复制编辑template<>
class Stack<bool> {
    // 针对bool的优化实现
};

2. 偏特化

对部分模板参数进行特殊处理。

cpp复制编辑template<typename T>
class Container<T*> {
    // 针对指针类型的特殊实现
};

四、模板元编程

模板不仅能生成代码，还能进行编译期计算。

1. 计算阶乘

cpp复制编辑template<int N>
struct Factorial {
    static constexpr int value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial<0> {
    static constexpr int value = 1;
};

使用：

cpp复制编辑int f = Factorial<5>::value; // 120

2. 编译期条件选择

cpp复制编辑template<bool cond, typename TrueType, typename FalseType>
struct Conditional {
    using type = TrueType;
};

template<typename TrueType, typename FalseType>
struct Conditional<false, TrueType, FalseType> {
    using type = FalseType;
};

五、SFINAE与类型萃取

SFINAE（Substitution Failure Is Not An Error）允许模板选择合适的重载。

cpp复制编辑template<typename T>
auto func(T t) -> decltype(t.size(), void()) {
    std::cout << "有size()成员函数" << std::endl;
}

template<typename T>
void func(...) {
    std::cout << "无size()成员函数" << std::endl;
}

类型萃取可用于提取类型信息。

六、模板实战案例

1. 泛型排序算法

cpp复制编辑template<typename T>
void bubbleSort(std::vector<T>& arr) {
    for (size_t i = 0; i < arr.size(); ++i)
        for (size_t j = 0; j < arr.size() - i - 1; ++j)
            if (arr[j] > arr[j + 1])
                std::swap(arr[j], arr[j + 1]);
}

2. 泛型智能指针（简易版）

cpp复制编辑template<typename T>
class SimpleUniquePtr {
    T* ptr;
public:
    explicit SimpleUniquePtr(T* p = nullptr) : ptr(p) {}
    ~SimpleUniquePtr() { delete ptr; }
    T& operator*() { return *ptr; }
    T* operator->() { return ptr; }
    SimpleUniquePtr(const SimpleUniquePtr&) = delete;
    SimpleUniquePtr& operator=(const SimpleUniquePtr&) = delete;
    SimpleUniquePtr(SimpleUniquePtr&& other) : ptr(other.ptr) {
        other.ptr = nullptr;
    }
};