类模板与 CTAD

上一节介绍了函数模板——将算法从具体类型中解放出来。本节将焦点转向类模板:用它来定义参数化的数据结构。同时深入讲解 C++17 的 CTAD(Class Template Argument Deduction),让类模板的使用像函数模板一样简洁。

1. 类模板基础

类模板的声明方式与函数模板类似——在 class 或 struct 前加上 template<...>。下面实现一个简单但完整的 Stack 容器:

#include <vector>
#include <stdexcept>

template<typename T>
class Stack {
public:
    // 压入元素
    void push(const T& value) {
        data_.push_back(value);
    }

    // 移动语义压入
    void push(T&& value) {
        data_.push_back(std::move(value));
    }

    // 弹出并返回栈顶
    T pop() {
        if (empty()) {
            throw std::runtime_error("pop from empty stack");
        }
        T top = std::move(data_.back());
        data_.pop_back();
        return top;  // NRVO 或移动
    }

    // 访问栈顶(不弹出)
    const T& top() const {
        if (empty()) {
            throw std::runtime_error("top on empty stack");
        }
        return data_.back();
    }

    // 判空
    [[nodiscard]] bool empty() const noexcept {
        return data_.empty();
    }

    // 元素个数
    [[nodiscard]] std::size_t size() const noexcept {
        return data_.size();
    }

private:
    std::vector<T> data_;
};

使用时需要显式指定模板参数(在 CTAD 出现之前):

Stack<int> int_stack;
int_stack.push(42);
int_stack.push(17);

auto val = int_stack.pop();  // val == 17

Stack<std::string> str_stack;
str_stack.push("hello");
str_stack.push("world");
std::cout << str_stack.top() << '\n';  // "world"

关键要点:类模板的成员函数只有在被实际调用时才会实例化。这意味着即使 T 不支持某个操作(比如打印),只要你不调用依赖该操作的成员函数,代码依然可以编译通过。

2. 成员函数定义

类模板的成员函数有两种定义方式:类内定义(隐式 inline)和类外定义。

类内定义

直接在类体内写实现,如上面的 Stack 示例。优点是简洁,适合短小的函数。

类外定义

将声明与实现分开。每个函数前都需要重复 template<...> 前缀,并用 ClassName<T>:: 限定:

template<typename T>
class Stack {
public:
    void push(const T& value);
    T pop();
    const T& top() const;
    [[nodiscard]] bool empty() const noexcept;
private:
    std::vector<T> data_;
};

// 类外定义——注意 template<typename T> 不可省略
template<typename T>
void Stack<T>::push(const T& value) {
    data_.push_back(value);
}

template<typename T>
T Stack<T>::pop() {
    if (empty()) {
        throw std::runtime_error("pop from empty stack");
    }
    T top = std::move(data_.back());
    data_.pop_back();
    return top;
}

template<typename T>
const T& Stack<T>::top() const {
    if (empty()) {
        throw std::runtime_error("top on empty stack");
    }
    return data_.back();
}

template<typename T>
bool Stack<T>::empty() const noexcept {
    return data_.empty();
}

头文件原则:模板的定义必须对使用者可见——编译器在实例化模板时需要看到完整实现。因此,类模板的成员函数定义通常放在头文件中(.h / .hpp),而不是 .cpp 文件。将实现放在 .cpp 中会导致链接错误。

3. CTAD(类模板参数推导,C++17)

C++17 之前,使用类模板时必须显式写出所有模板参数。C++17 引入了类模板参数推导(Class Template Argument Deduction, CTAD),让编译器从构造函数的实参推导出模板参数:

// C++14 风格——必须显式指定模板参数
std::pair<int, double> p1{1, 3.14};
std::vector<int> v1{1, 2, 3, 4, 5};
std::tuple<int, std::string, double> t1{42, "hello", 2.7};

// C++17 CTAD——编译器从构造实参推导
std::pair p2{1, 3.14};           // pair<int, double>
std::vector v2{1, 2, 3, 4, 5};  // vector<int>
std::tuple t2{42, "hello"s, 2.7}; // tuple<int, string, double>

CTAD 工作原理

编译器按以下步骤推导:

  1. 收集类模板的所有构造函数和用户定义的推导指引
  2. 将每个构造函数转化为一个虚构的函数模板
  3. 对这些函数模板执行重载决议,选出最佳匹配
  4. 从匹配结果确定模板参数

标准库常见 CTAD 示例

#include <optional>
#include <array>
#include <mutex>
#include <memory>

