73、C++ 元组（tuple）的全面解析

最新推荐文章于 2026-06-26 16:44:28 发布

原创最新推荐文章于 2026-06-26 16:44:28 发布 · 97 阅读

0 GEO检测

标签

#C++ # tuple # 元组

C++标准库深度解析与应用专栏收录该内容

100 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

C++ 元组（tuple）的全面解析

1. 元组相关函数与运算符

元组在 C++ 中是一种非常有用的工具，它允许将不同类型的值组合在一起。下面是一些与元组相关的函数和运算符的定义：

template<size_t I, class... Types>
constexpr const tuple_element_t<I, tuple<Types...>>&& get(const tuple<Types...>&&) noexcept;
template<class T, class... Types>
constexpr T& get(tuple<Types...>& t) noexcept;
template<class T, class... Types>
constexpr T&& get(tuple<Types...>&& t) noexcept;
template<class T, class... Types>
constexpr const T& get(const tuple<Types...>& t) noexcept;
template<class T, class... Types>
constexpr const T&& get(const tuple<Types...>&& t) noexcept;

这些 get 函数用于从元组中获取指定位置或指定类型的元素。

还有一些关系运算符，用于比较两个元组：

template<class... TTypes, class... UTypes>
constexpr bool operator==(const tuple<TTypes...>&, const tuple<UTypes...>&);
template<class... TTypes, class... UTypes>
constexpr bool operator!=(const tuple<TTypes...>&, const tuple<UTypes...>&);
template<class... TTypes, class... UTypes>
constexpr bool operator<(const tuple<TTypes...>&, const tuple<UTypes...>&);
template<class... TTypes, class... UTypes>
constexpr bool operator>(const tuple<TTypes...>&, const tuple<UTypes...>&);
template<class... TTypes, class... UTypes>
constexpr bool operator<=(const tuple<TTypes...>&, const tuple<UTypes...>&);
template<class... TTypes, class... UTypes>
constexpr bool operator>=(const tuple<TTypes...>&, const tuple<UTypes...>&);

另外，还有与分配器相关的特性和交换函数：

template<class... Types, class Alloc>
struct uses_allocator<tuple<Types...>, Alloc>;
template<class... Types>
constexpr void swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(see below );

2. 元组类模板

元组类模板 tuple 的定义如下：

namespace std {
template<class... Types>
class tuple {
public:
    // 构造函数
    constexpr explicit(see below ) tuple();
    constexpr explicit(see below ) tuple(const Types&...);
    template<class... UTypes>
    constexpr explicit(see below ) tuple(UTypes&&...);
    tuple(const tuple&) = default;
    tuple(tuple&&) = default;
    template<class... UTypes>
    constexpr explicit(see below ) tuple(const tuple<UTypes...>&);
    template<class... UTypes>
    constexpr explicit(see below ) tuple(tuple<UTypes...>&&);
    template<class U1, class U2>
    constexpr explicit(see below ) tuple(const pair<U1, U2>&);
    template<class U1, class U2>
    constexpr explicit(see below ) tuple(pair<U1, U2>&&);
    // 分配器扩展构造函数
    template<class Alloc>
    constexpr tuple(allocator_arg_t, const Alloc& a);
    template<class Alloc>
    constexpr explicit(see below )
    tuple(allocator_arg_t, const Alloc& a, const Types&...);
    template<class Alloc, class... UTypes>
    constexpr explicit(see below )
    tuple(allocator_arg_t, const Alloc& a, UTypes&&...);
    template<class Alloc>
    constexpr tuple(allocator_arg_t, const Alloc& a, const tuple&);
    template<class Alloc>
    constexpr tuple(allocator_arg_t, const Alloc& a, tuple&&);
    template<class Alloc, class... UTypes>
    constexpr explicit(see below )
    tuple(allocator_arg_t, const Alloc& a, const tuple<UTypes...>&);
    template<class Alloc, class... UTypes>
    constexpr explicit(see below )
    tuple(allocator_arg_t, const Alloc& a, tuple<UTypes...>&&);
    template<class Alloc, class U1, class U2>
    constexpr explicit(see below )
    tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
    template<class Alloc, class U1, class U2>
    constexpr explicit(see below )
    tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
    // 赋值运算符
    constexpr tuple& operator=(const tuple&);
    constexpr tuple& operator=(tuple&&) noexcept(see below );
    template<class... UTypes>
    constexpr tuple& operator=(const tuple<UTypes...>&);
    template<class... UTypes>
    constexpr tuple& operator=(tuple<UTypes...>&&);
    template<class U1, class U2>
    constexpr tuple& operator=(const pair<U1, U2>&);
    template<class U1, class U2>
    constexpr tuple& operator=(pair<U1, U2>&&);
    // 交换函数
    constexpr void swap(tuple&) noexcept(see below );
};
template<class... UTypes>
tuple(UTypes...) -> tuple<UTypes...>;
template<class T1, class T2>
tuple(pair<T1, T2>) -> tuple<T1, T2>;
template<class Alloc, class... UTypes>
tuple(allocator_arg_t, Alloc, UTypes...) -> tuple<UTypes...>;
template<class Alloc, class T1, class T2>
tuple(allocator_arg_t, Alloc, pair<T1, T2>) -> tuple<T1, T2>;
template<class Alloc, class... UTypes>
tuple(allocator_arg_t, Alloc, tuple<UTypes...>) -> tuple<UTypes...>;
}

