C++ 模板推导指南（CTAD）：C++17 简化类模板实例化

好的，各位观众老爷们，晚上好！欢迎来到“C++模板推导指南：C++17 简化类模板实例化”的特别节目。我是你们的老朋友，今晚的讲师，一个在代码堆里摸爬滚打了多年的老码农。

今天咱们要聊聊C++17中一个非常给力的特性，它能让我们的代码变得更简洁、更优雅，那就是“类模板参数推导（Class Template Argument Deduction，简称CTAD）”。

为什么需要 CTAD？

在C++17之前，我们使用类模板的时候，总是要显式地指定模板参数，就像这样：

template <typename T>
struct MyPair {
    T first;
    T second;
};

int main() {
    MyPair<int> pair1; // 必须显式指定 int
    MyPair<double> pair2; // 必须显式指定 double
    return 0;
}

这没什么大问题，但总是有点啰嗦，尤其是在模板参数可以从构造函数的参数中推导出来的时候。

想象一下，你要创建一个 MyPair 对象，它的两个成员都是 int 类型，你必须写 MyPair<int>。这就像明明知道你要喝的是橙汁，却还要指着橙子说：“我要这个橙子，并且我要把它榨成橙汁！”

CTAD就是来解决这个问题的。它允许编译器根据构造函数的参数来自动推导出模板参数，让我们的代码更简洁，更接近自然语言。

CTAD 的基本用法

有了 CTAD，上面的代码可以这样写：

template <typename T>
struct MyPair {
    T first;
    T second;

    MyPair(T f, T s) : first(f), second(s) {} // 构造函数是关键
};

int main() {
    MyPair pair1(10, 20); //  编译器自动推导出 T 为 int
    MyPair pair2(3.14, 2.71); // 编译器自动推导出 T 为 double
    return 0;
}

看到了吗？我们不再需要显式地指定模板参数了！编译器会根据 MyPair(10, 20) 中的 10 和 20 自动推导出 T 为 int。

这就像你去咖啡店，直接说：“我要一杯拿铁。”咖啡师会根据你的要求自动制作一杯拿铁，而不需要你告诉他：“我要一杯牛奶，还要一杯浓缩咖啡，然后把它们混合在一起。”

CTAD 的工作原理

CTAD 的工作原理其实很简单：

寻找构造函数： 编译器首先会寻找类模板的构造函数。
匹配参数类型： 编译器会尝试将构造函数的参数类型与你提供的参数进行匹配。
推导模板参数： 如果匹配成功，编译器就会根据构造函数的参数类型来推导出模板参数。

CTAD 的几种情况

CTAD 可以分为几种情况：

默认推导： 这是最常见的情况，就像我们上面的 MyPair 例子一样。编译器会根据构造函数的参数类型来自动推导出模板参数。
推导指引（Deduction Guide）： 有时候，默认的推导规则可能不够用，或者我们希望自定义推导规则。这时候，我们可以使用推导指引。
聚合初始化： 对于聚合类（aggregate class），CTAD 也可以工作。

接下来，我们分别来看一下这几种情况。

1. 默认推导

默认推导是最简单的情况，只要类模板有一个合适的构造函数，编译器就可以自动推导出模板参数。

例如：

template <typename T>
struct Vector {
    T* data;
    size_t size;

    Vector(size_t s) : data(new T[s]), size(s) {}
};

int main() {
    Vector v1(10); // 编译器推导出 T 为 int (因为 size_t 可以隐式转换为 int)
    return 0;
}

2. 推导指引

推导指引是一种显式地告诉编译器如何进行模板参数推导的方式。它允许我们自定义推导规则，以满足更复杂的需求。

推导指引的语法如下：

template <typename T>
struct MyContainer {
    T* data;
    size_t size;

    template <typename U>
    MyContainer(U begin, U end) : data(new T[std::distance(begin, end)]), size(std::distance(begin, end)) {
        std::copy(begin, end, data);
    }
};

// 推导指引
template <typename U>
MyContainer(U begin, U end) -> MyContainer<typename std::iterator_traits<U>::value_type>;

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    MyContainer container(vec.begin(), vec.end()); // 编译器推导出 T 为 int
    return 0;
}

