类模板推导支持别名模板(C++20/23) ​

什么是别名模板的 CTAD ​

类模板参数推导(CTAD, Class Template Argument Deduction)是 C++17 引入的特性,允许在声明变量时省略模板参数,由编译器从初始化表达式中推导。C++20 将 CTAD 扩展到了别名模板(alias template),使得通过 using 定义的模板别名也能享受自动推导。

在 C++17 中,CTAD 只对原始类模板有效。如果你用 using 定义了别名模板,编译器不知道怎么推导,必须显式写出模板参数。C++20 解决了这个问题。

cpp
#include <vector>
#include <utility>

// 别名模板
template<typename T>
using Vec = std::vector<T>;

// C++17:不行
// Vec v = {1, 2, 3};  // 编译错误

// C++20:可以了
Vec v = {1, 2, 3};  // 推导为 Vec<int>,即 std::vector<int>

基本示例 ​

cpp
#include <iostream>
#include <vector>
#include <utility>
#include <tuple>
#include <map>
#include <array>
#include <memory>
#include <string>

// ============================
// 示例1:简单别名模板的 CTAD
// ============================

template<typename T>
using Vec = std::vector<T>;

template<typename T, typename U>
using MyPair = std::pair<T, U>;

void basic_demo() {
    // 别名模板的 CTAD——编译器自动推导 T
    Vec v1 = {1, 2, 3, 4};           // Vec<int>
    Vec v2 = {1.1, 2.2, 3.3};        // Vec<double>
    Vec v3 = {std::string("hello")}; // Vec<std::string>

    std::cout << "v1[0] = " << v1[0] << std::endl;
    std::cout << "v2 大小: " << v2.size() << std::endl;

    // pair 别名也可以
    MyPair p = {42, "hello"};  // MyPair<int, const char*>
    std::cout << "pair: (" << p.first << ", " << p.second << ")" << std::endl;
}

// ============================
// 示例2:固定一个参数的别名
// ============================

// 固定 value_type 为 string 的 map
template<typename Key>
using StringMap = std::map<Key, std::string>;

void partial_alias_demo() {
    // 这里只需要推导 Key,Value 已经固定为 string
    // 注意:别名模板 CTAD 对部分特化的别名支持取决于编译器实现
    StringMap<int> m1;  // 显式指定
    m1[1] = "one";
    m1[2] = "two";

    for (auto& [k, v] : m1) {
        std::cout << k << " -> " << v << std::endl;
    }
}

// ============================
// 示例3:自定义类模板的别名 CTAD
// ============================

template<typename T, typename U>
struct MyContainer {
    T first;
    U second;

    MyContainer(T a, U b) : first(a), second(b) {}
};

// 推导指引
template<typename T, typename U>
MyContainer(T, U) -> MyContainer<T, U>;

// 别名
template<typename T, typename U>
using Container = MyContainer<T, U>;

void custom_demo() {
    // 原始类模板的 CTAD
    MyContainer c1(10, 3.14);

    // 别名模板的 CTAD(C++20)
    Container c2(20, "hello");

    std::cout << "c1: (" << c1.first << ", " << c1.second << ")" << std::endl;
    std::cout << "c2: (" << c2.first << ", " << c2.second << ")" << std::endl;
}

// ============================
// 示例4:std::array 别名
// ============================

// C++17 的 std::array CTAD
void array_demo() {
    // 原始 CTAD
    std::array arr1 = {1, 2, 3, 4, 5};  // std::array<int, 5>

    // 别名
    // template<typename T, std::size_t N>
    // using Arr = std::array<T, N>;
    // Arr arr2 = {1, 2, 3};  // 取决于编译器支持

    std::cout << "array 大小: " << arr1.size() << std::endl;
    for (auto x : arr1) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

// ============================
// 示例5:tuple 别名
// ============================

template<typename... Ts>
using Tup = std::tuple<Ts...>;

void tuple_demo() {
    // std::tuple 的原始 CTAD
    std::tuple t1(1, 2.0, "hello");

    // 别名模板(取决于编译器支持可变参数别名 CTAD)
    // Tup t2(1, 2.0, "hello");

    auto [a, b, c] = t1;
    std::cout << "tuple: (" << a << ", " << b << ", " << c << ")" << std::endl;
}

// ============================
// 示例6:条件别名
// ============================

template<typename T>
using SmartPtr = std::unique_ptr<T>;

void smart_ptr_demo() {
    // unique_ptr 没有 CTAD(因为不能从裸指针安全推导)
    // 需要显式指定
    SmartPtr<int> p = std::make_unique<int>(42);
    std::cout << "智能指针: " << *p << std::endl;
}

int main() {
    std::cout << "=== 基本别名 CTAD ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 部分特化别名 ===" << std::endl;
    partial_alias_demo();

    std::cout << "\n=== 自定义类别名 ===" << std::endl;
    custom_demo();

    std::cout << "\n=== array ===" << std::endl;
    array_demo();

    std::cout << "\n=== tuple ===" << std::endl;
    tuple_demo();

    std::cout << "\n=== 智能指针 ===" << std::endl;
    smart_ptr_demo();

    return 0;
}

CTAD 支持范围 ​

特性C++17C++20C++23
类模板 CTAD支持支持支持
聚合类 CTAD不支持支持支持
别名模板 CTAD不支持支持增强
继承构造函数的 CTAD不支持不支持支持
别名模板推导指引不支持不支持支持(提案)

适用场景 ​

  • 简化标准库容器的类型别名声明
  • 框架/库中用别名模板隐藏实现细节
  • 部分固定模板参数的别名
  • 减少模板代码中的冗余类型书写

常见问题 ​

别名模板的 CTAD 和原始类模板的 CTAD 有区别吗?

别名模板的 CTAD 是通过将别名"展开"回原始类模板,然后应用原始的推导指引来实现的。结果和直接使用原始类模板的 CTAD 一致,但编译器内部的推导过程更复杂。

所有别名模板都支持 CTAD 吗?

不是。只有当别名模板可以"展开"回原始类模板,且原始类模板的推导指引足够推导出所有参数时才可以。有些复杂的别名(如涉及 SFINAE 或复杂转换的)可能不支持。

可以为别名模板写推导指引吗?

C++20 标准不允许。有提案(P2582)建议 C++23/26 允许为别名模板编写推导指引,但截至目前编译器支持有限。

注意事项 ​

  • C++20 特性,需要支持 C++20 的编译器
  • 不是所有别名模板都能推导——取决于别名的复杂度
  • 推导指引从原始类模板继承
  • 编译器支持程度不一——GCC 和 Clang 支持较好
  • 不能为别名模板直接编写推导指引(C++20)

总结 ​

C++20 将类模板参数推导(CTAD)扩展到了别名模板。在 C++17 中,using Vec = std::vector<T> 这样的别名不能享受 CTAD,必须显式写出模板参数。C++20 之后,编译器可以通过将别名展开回原始类模板并应用推导指引来自动推导模板参数。这让别名模板的使用和原始类模板一样方便,减少了模板代码中的类型冗余。不过要注意,复杂的别名模板可能不支持 CTAD,且不能为别名模板编写自定义推导指引。