3. 元组的构造

元组的构造有多种方式，并且每种构造方式都有其特定的要求和效果。
- 默认构造函数 ：

constexpr explicit(see below ) tuple();

效果是对每个元素进行值初始化。不过，这个构造函数只有在所有元素类型都可默认构造时才参与重载解析。
- 参数构造函数 ：

constexpr explicit(see below ) tuple(const Types&...);

用对应参数的值初始化每个元素。该构造函数要求元素类型可复制构造，且元素数量至少为 1。
- 移动和复制构造函数 ：

tuple(const tuple&) = default;
tuple(tuple&&) = default;

默认的移动和复制构造函数在所有元素的复制和移动初始化都满足 constexpr 要求时才是 constexpr 函数。
- 从其他元组构造 ：

template<class... UTypes>
constexpr explicit(see below ) tuple(const tuple<UTypes...>&);
template<class... UTypes>
constexpr explicit(see below ) tuple(tuple<UTypes...>&&);

这些构造函数用于从其他元组构造新的元组，有一定的类型和数量要求。
- 从 pair 构造 ：

template<class U1, class U2>
constexpr explicit(see below ) tuple(const pair<U1, U2>&);
template<class U1, class U2>
constexpr explicit(see below ) tuple(pair<U1, U2>&&);

当元组元素数量为 2 时，可以从 pair 构造元组。

分配器扩展构造函数要求分配器满足 Cpp17Allocator 要求，其效果与前面的构造函数类似，但每个元素使用分配器构造。

下面是一个简单的构造示例：

#include <iostream>
#include <tuple>

int main() {
    std::tuple<int, double> t1; // 默认构造
    std::tuple<int, double> t2(1, 2.0); // 参数构造
    std::tuple<int, double> t3(t2); // 复制构造
    return 0;
}

4. 元组的赋值

元组的赋值运算符也有多种，每个赋值运算符只有在对应元素类型的赋值操作不抛出异常时才不会抛出异常。
- 复制赋值运算符 ：

constexpr tuple& operator=(const tuple& u);

将 u 的每个元素赋值给 *this 的对应元素。该运算符只有在所有元素类型都可复制赋值时才有效。
- 移动赋值运算符 ：

constexpr tuple& operator=(tuple&& u) noexcept(see below );

将 u 的元素移动赋值给 *this 的对应元素。运算符参与重载解析要求所有元素类型可移动赋值， noexcept 表达式是所有元素类型的 is_nothrow_move_assignable_v 的逻辑与。
- 从其他元组赋值 ：

template<class... UTypes>
constexpr tuple& operator=(const tuple<UTypes...>& u);
template<class... UTypes>
constexpr tuple& operator=(tuple<UTypes...>&& u);

