std::tuple<Types...>::operator=
来自 cppreference.com
tuple& operator=( const tuple& other ); |
(1) | (自 C++11 起) (自 C++20 起为 constexpr) |
constexpr const tuple& operator=( const tuple& other ) const; |
(2) | (自 C++23 起) |
tuple& operator=( tuple&& other ) noexcept(/* see below */); |
(3) | (自 C++11 起) (自 C++20 起为 constexpr) |
constexpr const tuple& operator=( tuple&& other ) const; |
(4) | (自 C++23 起) |
template< class... UTypes > tuple& operator=( const tuple<UTypes...>& other ); |
(5) | (自 C++11 起) (自 C++20 起为 constexpr) |
template< class... UTypes > constexpr const tuple& operator=( const tuple<UTypes...>& other ) const; |
(6) | (自 C++23 起) |
template< class... UTypes > tuple& operator=( tuple<UTypes...>&& other ); |
(7) | (自 C++11 起) (自 C++20 起为 constexpr) |
template< class... UTypes > constexpr const tuple& operator=( tuple<UTypes...>&& other ) const; |
(8) | (自 C++23 起) |
template< class E1, class E2 > tuple& operator=( const std::pair<E1, E2>& p ); |
(9) | (自 C++11 起) (自 C++20 起为 constexpr) |
template< class E1, class E2 > constexpr const tuple& operator=( const std::pair<E1, E2>& p ) const; |
(10) | (自 C++23 起) |
template< class E1, class E2 > tuple& operator=( std::pair<E1, E2>&& p ); |
(11) | (自 C++11 起) (自 C++20 起为 constexpr) |
template< class E1, class E2 > constexpr const tuple& operator=( std::pair<E1, E2>&& p ) const; |
(12) | (自 C++23 起) |
template< tuple-like UTuple > constexpr tuple& operator=( UTuple&& u ); |
(13) | (自 C++23 起) |
template< tuple-like UTuple > constexpr const tuple& operator=( UTuple&& u ) const; |
(14) | (自 C++23 起) |
将元组的内容替换为另一个元组类对象的内容。
在以下描述中,令
- i 在范围内
[
0,
sizeof...(Types))
中按顺序排列, -
Ti
是类模板参数包Types
中的第i
个类型,以及 -
Ui
是函数模板参数包UTypes
中的第i
个类型,
其中索引从零开始。
1) 复制赋值运算符。将 other 的每个元素分配给 *this 的相应元素。
2) 用于 const 限定操作数的复制赋值运算符。将 other 的每个元素分配给 *this 的相应元素。
5) 对于所有i,将std::get<i>(other)赋值给std::get<i>(*this)。
此重载仅在sizeof...(Types) == sizeof...(UTypes),以及对于所有对应类型对
Ti
和Ui
,std::is_assignable<Ti&, const Ui&>::value为true时才参与重载解析。6) 对于所有i,将std::get<i>(other)赋值给std::get<i>(*this)。
此重载仅在sizeof...(Types) == sizeof...(UTypes),以及对于所有对应类型对
Ti
和Ui
,std::is_assignable_v<const Ti&, const Ui&>为true时才参与重载解析。 此重载仅在sizeof...(Types) == sizeof...(UTypes),以及对于所有对应类型对
Ti
和Ui
,std::is_assignable<Ti&, Ui>::value为true时才参与重载解析。 此重载仅在sizeof...(Types) == sizeof...(UTypes),以及对于所有对应类型对
Ti
和Ui
,std::is_assignable_v<const Ti&, Ui>为true时才参与重载解析。9) 将p.first赋值给*this的第一个元素,并将p.second赋值给*this的第二个元素。
此重载仅在
- sizeof...(Types) == 2,
- std::is_assignable<T0&, const E1&>::value为true,以及
- std::is_assignable<T1&, const E2&>::value为true时才参与重载解析。
10) 将p.first赋值给第一个元素,并将p.second赋值给第二个元素。
此重载仅在
- sizeof...(Types) == 2,
- std::is_assignable_v<const T0&, const E1&>为true,以及
- std::is_assignable_v<const T1&, const E2&>为true时才参与重载解析。
此重载仅在
- sizeof...(Types) == 2,
- std::is_assignable_v<T0&, E1>为true,以及
- std::is_assignable_v<T1&, E2>为true时才参与重载解析。
此重载仅在
- sizeof...(Types) == 2,
- std::is_assignable_v<const T0&, E1>为true,以及
- std::is_assignable_v<const T1&, E2>为true时才参与重载解析。
此重载仅在
- std::same_as<std::remove_cvref_t<UTuple>, std::tuple>为false,
- std::remove_cvref_t<UTuple>不是std::ranges::subrange的特化,
- sizeof...(Types) 等于 std::tuple_size_v<std::remove_cvref_t<UTuple>>,并且
- std::is_assignable_v<Ti&, decltype(std::get<i>(std::forward<UTuple>(u)))> 为所有 i 都是 true。
此重载仅在
- std::same_as<std::remove_cvref_t<UTuple>, std::tuple>为false,
- std::remove_cvref_t<UTuple>不是std::ranges::subrange的特化,
- sizeof...(Types) 等于 std::tuple_size_v<std::remove_cvref_t<UTuple>>,并且
- std::is_assignable_v<const Ti&, decltype(std::get<i>(std::forward<UTuple>(u)))> 为所有 i 都是 true。
内容 |
[编辑] 参数
other | - | 要替换此元组内容的元组 |
p | - | 要替换此 2 元组内容的配对 |
u | - | 元组式 对象,用于替换此元组的内容 |
[编辑] 返回值
*this
[编辑] 异常
1,2) 如果
Types
中的某个类型的赋值抛出异常,则可能会抛出实现定义的异常。3)
noexcept 规范:
noexcept(
std::is_nothrow_move_assignable<T0>::value &&
std::is_nothrow_move_assignable<T1>::value &&
std::is_nothrow_move_assignable<T2>::value &&
...
4-14) 如果
Types
中的某个类型的赋值抛出异常,则可能会抛出实现定义的异常。[编辑] 示例
运行此代码
#include <iostream> #include <string> #include <string_view> #include <tuple> #include <utility> #include <vector> // helper function to print std::vector<int> std::ostream& operator<<(std::ostream& os, std::vector<int> const& v) { os << '{'; for (std::size_t t = 0; t != v.size(); ++t) os << v[t] << (t + 1 < v.size() ? ", " : ""); return os << '}'; } // helpers to print a tuple of any size template<class... Args> void print_tuple(std::string_view name, const std::tuple<Args...>& t) { std::cout << name << " = {"; std::apply([&](auto&& arg, auto&&... args) { std::cout << arg; ((std::cout << ", " << args), ...); }, t); std::cout << '}'; } template<class Tuple1, class Tuple2> void print_tuples(std::string_view name1, const Tuple1& t1, std::string_view name2, const Tuple2& t2) { print_tuple(name1, t1); std::cout << ", "; print_tuple(name2, std::tuple(t2)); std::cout << "\n\n"; } int main() { // Tuple to tuple examples // std::tuple<int, std::string, std::vector<int>> t1{1, "alpha", {1, 2, 3}}, t2{2, "beta", {4, 5}}; print_tuples("1) t1", t1, "t2", t2); // Normal copy assignment // operator=( const tuple& other ); t1 = t2; print_tuples("2) t1 = t2;\n t1", t1, "t2", t2); // Normal move assignment // operator=( tuple&& other ); t1 = std::move(t2); print_tuples("3) t1 = std::move(t2);\n t1", t1, "t2", t2); // Converting copy assignment // operator=( const tuple<UTypes...>& other ); std::tuple<short, const char*, std::vector<int>> t3{3, "gamma", {6, 7, 8}}; t1 = t3; print_tuples("4) t1 = t3;\n t1", t1, "t3", t3); // Converting move assignment // operator=( tuple<UTypes...>&& other ); t1 = std::move(t3); print_tuples("5) t1 = std::move(t3);\n t1", t1, "t3", t3); // Pair to tuple examples // std::tuple<std::string, std::vector<int>> t4{"delta", {10, 11, 12}}; std::pair<const char*, std::vector<int>> p1{"epsilon", {14, 15, 16}}; print_tuples("6) t4", t4, "p1", p1); // Converting copy assignment from std::pair // operator=( const std::pair<U1, U2>& p ); t4 = p1; print_tuples("7) t4 = p1;\n t4", t4, "p1", p1); // Converting move assignment from std::pair // operator=( std::pair<U1, U2>&& p ); t4 = std::move(p1); print_tuples("8) t4 = std::move(p1);\n t4", t4, "p1", p1); }
可能的输出
1) t1 = {1, alpha, {1, 2, 3}}, t2 = {2, beta, {4, 5}} 2) t1 = t2; t1 = {2, beta, {4, 5}}, t2 = {2, beta, {4, 5}} 3) t1 = std::move(t2); t1 = {2, beta, {4, 5}}, t2 = {2, , {}} 4) t1 = t3; t1 = {3, gamma, {6, 7, 8}}, t3 = {3, gamma, {6, 7, 8}} 5) t1 = std::move(t3); t1 = {3, gamma, {6, 7, 8}}, t3 = {3, gamma, {}} 6) t4 = {delta, {10, 11, 12}}, p1 = {epsilon, {14, 15, 16}} 7) t4 = p1; t4 = {epsilon, {14, 15, 16}}, p1 = {epsilon, {14, 15, 16}} 8) t4 = std::move(p1); t4 = {epsilon, {14, 15, 16}}, p1 = {epsilon, {}}
[编辑] 缺陷报告
以下行为更改缺陷报告已追溯应用于先前发布的 C++ 标准。
DR | 应用于 | 已发布的行为 | 正确行为 |
---|---|---|---|
LWG 2729 | C++11 | operator= 未受约束,并且可能 导致不必要的未定义行为 |
受约束 |
[编辑] 参见
构造新的 tuple (公共成员函数) | |
分配内容 ( std::pair<T1,T2> 的公共成员函数) |