◐ Shell clean mode source ↗

std::tuple::tuple – cppreference.com

Aus cppreference.com

<metanoindex/>

<tbody> </tbody>

definiert in Header `<tuple>`

`constexpr tuple();`	(1)	(seit C++11)

`explicit tuple( const Types&... args );`	(2)	(seit C++11)

`template< class... UTypes > explicit tuple( UTypes&&... args );`	(3)	(seit C++11)

`template< class... UTypes > tuple( const tuple<UTypes...>& other );`	(4)	(seit C++11)

`template <class... UTypes> tuple( tuple<UTypes...>&& other );`	(5)	(seit C++11)

`template< class U1, class U2 > tuple( const pair<U1,U2>& p );`	(6)	(seit C++11)

`template< class U1, class U2 > tuple( pair<U1,U2>&& p );`	(7)	(seit C++11)

`tuple( const tuple& other ) = default;`	(8)	(seit C++11)

`tuple( tuple&& other ) = default;`	(9)	(seit C++11)

`template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a );`	(10)	(seit C++11)

`template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const Types&... args );`	(11)	(seit C++11)

`template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, UTypes&&... args );`	(12)	(seit C++11)

`template <class Alloc, class... UTypes> tuple( std::allocator_arg_t, const Alloc& a, const tuple<UTypes...>& other );`	(13)	(seit C++11)

`template< class Alloc, class... UTypes > tuple( std::allocator_arg_t, const Alloc& a, tuple<UTypes...>&& other );`	(14)	(seit C++11)

`template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, const pair<U1, U2>& p );`	(15)	(seit C++11)

`template< class Alloc, class U1, class U2 > tuple( std::allocator_arg_t, const Alloc& a, pair<U1, U2>&& p );`	(16)	(seit C++11)

`template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, const tuple& other );`	(17)	(seit C++11)

`template< class Alloc > tuple( std::allocator_arg_t, const Alloc& a, tuple&& other );`	(18)	(seit C++11)

Erzeugt ein neues Tupel .

Original:

Constructs a new tuple.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

1)

Standardkonstruktor. Value-initialisiert alle Elemente .

Original:

Default constructor. Value-initializes all elements.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

2)

Initialisiert jedes Element des Tupels mit dem entsprechenden Parameter .

Original:

Initializes each element of the tuple with the corresponding parameter.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

3)

Initialisiert jedes Element des Tupels mit dem entsprechenden Wert in std::forward<Utypes>(args) .

Original:

Initializes each element of the tuple with the corresponding value in std::forward<Utypes>(args).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

4)

Für alle i in sizeof...(UTypes) initialisiert i-te Element des Tupels mit std::get<i>(other) .

Original:

For all i in sizeof...(UTypes), initializes ith element of the tuple with std::get<i>(other).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

5)

Für alle i in sizeof...(UTypes) initialisiert i-te Element des Tupels mit std::forward<Ui>(std::get<i>(other)) .

Original:

For all i in sizeof...(UTypes), initializes ith element of the tuple with std::forward<Ui>(std::get<i>(other)).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

6)

Konstruiert eine 2-Element-Tupels mit dem ersten Element aus p.first ausgebildet und dem zweiten Element aus p.second

Original:

Constructs a 2-element tuple with the first element constructed from p.first and the second element from p.second

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

7)

Konstruiert eine 2-Element-Tupels mit dem ersten Element aus std::forward<U1>(p.first) ausgebildet und dem zweiten Element aus std::forward<U2>(p.second)

Original:

Constructs a 2-element tuple with the first element constructed from std::forward<U1>(p.first) and the second element from std::forward<U2>(p.second)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

8)

Copykonstruktor Compiler generiert. Initialisiert jedes Element des Tupels mit dem entsprechenden Element other

Original:

Compiler-generated copy constructor. Initializes each element of the tuple with the corresponding element of other

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

9)

Move Konstruktor Compiler generiert. Initialisiert jedes i-te Element des Tupels mit std::forward<Ui>(std::get<i>(other)) .

Original:

Compiler-generated move constructor. Initializes each ith element of the tuple with std::forward<Ui>(std::get<i>(other)).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

10 - 18) Identisch mit 1-9 mit Ausnahme jedes Element wird durch uses-Allocator Bau, dh die Allocator Objekt a wird als zusätzliches Argument an den Konstruktor jedes Element, für das std::uses_allocator<Ui, Alloc>::value ist true weitergegeben erstellt .

Original:

10 - 18) Identical to 1-9 except each element is created by uses-allocator construction, that is, the Allocator object a is passed as an additional argument to the constructor of each element for which std::uses_allocator<Ui, Alloc>::value is true.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Parameter

args	-	Werte verwendet, um jedes Element des Tupels zu initialisieren Original: values used to initialize each element of the tuple The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
other	-	ein Tupel von Werten verwendet, um jedes Element des tupe initialisieren Original: a tuple of values used to initialize each element of the tupe The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
p	-	Wertepaar verwendet, um beide Elemente dieser 2-Tupel zu initialisieren Original: pair of values used to initialize both elements of this 2-tuple The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.
a	-	allocator in uses-Allocator Konstruktion verwenden Original: allocator to use in uses-allocator construction The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Beispiel

#include <iostream>
#include <string>
#include <vector>
#include <tuple>
#include <memory>

// helper function to print a tuple of any size
template<class Tuple, std::size_t N>
struct TuplePrinter {
    static void print(const Tuple& t) 
    {
        TuplePrinter<Tuple, N-1>::print(t);
        std::cout << ", " << std::get<N-1>(t);
    }
};

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

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

int main()
{
    std::tuple<int, std::string, double> t1;
    std::cout << "Value-initialized: "; print(t1);
    std::tuple<int, std::string, double> t2(42, "Test", -3.14);
    std::cout << "Initialized with values: "; print(t2);
    std::tuple<char, std::string, int> t3(t2);
    std::cout << "Implicitly converted: "; print(t3);
    std::tuple<int, double> t4(std::make_pair(42, 3.14));
    std::cout << "Constructed from a pair"; print(t4);

    // given Allocator my_alloc with a single-argument constructor my_alloc(int)
    // use my_alloc(1) to allocate 10 ints in a vector
    std::vector<int, my_alloc> v(10, 1, my_alloc(1));
    // use my_alloc(2) to allocate 10 ints in a vector in a tuple
    std::tuple<int, std::vector<int, my_alloc>, double> t5(std::allocator_arg,
                                                           my_alloc(2), 42, v,  -3.14);
}

Output:

Value-initialized: (0, , 0)
Initialized with values: (42, Test, -3.14)
Implicitly converted: (*, Test, -3)
Constructed from a pair(42, 3.14)

Siehe auch


make_tuple	erzeugt eine `tuple` Objekt des Typs von den Argumenttypen definiert Original: creates a `tuple` object of the type defined by the argument types The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Funktions-Template) [edit]

tie	erzeugt ein `tuple` aus lvalue Referenzen oder entpackt ein Tupel in einzelne Objekte Original: creates a `tuple` of lvalue references or unpacks a tuple into individual objects The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Funktions-Template) [edit]

forward_as_tuple	erzeugt ein `tuple` aus rvalue Referenzen Original: creates a `tuple` of rvalue references The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (Funktions-Template) [edit]