// std::optional
std::optional opt{42};            // optional<int>

// std::array (C++17 需要推导指引)
std::array arr{1, 2, 3, 4, 5};   // array<int, 5>

// std::lock_guard
std::mutex mtx;
std::lock_guard lock{mtx};       // lock_guard<std::mutex>

// std::pair 与 std::tuple
std::pair kv{"name"s, 100};      // pair<string, int>
std::tuple row{1, "Alice"s, 95.5}; // tuple<int, string, double>

// 函数返回值也可用 CTAD
auto make_config() {
    return std::pair{"timeout"s, 30};  // pair<string, int>
}

注意字符串字面量:"hello" 推导为 const char* 而非 std::string。如果需要 string,使用 "hello"s 字面量后缀(需要 using namespace std::string_literals;)。

4. 自定义推导指引(Deduction Guides)

当 CTAD 的隐式推导不能产生期望的结果时,你可以编写推导指引来显式告诉编译器如何推导:

template<typename T>
class Stack {
public:
    Stack() = default;

    // 从 initializer_list 构造
    Stack(std::initializer_list<T> init)
        : data_(init.begin(), init.end()) {}

private:
    std::vector<T> data_;
};

// 推导指引:从 initializer_list 推导 T
template<typename T>
Stack(std::initializer_list<T>) -> Stack<T>;

有了推导指引,就可以这样使用:

Stack s1{1, 2, 3, 4, 5};       // Stack<int>
Stack s2{"hello"s, "world"s};  // Stack<std::string>
// Stack s3{"hello", "world"}; // Stack<const char*> —— 注意!

更多推导指引示例

// 从迭代器对构造的容器
template<typename T>
class SimpleVec {
public:
    SimpleVec() = default;

    template<typename Iter>
    SimpleVec(Iter first, Iter last)
        : data_(first, last) {}

private:
    std::vector<T> data_;
};

// 推导指引:从迭代器的 value_type 推导 T
template<typename Iter>
SimpleVec(Iter, Iter) -> SimpleVec<typename std::iterator_traits<Iter>::value_type>;

// 使用
std::vector src{10, 20, 30};
SimpleVec sv(src.begin(), src.end());  // SimpleVec<int>

推导指引的位置:推导指引必须在类模板的同一命名空间中定义,且在使用 CTAD 之前可见。通常紧跟在类模板定义之后。

5. 模板特化(Full Specialization)

当通用模板对某个具体类型效率不高或行为不正确时,可以为该类型提供全特化版本:

// 主模板
template<typename T>
class Stack {
public:
    void push(const T& value) { data_.push_back(value); }
    T pop() {
        T top = std::move(data_.back());
        data_.pop_back();
        return top;
    }
    [[nodiscard]] bool empty() const noexcept { return data_.empty(); }
    [[nodiscard]] std::size_t size() const noexcept { return data_.size(); }
private:
    std::vector<T> data_;
};

// 全特化:为 bool 优化存储(每个元素只占 1 bit)
template<>
class Stack<bool> {
public:
    void push(bool value) {
        if (bit_pos_ == 0) {
            data_.push_back(0);
        }
        if (value) {
            data_.back() |= (1u << bit_pos_);
        }
        ++bit_pos_;
        if (bit_pos_ == 8) bit_pos_ = 0;
    }

    bool pop() {
        // 简化实现——实际需要处理跨字节
        --bit_pos_;
        if (bit_pos_ < 0) {
            bit_pos_ = 7;
            bool val = (data_.back() >> 7) & 1;
            data_.pop_back();
            return val;
        }
        bool val = (data_.back() >> bit_pos_) & 1;
        data_.back() &= ~(1u << bit_pos_);
        return val;
    }

    [[nodiscard]] bool empty() const noexcept {
        return data_.empty();
    }

private:
    std::vector<uint8_t> data_;
    int bit_pos_ = 0;  // 当前字节中的 bit 位置
};

使用方式不变——编译器自动选择特化版本:

Stack<int> is;    // 使用主模板
Stack<bool> bs;   // 使用 bool 特化版本

bs.push(true);
bs.push(false);
bs.push(true);
// 三个 bool 只占约 1 字节,而非 3 字节

全特化语法要点:template<> 表明这是一个特化——模板参数列表为空,因为所有参数都被具体类型(bool)替代。特化类可以有与主模板完全不同的成员和实现。

6. 偏特化(Partial Specialization)

偏特化允许你只特化部分模板参数,或基于类型结构进行模式匹配。注意:函数模板没有偏特化,只有类模板可以。