要求元素数量相等且对应元素类型可赋值。
- 从 pair 赋值 ：

template<class U1, class U2>
constexpr tuple& operator=(const pair<U1, U2>& u);
template<class U1, class U2>
constexpr tuple& operator=(pair<U1, U2>&& u);

当元组元素数量为 2 时，可从 pair 赋值。

5. 元组的交换

元组的交换函数如下：

constexpr void swap(tuple& rhs) noexcept(see below );

要求 *this 中的每个元素都能与 rhs 中的对应元素交换。交换操作是对每个元素调用 swap 函数， noexcept 表达式是所有元素类型的 is_nothrow_swappable_v 的逻辑与。

6. 元组创建函数

make_tuple ：

template<class... TTypes>
constexpr tuple<unwrap_ref_decay_t<TTypes>...> make_tuple(TTypes&&... t);

返回一个元组，元素类型经过 unwrap_ref_decay_t 处理。例如：

int i; float j;
auto t = std::make_tuple(1, std::ref(i), std::cref(j)); // 创建 tuple<int, int&, const float&>

forward_as_tuple ：

template<class... TTypes>
constexpr tuple<TTypes&&...> forward_as_tuple(TTypes&&... t) noexcept;

构造一个包含参数引用的元组，用于将参数转发给函数。要注意返回值不能比参数的生命周期长。
- tie ：

template<class... TTypes>
constexpr tuple<TTypes&...> tie(TTypes&... t) noexcept;

返回一个包含参数引用的元组。当参数中有 ignore 时，对对应元组元素赋值无效。例如：

int i; std::string s;
std::tie(i, std::ignore, s) = std::make_tuple(42, 3.14, "C++"); // i == 42, s == "C++"

tuple_cat ：

template<class... Tuples>
constexpr tuple<CTypes...> tuple_cat(Tuples&&... tpls);

将多个元组合并成一个元组。

下面是一个创建函数的示例：

#include <iostream>
#include <tuple>

int main() {
    auto t1 = std::make_tuple(1, 2.0);
    auto t2 = std::forward_as_tuple(3, 4.0);
    int a; double b;
    auto t3 = std::tie(a, b);
    auto t4 = std::tuple_cat(t1, t2);
    return 0;
}

以下是元组创建函数的流程图：

graph TD;
    A[开始] --> B[make_tuple];
    A --> C[forward_as_tuple];
    A --> D[tie];
    A --> E[tuple_cat];
    B --> F[返回处理后的元组];
    C --> G[返回引用元组];
    D --> H[返回引用元组];
    E --> I[返回合并后的元组];
    F --> J[结束];
    G --> J;
    H --> J;
    I --> J;

7. 用元组调用函数

apply ：

template<class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t);

将元组中的元素作为参数调用函数 f 。
- make_from_tuple ：

template<class T, class Tuple>
constexpr T make_from_tuple(Tuple&& t);

用元组中的元素构造类型 T 的对象。

8. 元组辅助类

tuple_size ：

template<class T> struct tuple_size;
template<class... Types>
class tuple_size<tuple<Types...>> : public integral_constant<size_t, sizeof...(Types)> { };

用于获取元组的大小。
- tuple_element ：

template<size_t I, class... Types>
class tuple_element<I, tuple<Types...>> {
public:
    using type = TI;
};

用于获取元组中指定位置元素的类型。

下面是一个辅助类的示例：

#include <iostream>
#include <tuple>

int main() {
    using T = std::tuple<int, double>;
    std::cout << std::tuple_size<T>::value << std::endl; // 输出 2
    using E = std::tuple_element<0, T>::type; // E 为 int
    return 0;
}

元组的这些功能和特性为 C++ 编程提供了强大的工具，能够方便地处理不同类型的数据组合和操作。通过合理使用元组，可以提高代码的灵活性和可读性。

功能	相关函数或类	作用
元素获取	`get`	从元组中获取指定位置或类型的元素
关系比较	关系运算符	比较两个元组
构造	各种构造函数	创建元组
赋值	赋值运算符	对元组进行赋值操作
交换	`swap`	交换两个元组的元素
创建	`make_tuple` 等	创建元组
调用函数	`apply` 等	用元组调用函数
辅助	`tuple_size` 等	提供元组的大小和元素类型信息

