C++模板编程详解与应用一、引言 C++模板是实现泛型编程的核心技术，允许编写与类型无关的代码，提高代码复用性和灵活性。

一、引言

C++模板是实现泛型编程的核心技术，允许编写与类型无关的代码，提高代码复用性和灵活性。随着现代C++的演进，模板技术也不断发展，涉及模板特化、模板元编程等高级话题。

本文将系统介绍C++模板的语法基础、特化机制、元编程思想及典型应用，帮助读者掌握模板编程技巧。

二、模板基础

1. 函数模板

函数模板定义了一组可以操作任意类型的函数。

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

int main() {
    std::cout << max(3, 5) << std::endl;
    std::cout << max(3.5, 2.5) << std::endl;
}

2. 类模板

类模板允许定义泛型类。

cpp复制编辑template<typename T>
class Box {
private:
    T value;
public:
    Box(T v) : value(v) {}
    T getValue() { return value; }
};

三、模板参数

模板参数可以是类型参数，也可以是非类型参数。

cpp复制编辑template<typename T, int size>
class Array {
    T data[size];
};

四、模板实例化

编译器根据使用情况自动实例化模板。也可以显式实例化：

cpp复制编辑template class Box<int>;

五、模板特化

1. 全特化

为特定类型实现模板的专门版本。

cpp复制编辑template<>
class Box<bool> {
    bool value;
public:
    Box(bool v) : value(v) {}
    void print() { std::cout << (value ? "true" : "false") << std::endl; }
};

2. 偏特化

针对部分模板参数特化。

cpp复制编辑template<typename T>
class Box<T*> {
    T* ptr;
public:
    Box(T* p) : ptr(p) {}
};

六、模板元编程

模板元编程利用模板递归计算，实现编译时计算。

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

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

int main() {
    std::cout << Factorial<5>::value << std::endl; // 120
}

七、模板技巧

SFINAE（Substitution Failure Is Not An Error）：实现函数重载选择。
类型萃取（type traits）：编译时类型信息判断。
可变参数模板：支持任意参数数量。

cpp复制编辑template<typename... Args> void printAll(Args... args) { (std::cout << ... << args) << std::endl; // C++17 折叠表达式 }

八、实战案例：智能指针实现简化版

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) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
    SimpleUniquePtr& operator=(SimpleUniquePtr&& other) noexcept {
        if (this != &other) {
            delete ptr;
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }
};