RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../algorithm/../utility/pair/pair.html below:

std::pair<T1,T2>::pair - cppreference.com

pair();

(1) (constexpr since C++11)
(conditionally explicit since C++11)

pair( const T1& x, const T2& y );

(2) (conditionally explicit since C++11)
(constexpr since C++14) (3)

template< class U1, class U2 > pair( U1&& x, U2&& y );

(since C++11)
(until C++23)
(constexpr since C++14)
(conditionally explicit)

template< class U1 = T1, class U2 = T2 > constexpr pair( U1&& x, U2&& y );

(since C++23)
(conditionally explicit)

template< class U1, class U2 > constexpr pair( pair<U1, U2>& p );

(4) (since C++23)
(conditionally explicit)

template< class U1, class U2 > pair( const pair<U1, U2>& p );

(5) (conditionally explicit since C++11)
(constexpr since C++14)

template< class U1, class U2 > pair( pair<U1, U2>&& p );

(6) (constexpr since C++14)
(conditionally explicit since C++11)

template< class U1, class U2 > constexpr pair( const pair<U1, U2>&& p );

(7) (since C++23)
(conditionally explicit)

template< pair-like P > constexpr pair ( P&& u );

(8) (since C++23)
(conditionally explicit) (9) (since C++11)
(constexpr since C++20)

pair( const pair& p ) = default;

(10)

pair( pair&& p ) = default;

(11) (since C++11)

Constructs a new pair.

1)

Default constructor. Value-initializes both elements of the pair,

first

and

second

2)

Initializes

first

with

x

and

second

with

y

4) Initializes first with p.first and second with p.second.

This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

5)

Initializes

first

with

p.first

and

second

with

p.second

This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

(since C++23)

This constructor is

explicit

if and only if

std::is_convertible_v<U1, T1>

false

std::is_convertible_v<U2, T2>

false

This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

(since C++23)

This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

8)

Given

u1

std::get<0>(std::forward(u))

and

u2

std::get<1>(std::forward(u))

, denote their types as

U1

and

U2

respectively. Initializes

first

with

u1

and

second

with

u2

This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

9) Forwards the elements of first_args to the constructor of first and forwards the elements of second_args to the constructor of second. This is the only non-default constructor that can be used to create a pair of non-copyable non-movable types. The program is ill-formed if first or second is a reference and bound to a temporary object.

10) Copy constructor is implicitly declared(until C++11)defaulted, and is constexpr if copying of both elements satisfies the requirements on constexpr functions(since C++11).

11) Move constructor is defaulted, and is constexpr if moving of both elements satisfies the requirements on constexpr functions.

[edit] Parameters x - value to initialize the first element of this pair y - value to initialize the second element of this pair p - pair of values used to initialize both elements of this pair u - pair-like object of values used to initialize both elements of this pair first_args - tuple of constructor arguments to initialize the first element of this pair second_args - tuple of constructor arguments to initialize the second element of this pair [edit] Exceptions

Does not throw exceptions unless one of the specified operations (e.g. constructor of an element) throws.

[edit] Example

#include <complex>
#include <iostream>
#include <string>
#include <tuple>
#include <utility>
 
int main()
{
    auto print = [](auto rem, auto const& pair)
    {
        std::cout << rem << "(" << pair.first << ", " << pair.second << ")\n";
    };
 
    std::pair<int, float> p1;
    print("(1) Value-initialized: ", p1);
 
    std::pair<int, double> p2{42, 3.1415};
    print("(2) Initialized with two values: ", p2);
 
    std::pair<char, int> p4{p2};
    print("(4) Implicitly converted: ", p4);
 
    std::pair<std::complex<double>, std::string> p6
        {std::piecewise_construct, std::forward_as_tuple(0.123, 7.7),
            std::forward_as_tuple(10, 'a')};
    print("(8) Piecewise constructed: ", p6);
}

Possible output:

(1) Value-initialized: (0, 0)
(2) Initialized with two values: (42, 3.1415)
(4) Implicitly converted: (*, 3)
(8) Piecewise constructed: ((0.123,7.7), aaaaaaaaaa)

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR Applied to Behavior as published Correct behavior LWG 265 C++98 the default constructor copy-initialized first
and second with T1() and T2() respectively
(thus required T1 and T2 to be CopyConstructible) first and second
are value-initialized LWG 2510 C++11 the default constructor was implicit made conditionally-explicit N4387 C++11 some constructors were implicit-only, preventing some uses constructors made conditionally-explicit [edit] See also creates a pair object of type, determined by the argument types
(function template) [edit] constructs a new tuple
(public member function of std::tuple<Types...>) [edit]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4