// 主模板
template<typename T>
class Storage {
public:
    Storage(T value) : value_(std::move(value)) {}
    const T& get() const { return value_; }
    void set(T value) { value_ = std::move(value); }
private:
    T value_;
};

// 偏特化:指针类型——管理指针的生命周期
template<typename T>
class Storage<T*> {
public:
    explicit Storage(T* ptr) : ptr_(ptr) {}
    ~Storage() { delete ptr_; }

    // 禁止拷贝
    Storage(const Storage&) = delete;
    Storage& operator=(const Storage&) = delete;

    // 允许移动
    Storage(Storage&& other) noexcept : ptr_(other.ptr_) {
        other.ptr_ = nullptr;
    }

    const T& get() const { return *ptr_; }
    void set(T value) { *ptr_ = std::move(value); }

private:
    T* ptr_;
};

更多偏特化模式

// 数组类型偏特化
template<typename T, std::size_t N>
class Storage<T[N]> {
public:
    Storage(const T (&arr)[N]) {
        std::copy(std::begin(arr), std::end(arr), data_);
    }

    const T& operator[](std::size_t i) const { return data_[i]; }
    static constexpr std::size_t size() { return N; }

private:
    T data_[N];
};

// std::pair 偏特化——键值对特殊处理
template<typename K, typename V>
class Storage<std::pair<K, V>> {
public:
    Storage(K key, V value) : pair_{std::move(key), std::move(value)} {}

    const K& key() const { return pair_.first; }
    const V& value() const { return pair_.second; }

private:
    std::pair<K, V> pair_;
};

编译器选择特化的规则:最特殊的匹配优先。

Storage<int> s1{42};            // 主模板
Storage<int*> s2{new int{99}};  // T* 偏特化 (T = int)
int arr[] = {1, 2, 3};
Storage<int[3]> s3{arr};        // T[N] 偏特化 (T = int, N = 3)

偏特化 vs. if constexpr:C++17 的 if constexpr 可以在某些场景下替代偏特化,代码更集中。但偏特化可以改变成员列表和存储布局,这是 if constexpr 做不到的。

7. 成员模板

类模板的成员函数本身也可以是模板——这就是成员模板。最常见的用途是实现类型转换构造函数:

template<typename T>
class SmartPtr {
public:
    explicit SmartPtr(T* p) : ptr_(p) {}
    ~SmartPtr() { delete ptr_; }

    // 成员模板:允许从 SmartPtr<Derived> 转换到 SmartPtr<Base>
    template<typename U>
    SmartPtr(SmartPtr<U>&& other) noexcept
        : ptr_(other.release()) {
        // 如果 U* 不能隐式转换为 T*,此处会编译失败
    }

    T* release() noexcept {
        T* tmp = ptr_;
        ptr_ = nullptr;
        return tmp;
    }

    T& operator*() const { return *ptr_; }
    T* operator->() const { return ptr_; }

private:
    T* ptr_;
};

// 使用
struct Base { virtual ~Base() = default; };
struct Derived : Base { int x = 42; };

SmartPtr<Derived> dp{new Derived{}};
SmartPtr<Base> bp{std::move(dp)};  // 成员模板转换

类型无关的比较器

template<typename T>
class Box {
public:
    explicit Box(T value) : value_(std::move(value)) {}

    const T& get() const { return value_; }

    // 成员模板:与任意类型的 Box 比较
    template<typename U>
    bool operator==(const Box<U>& other) const {
        return value_ == other.get();
    }

    // 成员模板:通用赋值
    template<typename U>
    Box& operator=(const Box<U>& other) {
        value_ = static_cast<T>(other.get());
        return *this;
    }

private:
    T value_;
};

// 使用
Box<int> bi{42};
Box<double> bd{42.0};
bool eq = (bi == bd);  // true,跨类型比较

Box<double> bd2{0.0};
bd2 = bi;  // int -> double 赋值

成员模板与特殊成员函数:成员模板不会阻止编译器生成默认的拷贝/移动构造函数。即使你写了接受 SmartPtr<U>&& 的模板构造函数,编译器仍然会生成默认的移动构造函数(当 U == T 时优先使用)。如果需要控制同类型的拷贝/移动行为,必须显式定义非模板版本。

8. 实用示例:Result<T, E> 类型

综合运用类模板、CTAD、偏特化和成员模板,实现一个简化版的 Result 类型(类似 C++23 的 std::expected):

#include <variant>
#include <stdexcept>
#include <string>
#include <utility>

