[ Web Proxy ]
URL:
Viewing: https://ru.cppreference.com/cpp/utility/tuple/tuple [Back]  [Original]
std::tuple::tuple cppreference.com
cppreference.com

std::tuple::tuple

cppreference.com
 
C++
(C++20)
(C++20)
(C++11)
(C++20)
/
(C++11)
(C++11)
(C++11)
(C++17)
 
(C++20)
(C++11)
( C++20)
(C++20)(C++20)(C++20)    
(C++20)
(C++20)
(C++14)
(C++11)
(C++23)
(C++11)
(C++23)
(C++11)
(C++11)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++11)
(C++17)
(C++17)
(C++23)
(C++17)
(C++17)
(C++17)
 
std::tuple
 
<tbody> </tbody>
constexpr tuple();
 (1) ( C++11)
(conditionally explicit)
tuple( const Types&... args );
 (2) ( C++11)
(constexpr since C++14)
(conditionally explicit)
template< class... UTypes > tuple( UTypes&&... args );
 (3) ( C++11)
(constexpr since C++14)
(conditionally explicit)
template< class... UTypes > constexpr tuple( tuple<UTypes...>& other );
 (4) ( C++23)
(conditionally explicit)
template< class... UTypes > tuple( const tuple<UTypes...>& other );
 (5) ( C++11)
(constexpr since C++14)
(conditionally explicit)
template< class... UTypes > tuple( tuple<UTypes...>&& other );
 (6) ( C++11)
(constexpr since C++14)
(conditionally explicit)
template< class... UTypes > constexpr tuple( const tuple<UTypes...>&& other );
 (7) ( C++23)
(conditionally explicit)
template< class U1, class U2 > constexpr tuple( std::pair<U1, U2>& p );
 (8) ( C++23)
(conditionally explicit)
template< class U1, class U2 > tuple( const std::pair<U1, U2>& p );
 (9) ( C++11)
(constexpr since C++14)
(conditionally explicit)
template< class U1, class U2 > tuple( std::pair<U1, U2>&& p );
 (10) ( C++11)
(constexpr since C++14)
(conditionally explicit)
template< class U1, class U2 > constexpr tuple( const std::pair<U1, U2>&& p );
 (11) ( C++23)
(conditionally explicit)
template< tuple-like UTuple > constexpr tuple( UTuple&& u );
 (12) ( C++23)
(conditionally explicit)
tuple( const tuple& other ) = default;
 (13) ( C++11)
tuple( tuple&& other ) = default;
 (14) ( C++11)
,
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a );
 (15) ( C++11)
(constexpr since C++20)
(conditionally explicit)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const Types&... args );
 (16) ( C++11)
(constexpr since C++20)
(conditionally explicit)
template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, UTypes&&... args );
 (17) ( C++11)
(constexpr since C++20)
(conditionally explicit)
template< class Alloc, class... UTypes > constexpr tuple( std::allocator_arg_t, const Alloc& a, tuple<UTypes...>& other );
 (18) ( C++23)
(conditionally explicit)
template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, const tuple<UTypes...>& other );
 (19) ( C++11)
(constexpr since C++20)
(conditionally explicit)
template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, tuple<UTypes...>&& other );
 (20) ( C++11)
(constexpr since C++20)
(conditionally explicit)
template< class Alloc, class... UTypes > constexpr tuple( std::allocator_arg_t, const Alloc& a, const tuple<UTypes...>&& other );
 (21) ( C++23)
(conditionally explicit)
template< class Alloc, class U1, class U2 > constexpr tuple( std::allocator_arg_t, const Alloc& a, std::pair<U1, U2>& p );
 (22) ( C++23)
(conditionally explicit)
template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, const std::pair<U1, U2>& p );
 (23) ( C++11)
(constexpr since C++20)
(conditionally explicit)
template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, std::pair<U1, U2>&& p );
 (24) ( C++11)
(constexpr since C++20)
(conditionally explicit)
template< class Alloc, class U1, class U2 > constexpr tuple( std::allocator_arg_t, const Alloc& a, const std::pair<U1, U2>&& p );
 (25) ( C++23)
(conditionally explicit)
template< class Alloc, tuple-like UTuple > constexpr tuple( std::allocator_arg_t, const Alloc& a, UTuple&& u );
 (26) ( C++23)
(conditionally explicit)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const tuple& other );
 (27) ( C++11)
(constexpr since C++20)
template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, tuple&& other );
 (28) ( C++11)
(constexpr since C++20)

tuple.

  • i [0, sizeof...(Types)) ,
  • Ti i- Types,
  • Ui i- UTypes,

.

1) . , . , sizeof...(Types) == 0.
  • , std::is_default_constructible<Ti>::value true i
  • explicit , Ti {} i.
2) . tuple .
  • , sizeof...(Types) >= 1 std::is_copy_constructible<Ti>::value true i.
  • explicit , std::is_convertible<const Ti&, Ti>::value false i.
3) . tuple std::forward<UTypes>(args).
  • ,
    • sizeof...(Types) == sizeof...(UTypes),
    • sizeof...(Types) >= 1,
    • std::is_constructible<Ti, Ui>::value true i,
    • D std::decay<U0>::type ( C++20)std::remove_cvref_t<U0> ( C++20),
  • explicit , std::is_convertible<Ui, Ti>::value false i.
  • , , , .
 ( C++23)
4-7) . tuple other.

