C++类模板 - 元素码农

发布时间: 2025-03-23 09:58

↑

# C++类模板

本文将详细介绍C++类模板的概念、语法和使用方法,包括模板参数、特化、成员函数模板等特性。通过理解类模板,我们可以实现更加灵活和可复用的类设计。

## 类模板概述

类模板是C++泛型编程的重要组成部分:

1. 基本概念
   - 参数化的类定义
   - 类型安全
   - 编译期代码生成

2. 主要特点
   - 类型参数化
   - 非类型参数
   - 模板参数包

## 基本语法

```cpp
// 基本类模板
template<typename T>
class Array {
public:
    Array(size_t size = 0)
        : data_(size ? new T[size] : nullptr)
        , size_(size) {}
    
    ~Array() {
        delete[] data_;
    }
    
    // 拷贝控制
    Array(const Array& other)
        : data_(other.size_ ? new T[other.size_] : nullptr)
        , size_(other.size_) {
        for (size_t i = 0; i < size_; ++i) {
            data_[i] = other.data_[i];
        }
    }
    
    Array& operator=(const Array& other) {
        if (this != &other) {
            Array temp(other);
            std::swap(data_, temp.data_);
            std::swap(size_, temp.size_);
        }
        return *this;
    }
    
    // 访问元素
    T& operator[](size_t index) { return data_[index]; }
    const T& operator[](size_t index) const { return data_[index]; }
    
    size_t size() const { return size_; }
    
private:
    T* data_;
    size_t size_;
};
```

## 多个模板参数

```cpp
// 键值对容器
template<typename Key, typename Value>
class Dictionary {
public:
    void insert(const Key& key, const Value& value) {
        data_[key] = value;
    }
    
    Value* find(const Key& key) {
        auto it = data_.find(key);
        return it != data_.end() ? &it->second : nullptr;
    }
    
private:
    std::map<Key, Value> data_;
};

// 使用示例
void example() {
    Dictionary<std::string, int> dict;
    dict.insert("one", 1);
    dict.insert("two", 2);
}
```

## 非类型模板参数

```cpp
// 固定大小数组
template<typename T, size_t N>
class FixedArray {
public:
    FixedArray() = default;
    
    T& operator[](size_t index) {
        return data_[index];
    }
    
    const T& operator[](size_t index) const {
        return data_[index];
    }
    
    constexpr size_t size() const { return N; }
    
private:
    T data_[N];
};

// 使用示例
void fixedArrayExample() {
    FixedArray<int, 5> arr;
    for (size_t i = 0; i < arr.size(); ++i) {
        arr[i] = i;
    }
}
```

## 成员函数模板

```cpp
template<typename T>
class Container {
public:
    // 成员函数模板
    template<typename U>
    void copyFrom(const Container<U>& other) {
        data_ = static_cast<T>(other.getData());
    }
    
    T getData() const { return data_; }
    
private:
    T data_;
};

// 使用示例
void containerExample() {
    Container<double> d;
    Container<int> i;
    d.copyFrom(i);  // 从int转换到double
}
```

## 特化与偏特化

```cpp
// 主模板
template<typename T>
class SmartPtr {
public:
    SmartPtr(T* ptr) : ptr_(ptr) {}
    ~SmartPtr() { delete ptr_; }
    
private:
    T* ptr_;
};

// 数组特化
template<typename T>
class SmartPtr<T[]> {
public:
    SmartPtr(T* ptr) : ptr_(ptr) {}
    ~SmartPtr() { delete[] ptr_; }
    
private:
    T* ptr_;
};

// void特化
template<>
class SmartPtr<void> {
public:
    SmartPtr(void* ptr) : ptr_(ptr) {}
    ~SmartPtr() { free(ptr_); }
    
private:
    void* ptr_;
};
```

## 模板参数包

```cpp
// 可变参数模板类
template<typename... Types>
class Tuple {
    // 实现省略
};

// 递归继承实现
template<typename Head, typename... Tail>
class TupleImpl : private TupleImpl<Tail...> {
public:
    TupleImpl(Head h, Tail... t)
        : TupleImpl<Tail...>(t...)
        , head_(h) {}
    
    Head& head() { return head_; }
    const Head& head() const { return head_; }
    
private:
    Head head_;
};

// 特化结束递归
template<typename Head>
class TupleImpl<Head> {
public:
    TupleImpl(Head h) : head_(h) {}
    
    Head& head() { return head_; }
    const Head& head() const { return head_; }
    
private:
    Head head_;
};
```

## 最佳实践

1. 类型要求
   - 明确模板参数要求
   - 使用概念约束
   - 文档说明类型要求

2. 代码组织
   - 声明和定义分离
   - 显式实例化
   - 导出模板

```cpp
// 声明和定义分离示例
// MyTemplate.h
template<typename T>
class MyTemplate {
public:
    void process(T value);
    T getValue() const;
    
private:
    T data_;
};

// MyTemplate.cpp
template<typename T>
void MyTemplate<T>::process(T value) {
    data_ = value;
}

template<typename T>
T MyTemplate<T>::getValue() const {
    return data_;
}

// 显式实例化
template class MyTemplate<int>;
template class MyTemplate<double>;
```

3. 性能考虑
   - 代码膨胀
   - 编译时间
   - 实例化开销

## 注意事项

1. 编译期行为
   - 延迟实例化
   - 编译错误位置
   - 链接问题

2. 类型安全
   - 类型约束
   - 静态断言
   - 类型特征

3. 调试难度
   - 错误信息复杂
   - 实例化跟踪
   - 符号名称问题

## 总结

类模板是C++泛型编程的核心机制之一,它允许我们创建可以适用于不同类型的通用类设计。通过模板参数、特化、成员函数模板等特性,我们可以实现高度灵活和可复用的类。在使用类模板时,需要注意类型要求、代码组织和性能影响,并遵循最佳实践来确保代码的可维护性和效率。