C++ 元组（tuple）的全面解析

9. 元组操作的详细要求与规则

在使用元组的各种操作时，有许多详细的要求和规则需要注意，以下是对一些关键操作的进一步说明：
- 构造函数异常处理 ：对于每个元组构造函数，只有当 Types 中的某个类型的构造抛出异常时，才会抛出异常。这意味着在构造元组时，我们可以根据元素类型的构造特性来预测构造过程中是否会出现异常。
- 默认移动和复制构造函数的 constexpr 特性 ：元组的默认移动和复制构造函数分别只有在所有元素的复制和移动初始化都满足 constexpr 要求时才是 constexpr 函数。对于空元组 tuple<> ，其默认的移动和复制构造函数总是 constexpr 函数。这为在编译时进行元组的构造提供了可能，提高了代码的性能。
- 析构函数的平凡性 ：如果所有元素类型 Ti 的 is_trivially_destructible_v<Ti> 为 true ，那么元组的析构函数是平凡的。这意味着在某些情况下，元组的析构不会有额外的开销。

10. 元组赋值操作的深入分析

元组的赋值操作也有其特定的规则和要求：
- 异常处理 ：对于每个元组赋值运算符，只有当 Types 中的某个类型的赋值抛出异常时，才会抛出异常。这与构造函数的异常处理规则类似，使得我们可以根据元素类型的赋值特性来预测赋值过程中是否会出现异常。
- 复制赋值运算符 ：

constexpr tuple& operator=(const tuple& u);

该运算符将 u 的每个元素赋值给 *this 的对应元素。但它只有在所有元素类型都可复制赋值时才会被定义，否则会被定义为删除的。这确保了在进行复制赋值操作时，元素类型是支持该操作的。
- 移动赋值运算符 ：

constexpr tuple& operator=(tuple&& u) noexcept(see below );

此运算符将 u 的元素移动赋值给 *this 的对应元素。它参与重载解析的前提是所有元素类型都可移动赋值。 noexcept 表达式是所有元素类型的 is_nothrow_move_assignable_v<Ti> 的逻辑与，这意味着只有当所有元素的移动赋值操作都不会抛出异常时，该运算符才是 noexcept 的。

11. 元组交换操作的要点

元组的交换操作 swap 有以下要点：

constexpr void swap(tuple& rhs) noexcept(see below );

要求： *this 中的每个元素都必须能与 rhs 中的对应元素交换。这确保了交换操作的可行性。
操作过程 ：交换操作是对每个元素调用 swap 函数。
异常处理 ： noexcept 表达式是所有元素类型的 is_nothrow_swappable_v<Ti> 的逻辑与。这意味着只有当所有元素的交换操作都不会抛出异常时，整个元组的交换操作才不会抛出异常。

12. 元组创建函数的使用场景

不同的元组创建函数适用于不同的场景：
- make_tuple ：适用于创建一个新的元组，元素类型会经过 unwrap_ref_decay_t 处理。它可以方便地将不同类型的值组合成一个元组，例如在需要临时创建一个包含多种类型元素的元组时使用。
- forward_as_tuple ：主要用于构造一个包含参数引用的元组，用于将参数转发给函数。在需要将参数以引用的形式传递给其他函数时，这个函数非常有用。但要注意返回值不能比参数的生命周期长，否则会导致悬空引用。
- tie ：用于创建一个包含参数引用的元组，并且可以使用 ignore 忽略某些元素。在需要将元组的元素解包到变量中，并且不需要某些元素时，可以使用 tie 函数。
- tuple_cat ：用于将多个元组合并成一个元组。当需要将多个元组的元素合并到一个元组中时，这个函数非常方便。

以下是一个更复杂的元组创建和操作示例：

#include <iostream>
#include <tuple>