在这个例子中，我们定义了一个 MyContainer 类模板，它接受两个迭代器作为构造函数的参数。我们还定义了一个推导指引，它告诉编译器如何根据迭代器的类型来推导出模板参数 T。

推导指引 template <typename U> MyContainer(U begin, U end) -> MyContainer<typename std::iterator_traits<U>::value_type>; 做了以下事情：

template <typename U>: 引入了一个模板参数 U，它代表迭代器的类型。
MyContainer(U begin, U end): 匹配接受两个迭代器 begin 和 end 的构造函数。
-> MyContainer<typename std::iterator_traits<U>::value_type>: 指定推导结果。这里使用了 std::iterator_traits<U>::value_type 来获取迭代器指向的元素的类型，并将其作为 MyContainer 的模板参数 T。

推导指引的用武之地

解决二义性： 有时候，编译器可能会面临多种可能的推导结果，这时候就需要使用推导指引来明确指定推导规则。
自定义推导规则： 有时候，默认的推导规则可能不符合我们的需求，这时候可以使用推导指引来自定义推导规则。
类型转换： 可以使用推导指引来进行类型转换。

3. 聚合初始化

聚合类是指没有用户声明的构造函数、没有私有或保护的非静态数据成员、没有基类和虚函数的类。

对于聚合类，CTAD 也可以工作：

template <typename T, typename U>
struct Point {
    T x;
    U y;
};

int main() {
    Point p1{10, 20}; // T 为 int, U 为 int
    Point p2{3.14, 2}; // T 为 double, U 为 int
    return 0;
}

在这个例子中，Point 是一个聚合类，它有两个模板参数 T 和 U。编译器会根据聚合初始化的值来自动推导出这两个模板参数的类型。

CTAD 的一些限制

CTAD 虽然很强大，但也有一些限制：

无法推导所有模板参数： CTAD 只能推导那些可以从构造函数的参数中推导出来的模板参数。如果一个模板参数无法从构造函数的参数中推导出来，那么仍然需要显式地指定它。
必须有构造函数： CTAD 依赖于构造函数。如果一个类模板没有构造函数，那么就无法使用 CTAD。
类型推导可能不符合预期: 编译器可能会选择一个隐式转换后的类型，而不是你期望的类型。这时需要显式指定类型，或者使用推导指引来强制编译器选择正确的类型。

CTAD 的使用场景

CTAD 在很多场景下都非常有用，例如：

简化容器的创建： 可以使用 CTAD 来简化容器的创建，例如 std::vector、std::map 等。

std::vector vec = {1, 2, 3, 4, 5}; //  编译器推导出 vector<int>
std::map map = {{1, "one"}, {2, "two"}}; // 编译器推导出 map<int, const char*>

创建智能指针： 可以使用 CTAD 来创建智能指针，例如 std::shared_ptr、std::unique_ptr 等。

std::shared_ptr ptr = std::make_shared<int>(10); // 编译器推导出 shared_ptr<int>

创建自定义类模板： 可以使用 CTAD 来简化自定义类模板的创建。

CTAD 与 auto 的区别

很多人可能会把 CTAD 和 auto 搞混。它们虽然都可以让编译器自动推导类型，但它们的作用是不同的：

auto 用于推导变量的类型。
CTAD 用于推导类模板的模板参数。

例如：

auto x = 10; //  编译器推导出 x 的类型为 int
MyPair pair(10, 20); // 编译器推导出 MyPair 的模板参数 T 为 int

CTAD 的优势

代码更简洁： CTAD 可以减少代码中的冗余信息，使代码更简洁易懂。
可读性更高： CTAD 可以使代码更接近自然语言，提高代码的可读性。
减少错误： CTAD 可以减少手动指定模板参数时可能出现的错误。

CTAD 的劣势

类型推导可能不符合预期： 编译器可能会选择一个隐式转换后的类型，而不是你期望的类型。
调试困难： 如果类型推导出现问题，可能会比较难以调试。

总结

CTAD 是 C++17 中一个非常强大的特性，它可以简化类模板的实例化，使代码更简洁、更易读。但是，在使用 CTAD 时，也要注意它的限制，并根据实际情况选择是否使用 CTAD。

