C++23 新特性：为 std::pair 的转发构造函数添加默认实参

文章目录

• • [1\. 背景：`std::pair` 的转发构造函数](#1. 背景：std::pair 的转发构造函数)
  • [2\. C++23 的改进：添加默认实参](#2. C++23 的改进：添加默认实参)
  • • 示例代码
  • [3\. 带来的好处](#3. 带来的好处)
  • • [3.1 更简洁的代码](#3.1 更简洁的代码)
    • [3.2 提高代码的可维护性](#3.2 提高代码的可维护性)
    • [3.3 与 `std::optional` 和 `std::variant` 的协同](#3.3 与 std::optional 和 std::variant 的协同)
  • [4\. 实现细节](#4. 实现细节)
  • • 示例实现（简化版）
  • [5\. 使用场景](#5. 使用场景)
  • • [5.1 初始化列表](#5.1 初始化列表)
    • [5.2 模板编程](#5.2 模板编程)
  • [6\. 注意事项](#6. 注意事项)
  • • [6.1 默认构造的限制](#6.1 默认构造的限制)
    • [6.2 与旧代码的兼容性](#6.2 与旧代码的兼容性)
  • [7\. 总结](#7. 总结)

在 C++ 的发展历程中， std::pair 一直是标准库中一个非常实用的工具，用于组合两个不同类型的数据。然而，随着 C++23 的到来， std::pair 的功能得到了进一步增强，特别是其转发构造函数现在支持默认实参。这一改进不仅提升了代码的灵活性，还让 std::pair 的使用更加便捷。本文将详细介绍这一特性及其带来的好处。

1. 背景：std::pair 的转发构造函数

在 C++11 中，std::pair 引入了转发构造函数，允许通过完美转发的方式构造 std::pair 的成员。这使得 std::pair 能够高效地处理不同类型和值类别（左值、右值）的参数。例如：

#include <utility>
#include <iostream>
#include <string>

int main() {
    std::string str = "Hello";
    std::pair<std::string, int> p1(str, 42); // 左值绑定
    std::pair<std::string, int> p2(std::move(str), 42); // 右值绑定
    std::cout << p1.first << ", " << p1.second << std::endl;
    std::cout << p2.first << ", " << p2.second << std::endl;
}

在上述代码中，std::pair 的转发构造函数能够根据传入的参数类型（左值或右值），完美地转发给成员变量的构造函数，从而避免不必要的拷贝或移动操作。

然而，C++23 之前，std::pair 的转发构造函数有一个限制：它不能直接构造默认值。例如，如果想要构造一个 std::pair，其中第一个成员是默认构造的，而第二个成员是显式提供的，就需要手动调用默认构造函数，代码显得冗长且不够直观。

2. C++23 的改进：添加默认实参

在 C++23 中，std::pair 的转发构造函数得到了扩展，支持默认实参。这意味着我们可以更灵活地构造 std::pair，而无需显式提供所有成员的值。具体来说，如果某个成员的值没有被显式提供，std::pair 会自动使用该成员类型的默认构造函数来初始化它。

示例代码

#include <utility>
#include <iostream>
#include <string>

int main() {
    // 构造一个 std::pair，其中第一个成员是默认构造的
    std::pair<std::string, int> p1; // 等价于 std::pair<std::string(), int()>

    // 构造一个 std::pair，其中第一个成员是默认构造的，第二个成员是显式提供的
    std::pair<std::string, int> p2(42); // 等价于 std::pair<std::string(), 42>

    // 构造一个 std::pair，其中第一个成员是显式提供的，第二个成员是默认构造的
    std::pair<std::string, int> p3("Hello"); // 等价于 std::pair{"Hello", int()}

    std::cout << "p1: " << p1.first << ", " << p1.second << std::endl;
    std::cout << "p2: " << p2.first << ", " << p2.second << std::endl;
    std::cout << "p3: " << p3.first << ", " << p3.second << std::endl;
}

在上述代码中：

• p1 的两个成员都是默认构造的。
• p2 的第一个成员是默认构造的，第二个成员是显式提供的。
• p3 的第一个成员是显式提供的，第二个成员是默认构造的。

这种改进使得 std::pair 的构造更加灵活，同时也减少了代码的冗余。

3. 带来的好处

3.1 更简洁的代码

通过支持默认实参，std::pair 的构造变得更加简洁。开发者无需显式调用默认构造函数，代码更加直观易读。

3.2 提高代码的可维护性

在复杂的数据结构中，std::pair 的这种改进可以减少因遗漏默认构造而导致的错误。例如，在模板编程中，这种特性可以显著简化代码逻辑。

3.3 与 std::optional 和 std::variant 的协同

std::pair 的这一改进与 C++17 中引入的 std::optional 和 C++11 中的 std::variant 协同工作得更好。例如，std::optional<std::pair<T1, T2>> 现在可以更自然地处理默认值。

4. 实现细节

C++23 的这一改进是通过扩展 std::pair 的构造函数模板来实现的。具体来说，std::pair 的构造函数模板现在支持默认参数，这使得编译器能够根据提供的参数数量和类型，自动推导出成员的初始化方式。

示例实现（简化版）

template <typename T1, typename T2>
struct pair {
    T1 first;
    T2 second;

    template <typename U1 = T1, typename U2 = T2>
    pair(U1&& u1 = T1(), U2&& u2 = T2())
        : first(std::forward<U1>(u1)), second(std::forward<U2>(u2)) {}
};

在上述实现中，构造函数模板的默认参数允许 std::pair 的成员在没有显式提供值时，自动使用默认构造函数进行初始化。

5. 使用场景

5.1 初始化列表

在初始化列表中，std::pair 的默认实参特性可以显著简化代码。例如：

std::vector<std::pair<std::string, int>> vec = {
    {"Alice", 25},
    {"Bob", 30},
    {}, // 默认构造
    {"Charlie"} // 第二个成员默认构造
};

在上述代码中，std::pair 的默认构造和部分默认构造被自然地支持。

5.2 模板编程

在模板编程中，std::pair 的默认实参特性可以减少模板特化的复杂性。例如，当模板函数需要构造一个 std::pair 时，可以更自然地处理默认值。

template <typename T1, typename T2>
std::pair<T1, T2> make_pair_with_default(T1 t1 = T1(), T2 t2 = T2()) {
    return {t1, t2};
}

在上述代码中，make_pair_with_default 函数可以自然地处理默认值，而无需额外的模板特化。

6. 注意事项

6.1 默认构造的限制

虽然 std::pair 的转发构造函数支持默认实参，但默认构造仍然依赖于成员类型的默认构造函数。如果成员类型没有默认构造函数，则无法使用默认实参。

6.2 与旧代码的兼容性

在将代码升级到 C++23 时，需要注意 std::pair 的默认实参特性可能会影响旧代码的行为。特别是当旧代码依赖于 std::pair 的特定构造方式时，需要仔细检查。

7. 总结

C++23 为 std::pair 的转发构造函数添加默认实参，这一改进显著提升了 std::pair 的灵活性和易用性。通过支持默认实参，std::pair 的构造变得更加简洁，同时也减少了代码的冗余和潜在错误。这一特性不仅适用于简单的数据结构，还与模板编程、std::optional 和 std::variant 等高级特性协同工作得更好。
: C++23 Proposal P2718R0
: C++23 Features Overview
: C++23 Improvements in the Standard Library
: C++23 and std::optional
: C++23 and std::variant