Skip to content

Commit c8f2cda

Browse files
philnik777philnik777
authored
[libc++] Simplify the implementation of std::get for pairs (#114984)
This makes it clearer what the functions actually do. As a nice side-effect it also avoids a function call. If the C++03 header split is successful we could drop `__get_pair` entirely.
1 parent 769c6a9 commit c8f2cda

File tree

2 files changed

+107
-62
lines changed

2 files changed

+107
-62
lines changed

‎libcxx/include/__utility/pair.h‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -654,42 +654,42 @@ get(const pair<_T1, _T2>&& __p) _NOEXCEPT {
654654
#if _LIBCPP_STD_VER >= 14
655655
template <class _T1, class _T2>
656656
inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT {
657-
return __get_pair<0>::get(__p);
657+
return __p.first;
658658
}
659659

660660
template <class _T1, class _T2>
661661
inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT {
662-
return __get_pair<0>::get(__p);
662+
return __p.first;
663663
}
664664

665665
template <class _T1, class _T2>
666666
inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
667-
return __get_pair<0>::get(std::move(__p));
667+
return std::forward<_T1&&>(__p.first);
668668
}
669669

670670
template <class _T1, class _T2>
671671
inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT {
672-
return __get_pair<0>::get(std::move(__p));
672+
return std::forward<_T1 const&&>(__p.first);
673673
}
674674

675-
template <class _T1, class _T2>
676-
inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T2, _T1>& __p) _NOEXCEPT {
677-
return __get_pair<1>::get(__p);
675+
template <class _T2, class _T1>
676+
inline _LIBCPP_HIDE_FROM_ABI constexpr _T2& get(pair<_T1, _T2>& __p) _NOEXCEPT {
677+
return __p.second;
678678
}
679679

680-
template <class _T1, class _T2>
681-
inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T2, _T1> const& __p) _NOEXCEPT {
682-
return __get_pair<1>::get(__p);
680+
template <class _T2, class _T1>
681+
inline _LIBCPP_HIDE_FROM_ABI constexpr _T2 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT {
682+
return __p.second;
683683
}
684684

685-
template <class _T1, class _T2>
686-
inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T2, _T1>&& __p) _NOEXCEPT {
687-
return __get_pair<1>::get(std::move(__p));
685+
template <class _T2, class _T1>
686+
inline _LIBCPP_HIDE_FROM_ABI constexpr _T2&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
687+
return std::forward<_T2&&>(__p.second);
688688
}
689689