一些建议

优先使用 CTAD： 在可以使用 CTAD 的情况下，尽量使用 CTAD。
谨慎使用 CTAD： 如果类型推导可能不符合预期，或者调试比较困难，可以考虑显式地指定模板参数。
多做实验： 通过多做实验，可以更好地理解 CTAD 的工作原理，并掌握 CTAD 的使用技巧。

CTAD 的最佳实践

实践	描述	示例
默认构造函数参数推导	如果类模板有一个合适的构造函数，让编译器推导模板参数。	`cpp template <typename T> struct MyPair { T first; T second; MyPair(T f, T s) : first(f), second(s) {} }; MyPair pair1(10, 20); // 推导为 MyPair<int>`
推导指引解决类型歧义	使用推导指引显式指定推导规则，解决编译器可能面临多种推导结果的情况。	`cpp template <typename T> struct MyContainer { T* data; size_t size; template <typename U> MyContainer(U begin, U end) : data(new T[std::distance(begin, end))], size(std::distance(begin, end)) {} }; template <typename U> MyContainer(U begin, U end) -> MyContainer<typename std::iterator_traits<U>::value_type>; std::vector<int> vec = {1, 2, 3, 4, 5}; MyContainer container(vec.begin(), vec.end()); // 推导为 MyContainer<int>`
聚合类使用 CTAD	对于没有用户自定义构造函数的聚合类，CTAD 可以直接使用初始化列表进行推导。	`cpp template <typename T, typename U> struct Point { T x; U y; }; Point p1{10, 20}; // 推导为 Point<int, int> Point p2{3.14, 2}; // 推导为 Point<double, int>`
避免隐式类型转换带来的问题	当隐式类型转换可能导致非预期结果时，显式指定模板参数或使用推导指引。	`cpp template <typename T> struct Wrapper { T value; Wrapper(T v) : value(v) {} }; Wrapper w1(10); // 推导为 Wrapper<int> Wrapper w2{10.5f}; // 推导为Wrapper<float> // 如果期望是Wrapper<double>, 显式指定: Wrapper<double> w3{10.5f};`
容器初始化使用 CTAD	利用 CTAD 简化容器的创建，例如 `std::vector`, `std::map` 等。	`cpp std::vector vec = {1, 2, 3, 4, 5}; // 推导为 std::vector<int> std::map map = {{1, "one"}, {2, "two"}}; // 推导为 std::map<int, const char*>`
智能指针使用 CTAD	使用 CTAD 创建智能指针，如 `std::shared_ptr`, `std::unique_ptr`。	`cpp auto ptr = std::make_shared<int>(10); // 推导为 std::shared_ptr<int>`
自定义类型利用 CTAD	在自定义类模板中使用 CTAD，减少手动指定模板参数的冗余。	`cpp template <typename T> struct MyArray { T data[10]; MyArray(std::initializer_list<T> list) { /* ... */ } }; MyArray arr = {1, 2, 3}; // 推导为 MyArray<int>`
配合 `auto` 使用	CTAD 推导类模板参数，`auto` 推导变量类型，两者结合使用可以进一步简化代码。	`cpp auto pair = MyPair(10, 20); // CTAD 推导 MyPair<int>, auto 推导 pair 的类型为 MyPair<int>`
调试和错误处理	在类型推导出现问题时，使用编译器提供的诊断信息或手动指定类型进行调试。	`cpp // 编译器可能会推导出非期望的类型，这时需要检查构造函数的参数类型和隐式转换。 // 使用 static_assert 进行编译时类型检查: template <typename T> struct MyClass { static_assert(std::is_same_v<T, int>, "T must be int"); };`

总结

通过合理的运用 CTAD，可以让 C++ 代码更加简洁、易读，并减少错误。但同时也要注意 CTAD 的限制和潜在的问题，灵活运用显式类型指定和推导指引，才能写出高质量的 C++ 代码。

好了，今天的讲座就到这里。感谢各位观众老爷的收看！希望大家能够喜欢今天的节目，并能将 CTAD 应用到实际的开发中。

下次再见！

发表回复 取消回复

发表回复取消回复