// 标签类型,用于区分错误构造
template<typename E>
struct Err {
    E error;
};

// 推导指引
template<typename E>
Err(E) -> Err<E>;

// 主模板:Result<T, E>
template<typename T, typename E = std::string>
class Result {
public:
    // 成功构造
    Result(T value) : data_(std::move(value)) {}

    // 错误构造
    Result(Err<E> err) : data_(std::move(err.error)) {}

    // 查询状态
    [[nodiscard]] bool has_value() const noexcept {
        return std::holds_alternative<T>(data_);
    }
    explicit operator bool() const noexcept { return has_value(); }

    // 访问值
    T& value() & {
        if (!has_value()) throw std::runtime_error("Result has no value");
        return std::get<T>(data_);
    }
    const T& value() const& {
        if (!has_value()) throw std::runtime_error("Result has no value");
        return std::get<T>(data_);
    }

    // 访问错误
    E& error() & {
        if (has_value()) throw std::runtime_error("Result has no error");
        return std::get<E>(data_);
    }
    const E& error() const& {
        if (has_value()) throw std::runtime_error("Result has no error");
        return std::get<E>(data_);
    }

    // value_or——带默认值的安全访问
    T value_or(T default_val) const {
        return has_value() ? value() : std::move(default_val);
    }

    // 成员模板:map——对成功值做变换
    template<typename F>
    auto map(F&& func) const -> Result<decltype(func(value())), E> {
        using U = decltype(func(value()));
        if (has_value()) {
            return Result<U, E>{func(value())};
        }
        return Result<U, E>{Err{error()}};
    }

private:
    std::variant<T, E> data_;
};

// CTAD 推导指引
template<typename T>
Result(T) -> Result<T, std::string>;

template<typename E>
Result(Err<E>) -> Result<void, E>; // 仅错误时特殊处理

Result<void, E> 偏特化

当操作没有返回值、只关心成功/失败时,需要偏特化 void:

// 偏特化:T = void 时没有值,只有成功/失败状态
template<typename E>
class Result<void, E> {
public:
    // 成功构造
    Result() : data_(std::monostate{}) {}

    // 错误构造
    Result(Err<E> err) : data_(std::move(err.error)) {}

    [[nodiscard]] bool has_value() const noexcept {
        return std::holds_alternative<std::monostate>(data_);
    }
    explicit operator bool() const noexcept { return has_value(); }

    const E& error() const {
        return std::get<E>(data_);
    }

private:
    std::variant<std::monostate, E> data_;
};

使用 Result

#include <fstream>
#include <sstream>

// 返回值型错误处理
Result<std::string, std::string> read_file(const std::string& path) {
    std::ifstream file{path};
    if (!file.is_open()) {
        return Err{"cannot open file: " + path};
    }
    std::ostringstream ss;
    ss << file.rdbuf();
    return ss.str();  // 隐式构造 Result(成功)
}

// 无返回值的操作
Result<void, std::string> write_file(const std::string& path,
                                      const std::string& content) {
    std::ofstream file{path};
    if (!file.is_open()) {
        return Err{"cannot open file for writing: " + path};
    }
    file << content;
    return {};  // 成功
}

int main() {
    // 链式操作:读文件 -> 转大写
    auto result = read_file("config.txt")
        .map([](const std::string& s) {
            std::string upper = s;
            for (auto& c : upper) c = std::toupper(c);
            return upper;
        });

    if (result) {
        std::cout << "Content: " << result.value() << '\n';
    } else {
        std::cerr << "Error: " << result.error() << '\n';
    }

    // CTAD in action
    Result ok{42};          // Result<int, string>
    Result err{Err{"oops"s}};  // Result<void, string>

    // value_or 安全访问
    int val = ok.value_or(-1);  // 42
}

本节小结

  • 类模板用 template<typename T> class Name { ... }; 定义参数化数据结构
  • 成员函数可类内定义或类外定义;模板实现必须放在头文件中
  • CTAD(C++17)让编译器从构造函数参数推导模板参数,省去 <int> 等冗余标注
  • 推导指引用 ClassName(args) -> ClassName<deduced>; 控制 CTAD 行为
  • 全特化 template<> class X<具体类型> 为特定类型提供完全不同的实现
  • 偏特化 template<typename T> class X<T*> 基于类型结构模式匹配
  • 成员模板实现跨类型转换、泛型比较等灵活操作
  • 综合运用这些技术可构建如 Result<T, E> 这样安全且表达力强的工具类