FWD(other) std::forward<decltype(other)>(other), i i- std::get<i>(FWD(other)).

  • ,
    • sizeof...(Types) == sizeof...(UTypes)
    • std::is_constructible_v<Ti, decltype(std::get<i>(FWD(other)))> true i,
      • sizeof...(Types) 1
      • ( Types... T, UTypes... U) std::is_convertible_v<decltype(other), T>, std::is_constructible_v<T, decltype(other)> std::is_same_v<T, U> false.
  • explicit , std::is_convertible_v<decltype(std::get<i>(FWD(other))), Ti> false i.
  • , , , .
 ( C++23)
8-11) . tuple, p.

FWD(p) std::forward<decltype(p)>(p), std::get<0>(FWD(p)) std::get<1>(FWD(p)).

  • ,
    • sizeof...(Types) == 2,
    • std::is_constructible_v<T0, decltype(std::get<0>(FWD(p)))> true,
    • std::is_constructible_v<T1, decltype(std::get<1>(FWD(p)))> true
  • explicit , std::is_convertible_v<decltype(std::get<0>(FWD(p))), T0> std::is_convertible_v<decltype(std::get<1>(FWD(p))), T1> false.
  • , , , .
 ( C++23)
12) tuple-like. , f u.

i i- std::get<i>(std::forward<UTuple>(u)).

  • ,
    • 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_constructible_v<Ti, decltype(std::get<i>(std::forward<UTuple>(u)))> true i,
      • sizeof...(Types) 1,
      • ( Types... T) std::is_convertible_v<UTuple, T> std::is_constructible_v<T, UTuple> false.
13) . other.
  • constexpr, constexpr. std::tuple<>, constexpr.
  • std::is_copy_constructible<Ti>::value true i, ( C++20) ( C++20).
14) . i i- std::forward<Ui>(std::get<i>(other)).
  • constexpr, constexpr. std::tuple<> constexpr.
  • std::is_move_constructible<Ti>::value true i, ( C++20) ( C++20).
15-28) (1-14) , , , Allocator a , std::uses_allocator<Ui, Alloc>::value true.

args , tuple
other , tuple
p , tuple
u tuple-like,
a ,

- tuple , : 

std::tuple<int, int> foo_tuple() 
{
  return {1, -1};  //   N4387
  return std::make_tuple(1, -1); //  
}

, - tuple, : 

using namespace std::chrono;
void launch_rocket_at(std::tuple<hours, minutes, seconds>);

launch_rocket_at({hours(1), minutes(2), seconds(3)}); // OK
launch_rocket_at({1, 2, 3}); // : int     
launch_rocket_at(std::tuple<hours, minutes, seconds>{1, 2, 3}); // OK

#include <iomanip>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <vector>

//       
template<class Os, class T>
Os& operator<< (Os& os, std::vector<T> const& v)
{
    os << '{';
    for (auto i{v.size()}; const T& e : v)
        os << e << (--i ? "," : "");
    return os << '}';
}

template<class T>
void print_single(T const& v)
{
    if constexpr (std::is_same_v<T, std::decay_t<std::string>>)
        std::cout << std::quoted(v);
    else if constexpr (std::is_same_v<std::decay_t<T>, char>)
        std::cout << "'" << v << "'";
    else
        std::cout << v;
}

//     tuple  
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static void print(const Tuple& t)
    {
        TuplePrinter<Tuple, N-1>::print(t);
        std::cout << ", ";
        print_single(std::get<N-1>(t));
    }
};

template<class Tuple>
struct TuplePrinter<Tuple, 1>{
    static void print(const Tuple& t)
    {
        print_single(std::get<0>(t));
    }
};

template<class... Args>
void print(std::string_view message, const std::tuple<Args...>& t)
{
    std::cout << message << "(";
    TuplePrinter<decltype(t), sizeof...(Args)>::print(t);
    std::cout << ")\n";
}
//   

int main()
{
    std::tuple<int, std::string, double> t1;
    print(" , t1: ", t1);
    std::tuple<int, std::string, double> t2{42, "", -3.14};
    print(" , t2: ", t2);
    std::tuple<char, std::string, int> t3{t2};
    print(" , t3: ", t3);
    std::tuple<int, double> t4{std::make_pair(42, 3.14)};
    print("  pair, t4: ", t4);

    //   my_alloc     
    // my_alloc(int);  my_alloc(1)   5    
    using my_alloc = std::allocator<int>;
    std::vector<int, my_alloc> v { 5, 1, my_alloc{/*1*/}};
    //  my_alloc(2)   5      tuple
    std::tuple<int, std::vector<int, my_alloc>, double> t5
        {std::allocator_arg, my_alloc{/*2*/}, 42, v, -3.14};
    print("  , t5: ", t5);
}

: 

 , t1: (0, "", 0)
 , t2: (42, "Test", -3.14)
 , t3: ('*', "Test", -3)
  pair, t4: (42, 3.14)
  , t5: (42, {1,1,1,1,1}, -3.14)

C++:

LWG 2510 C++11 -
LWG 3121 C++11 1-tuple
; allocator_arg_t
LWG 3158 C++11 ,
, 		-
LWG 3211 C++11 , tuple<>
WG C++11 ,

-

tuple
(public -) []
(C++11)
 tuple ,
( ) []
tuple
( ) []
(C++11)
 tuple
( ) []
pair
(public - std::pair) []
Web Proxy Viewer  |  New URL  |  Original Page