int main() {
    int a = 1;
    double b = 2.0;
    auto t1 = std::make_tuple(a, b);
    auto t2 = std::forward_as_tuple(3, 4.0);
    int c; double d;
    auto t3 = std::tie(c, d);
    auto t4 = std::tuple_cat(t1, t2);

    std::cout << std::get<0>(t4) << " " << std::get<1>(t4) << " " << std::get<2>(t4) << " " << std::get<3>(t4) << std::endl;

    t3 = t4;
    std::cout << c << " " << d << std::endl;

    return 0;
}

13. 用元组调用函数的实际应用

apply 和 make_from_tuple 函数在实际编程中有很多应用场景：
- apply ：可以将元组中的元素作为参数调用函数。这在需要将元组的元素传递给一个函数时非常有用，例如在函数式编程中，可以使用 apply 函数将元组的元素作为参数传递给一个高阶函数。

#include <iostream>
#include <tuple>
#include <functional>

void printSum(int a, double b) {
    std::cout << a + b << std::endl;
}

int main() {
    auto t = std::make_tuple(1, 2.0);
    std::apply(printSum, t);
    return 0;
}

make_from_tuple ：可以用元组中的元素构造类型 T 的对象。这在需要根据元组的元素创建一个对象时非常方便，例如在工厂模式中，可以使用 make_from_tuple 函数根据元组的元素创建不同类型的对象。

#include <iostream>
#include <tuple>

struct Point {
    int x;
    int y;
    Point(int a, int b) : x(a), y(b) {}
};

int main() {
    auto t = std::make_tuple(1, 2);
    auto p = std::make_from_tuple<Point>(t);
    std::cout << p.x << " " << p.y << std::endl;
    return 0;
}

14. 元组辅助类的重要性

元组辅助类 tuple_size 和 tuple_element 为我们提供了关于元组的重要信息：
- tuple_size ：可以获取元组的大小，这在需要知道元组中元素数量时非常有用，例如在循环处理元组元素时，可以根据元组的大小来确定循环的次数。
- tuple_element ：可以获取元组中指定位置元素的类型，这在需要根据元素类型进行不同操作时非常有用，例如在模板编程中，可以根据元素类型来选择不同的处理逻辑。

以下是一个使用辅助类进行类型检查的示例：

#include <iostream>
#include <tuple>
#include <type_traits>

template<typename Tuple>
void checkElementTypes() {
    if constexpr (std::is_same_v<typename std::tuple_element<0, Tuple>::type, int>) {
        std::cout << "The first element is an int." << std::endl;
    } else {
        std::cout << "The first element is not an int." << std::endl;
    }
}

int main() {
    using T = std::tuple<int, double>;
    checkElementTypes<T>();
    return 0;
}

15. 总结

元组在 C++ 中是一个非常强大且灵活的工具，它允许我们将不同类型的值组合在一起，并且提供了丰富的操作和辅助类。通过合理使用元组的构造、赋值、交换、创建和调用函数等操作，以及利用辅助类提供的信息，我们可以提高代码的灵活性和可读性，同时也能更好地处理不同类型的数据组合。在实际编程中，我们应该根据具体的需求选择合适的元组操作和函数，以达到最佳的编程效果。

操作类型	关键要求	异常处理
构造	元素类型的构造特性	元素构造抛出异常时才抛出
赋值	元素类型的赋值特性	元素赋值抛出异常时才抛出
交换	元素可交换	元素交换抛出异常时才抛出

以下是元组操作的整体流程图：

graph TD;
    A[开始] --> B[构造元组];
    A --> C[赋值元组];
    A --> D[交换元组];
    A --> E[创建元组];
    A --> F[调用函数];
    B --> G{是否异常};
    C --> G;
    D --> G;
    E --> H[选择创建函数];
    F --> I[选择调用函数];
    H --> J[返回元组];
    I --> K[执行函数调用];
    G --> L{是};
    G --> M{否};
    L --> N[抛出异常];
    M --> O[操作成功];
    J --> O;
    K --> O;
    N --> P[结束];
    O --> P;

通过对元组的全面了解和掌握，我们可以在 C++ 编程中更加高效地处理复杂的数据结构和操作。