std::pair::pair

来自cppreference.com

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

 
C++
 
实用工具库
类型的支持 (basic types, RTTI, type traits)
动态内存管理
错误处理
程序实用工具
可变参数函数
日期和时间
函数对象
initializer_list（C++11）
bitset
hash（C++11）
关系运算符
Original:
Relational operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rel_ops::operator!=
rel_ops::operator>
rel_ops::operator<=
rel_ops::operator>=
双和元组
Original:
Pairs and tuples
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pair
tuple（C++11）
piecewise_construct_t（C++11）
piecewise_construct（C++11）
掉期，远期和移动
Original:
Swap, forward and move
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
swap
forward（C++11）
move（C++11）
move_if_noexcept（C++11）
declval（C++11）
 
std::pair
成员函数
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pair::pair
pair::operator=
pair::swap
非成员函数
Original:
Non-member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
make_pair
operator=
operator!=
operator<
operator<=
operator>
operator>=
std::swap
get（C++11）
Helper类
Original:
Helper classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
tuple_size（C++11）
tuple_element（C++11）
 
pair();
constexpr pair();
 (1) （至 C++11）
（C++11 起）
pair( const T1& x, const T2& y );
 (2)
template< class U1, class U2 >
pair( U1&& x, U2&& y );
 (3) （C++11 起）
template< class U1, class U2 >
pair( const pair<U1,U2>& p );
 (4)
template< class U1, class U2 >
pair( pair<U1,U2>&& p );
 (5) （C++11 起）
template< class... Args1, class... Args2 >

pair( std::piecewise_construct_t,
      std::tuple<Args1...> first_args,

      std::tuple<Args2...> second_args );
 (6) （C++11 起）
pair( const pair& p ) = default;
 (7)
pair( pair&& p ) = default;
 (8) （C++11 起）


构造一个新的对.
Original:
Constructs a new pair.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
默认构造函数。值初始化的两个元素对，first和second.
Original:
Default constructor. Value-initializes both elements of the pair, first and second.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
初始化first与xsecondy.
Original:
Initializes first with x and second with y.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
初始化first与std::forward<U1>(x)secondstd::forward<U2>(y).
Original:
Initializes first with std::forward<U1>(x) and second with std::forward<U2>(y).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
初始化first与p.firstsecondp.second.
Original:
Initializes first with p.first and second with p.second.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
初始化first与std::move<U1>(p.first)secondstd::move<U2>(p.second).
Original:
Initializes first with std::move<U1>(p.first) and second with std::move<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.
6)
前锋first_args的构造函数first的元素，并转发second_argssecond的构造函数中的元素。这是唯一的非默认构造函数，可以用来创建一个对不可复制的非动产类型.
Original:
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 text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7)
拷贝构造函数是隐式产生的
Original:
Copy constructor is implicitly generated.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
移动构造函数隐式产生的
Original:
Move constructor is implicitly generated.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 参数

x -
这对的第一个元素的值来初始化
Original:
value to initialize the first element of this pair
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
y -
值初始化这对第二元件
Original:
value to initialize the second element of this pair
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
p -
对用于初始化这对两个元素的值
Original:
pair of values used to initialize both elements of this pair
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
first_args -
元组构造函数的参数，这对来初始化的第一个元素
Original:
tuple of constructor arguments to initialize the first element of this pair
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
second_args -
元组构造函数的参数，这对初始化第二个元素
Original:
tuple of constructor arguments to initialize the second element of this pair
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[编辑] 为例

#include <utility>
#include <string>
#include <complex>
#include <tuple>
#include <iostream>
int main()
{
    std::pair<int, float> p1;
    std::cout << "Value-initialized: "
              << p1.first << ", " << p1.second << '\n';
 
    std::pair<int, double> p2(42, 0.123);
    std::cout << "Initialized with two values: "
              << p2.first << ", " << p2.second << '\n';
 
    std::pair<char, int> p4(p2);
    std::cout << "Implicitly converted: "
              << p4.first << ", " << p4.second << '\n';
 
    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'));
    std::cout << "Piecewise constructed: "
              << p6.first << ", " << p6.second << '\n';
}

Output: 

Value-initialized: 0, 0
Initialized with two values: 42, 0.123
Implicitly converted: *, 0
Piecewise constructed: (0.123,7.7), aaaaaaaaaa

[编辑] 另请参阅
创建一个pair对象的类型，定义的参数类型
Original:
creates a pair object of 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.

（函数模板） [edit]
来自“http://zh.cppreference.com/mwiki/index.php?title=cpp/utility/pair/pair&oldid=26488”