690-
template <class _T1, class _T2>
691-
inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T2, _T1> const&& __p) _NOEXCEPT {
692-
return __get_pair<1>::get(std::move(__p));
690+
template <class _T2, class _T1>
691+
inline _LIBCPP_HIDE_FROM_ABI constexpr _T2 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT {
692+
return std::forward<_T2 const&&>(__p.second);
693693
}
694694

695695
#endif // _LIBCPP_STD_VER >= 14

‎libcxx/test/std/utilities/utility/pairs/pair.astuple/pairs.by.type.pass.cpp‎

Lines changed: 91 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -8,81 +8,126 @@
88

99
// UNSUPPORTED: c++03, c++11
1010

11-
#include <utility>
12-
#include <string>
13-
#include <type_traits>
11+
#include <cassert>
1412
#include <complex>
1513
#include <memory>
16-
17-
#include <cassert>
14+
#include <type_traits>
15+
#include <utility>
1816

1917
#include "test_macros.h"
2018

21-
int main(int, char**)
22-
{
23-
typedef std::complex<float> cf;
24-
{
25-
auto t1 = std::make_pair<int, cf> ( 42, { 1,2 } );
26-
assert ( std::get<int>(t1) == 42 );
27-
assert ( std::get<cf>(t1).real() == 1 );
28-
assert ( std::get<cf>(t1).imag() == 2 );
29-
}
19+
TEST_CONSTEXPR_CXX14 bool test() {
20+
{ // Make sure that references work as expected
21+
int i = 1;
22+
int j = 2;
3023

3124
{
32-
const std::pair<int, const int> p1 { 1, 2 };
33-
const int &i1 = std::get<int>(p1);
34-
const int &i2 = std::get<const int>(p1);
35-
assert ( i1 == 1 );
36-
assert ( i2 == 2 );
37-
}
25+
std::pair<int&, int&&> p(i, std::move(j));
26+
assert(&std::get<int&>(p) == &i);
27+
assert(&std::get<int&&>(p) == &j);
3828

39-
{
40-
typedef std::unique_ptr<int> upint;
41-
std::pair<upint, int> t(upint(new int(4)), 42);
42-
upint p = std::get<upint>(std::move(t)); // get rvalue
43-
assert(*p == 4);
44-
assert(std::get<upint>(t) == nullptr); // has been moved from
29+
assert(&std::get<int&>(std::move(p)) == &i);
30+
assert(std::get<int&&>(std::move(p)) == 2);
31+
32+
const std::pair<int&, int&&> cp(i, std::move(j));
33+
assert(&std::get<int&>(cp) == &i);
34+
assert(&std::get<int&&>(cp) == &j);
35+
36+
assert(&std::get<int&>(std::move(cp)) == &i);
37+
assert(std::get<int&&>(std::move(cp)) == 2);
4538
}
4639

4740
{
48-
typedef std::unique_ptr<int> upint;
49-
const std::pair<upint, int> t(upint(new int(4)), 42);
50-
static_assert(std::is_same<const upint&&, decltype(std::get<upint>(std::move(t)))>::value, "");
51-
static_assert(noexcept(std::get<upint>(std::move(t))), "");
52-
static_assert(std::is_same<const int&&, decltype(std::get<int>(std::move(t)))>::value, "");
53-
static_assert(noexcept(std::get<int>(std::move(t))), "");
54-
auto&& p = std::get<upint>(std::move(t)); // get const rvalue
55-
auto&& i = std::get<int>(std::move(t)); // get const rvalue
56-
assert(*p == 4);
57-
assert(i == 42);
58-
assert(std::get<upint>(t) != nullptr);
41+
std::pair<int&&, int&> p(std::move(i), j);
42+
assert(&std::get<int&>(p) == &j);
43+
assert(&std::get<int&&>(p) == &i);
44+
45+
assert(&std::get<int&>(std::move(p)) == &j);
46+
assert(std::get<int&&>(std::move(p)) == 1);
47+
48+
const std::pair<int&&, int&> cp(std::move(i), j);
49+
assert(&std::get<int&>(cp) == &j);
50+
assert(&std::get<int&&>(cp) == &i);
51+
52+
assert(&std::get<int&>(std::move(cp)) == &j);
53+
assert(std::get<int&&>(std::move(cp)) == 1);
5954
}
55+
}
6056

61-
{
62-
int x = 42;
57+
{
58+
typedef std::complex<float> cf;
59+
auto t1 = std::make_pair<int, cf>(42, {1, 2});
60+
assert(std::get<int>(t1) == 42);
61+
assert(std::get<cf>(t1).real() == 1);
62+
assert(std::get<cf>(t1).imag() == 2);
63+
}
64+
65+
{
66+
const std::pair<int, const int> p1{1, 2};
67+
const int& i1 = std::get<int>(p1);
68+
const int& i2 = std::get<const int>(p1);
69+
assert(i1 == 1);
70+
assert(i2 == 2);
71+
}
72+
73+
{
74+
int x = 42;
6375
int const y = 43;
6476
std::pair<int&, int const&> const p(x, y);
6577
static_assert(std::is_same<int&, decltype(std::get<int&>(std::move(p)))>::value, "");
6678
static_assert(noexcept(std::get<int&>(std::move(p))), "");
6779
static_assert(std::is_same<int const&, decltype(std::get<int const&>(std::move(p)))>::value, "");
6880
static_assert(noexcept(std::get<int const&>(std::move(p))), "");
69-
}
81+
}
7082

71-
{
72-
int x = 42;
83+
{
84+
int x = 42;
7385
int const y = 43;
7486
std::pair<int&&, int const&&> const p(std::move(x), std::move(y));
7587
static_assert(std::is_same<int&&, decltype(std::get<int&&>(std::move(p)))>::value, "");
7688
static_assert(noexcept(std::get<int&&>(std::move(p))), "");
7789
static_assert(std::is_same<int const&&, decltype(std::get<int const&&>(std::move(p)))>::value, "");
7890
static_assert(noexcept(std::get<int const&&>(std::move(p))), "");
79-
}
91+
}
8092

81-
{
82-
constexpr const std::pair<int, const int> p { 1, 2 };
93+
{
94+
constexpr const std::pair<int, const int> p{1, 2};
8395
static_assert(std::get<int>(std::move(p)) == 1, "");
8496
static_assert(std::get<const int>(std::move(p)) == 2, "");
85-
}
97+
}
98+
99+
return true;
100+
}
101+
102+
int main(int, char**) {
103+
test();
104+
#if TEST_STD_VER >= 14
105+
static_assert(test(), "");
106+
#endif
107+
108+
// These tests use types which only work during constant evaluation in very recent standards
109+
110+
{
111+
typedef std::unique_ptr<int> upint;
112+
std::pair<upint, int> t(upint(new int(4)), 42);
113+
upint p = std::get<upint>(std::move(t)); // get rvalue
114+
assert(*p == 4);
115+
assert(std::get<upint>(t) == nullptr); // has been moved from
116+
}
117+
118+
{
119+
typedef std::unique_ptr<int> upint;
120+
const std::pair<upint, int> t(upint(new int(4)), 42);
121+
static_assert(std::is_same<const upint&&, decltype(std::get<upint>(std::move(t)))>::value, "");
122+
static_assert(noexcept(std::get<upint>(std::move(t))), "");
123+
static_assert(std::is_same<const int&&, decltype(std::get<int>(std::move(t)))>::value, "");
124+
static_assert(noexcept(std::get<int>(std::move(t))), "");
125+
auto&& p = std::get<upint>(std::move(t)); // get const rvalue
126+
auto&& i = std::get<int>(std::move(t)); // get const rvalue
127+
assert(*p == 4);
128+
assert(i == 42);
129+
assert(std::get<upint>(t) != nullptr);
130+
}
86131

87132
return 0;
88133
}

0 commit comments

Comments
 (0)