Skip to content

Commit d286f2e

Browse files
vinay-deshmukhvinay-deshmukh
authored
[libc++] Make std::__tree_node member private to prepare for UB removal (#154225)
Prepare for: #153908 (comment)
1 parent ccbcebc commit d286f2e

File tree

3 files changed

+64
-56
lines changed

3 files changed

+64
-56
lines changed

‎libcxx/include/__tree‎

Lines changed: 51 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -582,8 +582,10 @@ class _LIBCPP_STANDALONE_DEBUG __tree_node : public __tree_node_base<_VoidPtr> {
582582
public:
583583
using __node_value_type _LIBCPP_NODEBUG = __get_node_value_type_t<_Tp>;
584584

585+
private:
585586
__node_value_type __value_;
586587

588+
public:
587589
_LIBCPP_HIDE_FROM_ABI __node_value_type& __get_value() { return __value_; }
588590

589591
~__tree_node() = delete;
@@ -614,7 +616,7 @@ public:
614616

615617
_LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
616618
if (__value_constructed)
617-
__alloc_traits::destroy(__na_, std::addressof(__p->__value_));
619+
__alloc_traits::destroy(__na_, std::addressof(__p->__get_value()));
618620
if (__p)
619621
__alloc_traits::deallocate(__na_, __p, 1);
620622
}
@@ -650,8 +652,10 @@ public:
650652

651653
_LIBCPP_HIDE_FROM_ABI __tree_iterator() _NOEXCEPT : __ptr_(nullptr) {}
652654

653-
_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__value_; }
654-
_LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__value_); }
655+
_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__get_value(); }
656+
_LIBCPP_HIDE_FROM_ABI pointer operator->() const {
657+
return pointer_traits<pointer>::pointer_to(__get_np()->__get_value());
658+
}
655659

656660
_LIBCPP_HIDE_FROM_ABI __tree_iterator& operator++() {
657661
__ptr_ = std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_));
@@ -712,8 +716,10 @@ public:
712716

713717
_LIBCPP_HIDE_FROM_ABI __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
714718

715-
_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__value_; }
716-
_LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__value_); }
719+
_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__get_value(); }
720+
_LIBCPP_HIDE_FROM_ABI pointer operator->() const {
721+
return pointer_traits<pointer>::pointer_to(__get_np()->__get_value());
722+
}
717723

718724
_LIBCPP_HIDE_FROM_ABI __tree_const_iterator& operator++() {
719725
__ptr_ = std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_));
@@ -1226,7 +1232,7 @@ private:
12261232

12271233
auto __right = __ptr->__right_;
12281234

1229-
__node_traits::destroy(__alloc_, std::addressof(__ptr->__value_));
1235+
__node_traits::destroy(__alloc_, std::addressof(__ptr->__get_value()));
12301236
__node_traits::deallocate(__alloc_, __ptr, 1);
12311237

12321238
(*this)(static_cast<__node_pointer>(__right));
@@ -1245,7 +1251,7 @@ private:
12451251
if (!__src)
12461252
return nullptr;
12471253

1248-
__node_holder __new_node = __construct_node(__src->__value_);
1254+
__node_holder __new_node = __construct_node(__src->__get_value());
12491255

12501256
unique_ptr<__node, __tree_deleter> __left(
12511257
__copy_construct_tree(static_cast<__node_pointer>(__src->__left_)), __node_alloc_);
@@ -1276,7 +1282,7 @@ private:
12761282
return nullptr;
12771283
}
12781284

1279-
__assign_value(__dest->__value_, __src->__value_);
1285+
__assign_value(__dest->__get_value(), __src->__get_value());
12801286
__dest->__is_black_ = __src->__is_black_;
12811287

12821288
// If we already have a left node in the destination tree, reuse it and copy-assign recursively
@@ -1417,7 +1423,7 @@ void __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _
14171423
if (__size_ != 0) {
14181424
_DetachedTreeCache __cache(this);
14191425
for (; __cache.__get() && __first != __last; ++__first) {
1420-
__assign_value(__cache.__get()->__value_, *__first);
1426+
__assign_value(__cache.__get()->__get_value(), *__first);
14211427
__node_insert_multi(__cache.__get());
14221428
__cache.__advance();
14231429
}
@@ -1509,13 +1515,13 @@ void __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type) {
15091515
if (__size_ != 0) {
15101516
_DetachedTreeCache __cache(this);
15111517
while (__cache.__get() != nullptr && __t.__size_ != 0) {
1512-
__assign_value(__cache.__get()->__value_, std::move(__t.remove(__t.begin())->__value_));
1518+
__assign_value(__cache.__get()->__get_value(), std::move(__t.remove(__t.begin())->__get_value()));
15131519
__node_insert_multi(__cache.__get());
15141520
__cache.__advance();
15151521
}
15161522
}
15171523
while (__t.__size_ != 0) {
1518-
__insert_multi_from_orphaned_node(__e, std::move(__t.remove(__t.begin())->__value_));
1524+
__insert_multi_from_orphaned_node(__e, std::move(__t.remove(__t.begin())->__get_value()));
15191525
}
15201526
}
15211527
}
@@ -1583,7 +1589,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__end_node_pointer& __parent,
15831589
__node_pointer __nd = __root();
15841590
if (__nd != nullptr) {
15851591
while (true) {
1586-
if (value_comp()(__nd->__value_, __v)) {
1592+
if (value_comp()(__nd->__get_value(), __v)) {
15871593
if (__nd->__right_ != nullptr)
15881594
__nd = static_cast<__node_pointer>(__nd->__right_);
15891595
else {
@@ -1613,7 +1619,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__end_node_pointer& __parent
16131619
__node_pointer __nd = __root();
16141620
if (__nd != nullptr) {
16151621
while (true) {
1616-
if (value_comp()(__v, __nd->__value_)) {
1622+
if (value_comp()(__v, __nd->__get_value())) {
16171623
if (__nd->__left_ != nullptr)
16181624
__nd = static_cast<__node_pointer>(__nd->__left_);
16191625
else {
@@ -1676,15 +1682,15 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(__end_node_pointer& __parent, co
16761682
__node_base_pointer* __nd_ptr = __root_ptr();
16771683
if (__nd != nullptr) {
16781684
while (true) {
1679-
if (value_comp()(__v, __nd->__value_)) {
1685+
if (value_comp()(__v, __nd->__get_value())) {
16801686
if (__nd->__left_ != nullptr) {
16811687
__nd_ptr = std::addressof(__nd->__left_);
16821688
__nd = static_cast<__node_pointer>(__nd->__left_);
16831689
} else {
16841690
__parent = static_cast<__end_node_pointer>(__nd);
16851691
return __parent->__left_;
16861692
}
1687-
} else if (value_comp()(__nd->__value_, __v)) {
1693+
} else if (value_comp()(__nd->__get_value(), __v)) {
16881694
if (__nd->__right_ != nullptr) {
16891695
__nd_ptr = std::addressof(__nd->__right_);
16901696
__nd = static_cast<__node_pointer>(__nd->__right_);
@@ -1808,7 +1814,7 @@ typename __tree<_Tp, _Compare, _Allocator>::__node_holder
18081814
__tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&&... __args) {
18091815
__node_allocator& __na = __node_alloc();
18101816
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
1811-
__node_traits::construct(__na, std::addressof(__h->__value_), std::forward<_Args>(__args)...);
1817+
__node_traits::construct(__na, std::addressof(__h->__get_value()), std::forward<_Args>(__args)...);
18121818
__h.get_deleter().__value_constructed = true;
18131819
return __h;
18141820
}
@@ -1819,7 +1825,7 @@ pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
18191825
__tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args) {
18201826
__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
18211827
__end_node_pointer __parent;
1822-
__node_base_pointer& __child = __find_equal(__parent, __h->__value_);
1828+
__node_base_pointer& __child = __find_equal(__parent, __h->__get_value());
18231829
__node_pointer __r = static_cast<__node_pointer>(__child);
18241830
bool __inserted = false;
18251831
if (__child == nullptr) {
@@ -1837,7 +1843,7 @@ __tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p
18371843
__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
18381844
__end_node_pointer __parent;
18391845
__node_base_pointer __dummy;
1840-
__node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_);
1846+
__node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__get_value());
18411847
__node_pointer __r = static_cast<__node_pointer>(__child);
18421848
if (__child == nullptr) {
18431849
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
@@ -1852,7 +1858,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
18521858
__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args) {
18531859
__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
18541860
__end_node_pointer __parent;
1855-
__node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
1861+
__node_base_pointer& __child = __find_leaf_high(__parent, __h->__get_value());
18561862
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
18571863
return iterator(static_cast<__node_pointer>(__h.release()));
18581864
}
@@ -1863,7 +1869,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
18631869
__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p, _Args&&... __args) {
18641870
__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
18651871
__end_node_pointer __parent;
1866-
__node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
1872+
__node_base_pointer& __child = __find_leaf(__p, __parent, __h->__get_value());
18671873
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
18681874
return iterator(static_cast<__node_pointer>(__h.release()));
18691875
}
@@ -1876,7 +1882,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_assign_unique(const value_type& __v, _
18761882
__node_pointer __r = static_cast<__node_pointer>(__child);
18771883
bool __inserted = false;
18781884
if (__child == nullptr) {
1879-
__assign_value(__nd->__value_, __v);
1885+
__assign_value(__nd->__get_value(), __v);
18801886
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
18811887
__r = __nd;
18821888
__inserted = true;
@@ -1888,7 +1894,7 @@ template <class _Tp, class _Compare, class _Allocator>
18881894
typename __tree<_Tp, _Compare, _Allocator>::iterator
18891895
__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(__node_pointer __nd) {
18901896
__end_node_pointer __parent;
1891-
__node_base_pointer& __child = __find_leaf_high(__parent, __nd->__value_);
1897+
__node_base_pointer& __child = __find_leaf_high(__parent, __nd->__get_value());
18921898
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
18931899
return iterator(__nd);
18941900
}
@@ -1897,7 +1903,7 @@ template <class _Tp, class _Compare, class _Allocator>
18971903
typename __tree<_Tp, _Compare, _Allocator>::iterator
18981904
__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(const_iterator __p, __node_pointer __nd) {
18991905
__end_node_pointer __parent;
1900-
__node_base_pointer& __child = __find_leaf(__p, __parent, __nd->__value_);
1906+
__node_base_pointer& __child = __find_leaf(__p, __parent, __nd->__get_value());
19011907
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
19021908
return iterator(__nd);
19031909
}
@@ -1924,7 +1930,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(_NodeHandle&& __n
19241930

19251931
__node_pointer __ptr = __nh.__ptr_;
19261932
__end_node_pointer __parent;
1927-
__node_base_pointer& __child = __find_equal(__parent, __ptr->__value_);
1933+
__node_base_pointer& __child = __find_equal(__parent, __ptr->__get_value());
19281934
if (__child != nullptr)
19291935
return _InsertReturnType{iterator(static_cast<__node_pointer>(__child)), false, std::move(__nh)};
19301936

@@ -1943,7 +1949,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(const_iterator __
19431949
__node_pointer __ptr = __nh.__ptr_;
19441950
__end_node_pointer __parent;
19451951
__node_base_pointer __dummy;
1946-
__node_base_pointer& __child = __find_equal(__hint, __parent, __dummy, __ptr->__value_);
1952+
__node_base_pointer& __child = __find_equal(__hint, __parent, __dummy, __ptr->__get_value());
19471953
__node_pointer __r = static_cast<__node_pointer>(__child);
19481954
if (__child == nullptr) {
19491955
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
@@ -1978,7 +1984,7 @@ _LIBCPP_HIDE_FROM_ABI void __tree<_Tp, _Compare, _Allocator>::__node_handle_merg
19781984
for (typename _Tree::iterator __i = __source.begin(); __i != __source.end();) {
19791985
__node_pointer __src_ptr = __i.__get_np();
19801986
__end_node_pointer __parent;
1981-
__node_base_pointer& __child = __find_equal(__parent, __src_ptr->__value_);
1987+
__node_base_pointer& __child = __find_equal(__parent, __src_ptr->__get_value());
19821988
++__i;
19831989
if (__child != nullptr)
19841990
continue;
@@ -1995,7 +2001,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(_NodeHandle&& __nh
19952001
return end();
19962002
__node_pointer __ptr = __nh.__ptr_;
19972003
__end_node_pointer __parent;
1998-
__node_base_pointer& __child = __find_leaf_high(__parent, __ptr->__value_);
2004+
__node_base_pointer& __child = __find_leaf_high(__parent, __ptr->__get_value());
19992005
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
20002006
__nh.__release_ptr();
20012007
return iterator(__ptr);
@@ -2010,7 +2016,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(const_iterator __h
20102016

20112017
__node_pointer __ptr = __nh.__ptr_;
20122018
__end_node_pointer __parent;
2013-
__node_base_pointer& __child = __find_leaf(__hint, __parent, __ptr->__value_);
2019+
__node_base_pointer& __child = __find_leaf(__hint, __parent, __ptr->__get_value());
20142020
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
20152021
__nh.__release_ptr();
20162022
return iterator(__ptr);
@@ -2024,7 +2030,7 @@ _LIBCPP_HIDE_FROM_ABI void __tree<_Tp, _Compare, _Allocator>::__node_handle_merg
20242030
for (typename _Tree::iterator __i = __source.begin(); __i != __source.end();) {
20252031
__node_pointer __src_ptr = __i.__get_np();
20262032
__end_node_pointer __parent;
2027-
__node_base_pointer& __child = __find_leaf_high(__parent, __src_ptr->__value_);
2033+
__node_base_pointer& __child = __find_leaf_high(__parent, __src_ptr->__get_value());
20282034
++__i;
20292035
__source.__remove_node_pointer(__src_ptr);
20302036
__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__src_ptr));
@@ -2079,9 +2085,9 @@ typename __tree<_Tp, _Compare, _Allocator>::size_type
20792085
__tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const {
20802086
__node_pointer __rt = __root();
20812087
while (__rt != nullptr) {
2082-
if (value_comp()(__k, __rt->__value_)) {
2088+
if (value_comp()(__k, __rt->__get_value())) {
20832089
__rt = static_cast<__node_pointer>(__rt->__left_);
2084-
} else if (value_comp()(__rt->__value_, __k))
2090+
} else if (value_comp()(__rt->__get_value(), __k))
20852091
__rt = static_cast<__node_pointer>(__rt->__right_);
20862092
else
20872093
return 1;
@@ -2096,10 +2102,10 @@ __tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const {
20962102
__end_node_pointer __result = __end_node();
20972103
__node_pointer __rt = __root();
20982104
while (__rt != nullptr) {
2099-
if (value_comp()(__k, __rt->__value_)) {
2105+
if (value_comp()(__k, __rt->__get_value())) {
21002106
__result = static_cast<__end_node_pointer>(__rt);
21012107
__rt = static_cast<__node_pointer>(__rt->__left_);
2102-
} else if (value_comp()(__rt->__value_, __k))
2108+
} else if (value_comp()(__rt->__get_value(), __k))
21032109
__rt = static_cast<__node_pointer>(__rt->__right_);
21042110
else
21052111
return std::distance(
@@ -2114,7 +2120,7 @@ template <class _Key>
21142120
typename __tree<_Tp, _Compare, _Allocator>::iterator
21152121
__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result) {
21162122
while (__root != nullptr) {
2117-
if (!value_comp()(__root->__value_, __v)) {
2123+
if (!value_comp()(__root->__get_value(), __v)) {
21182124
__result = static_cast<__end_node_pointer>(__root);
21192125
__root = static_cast<__node_pointer>(__root->__left_);
21202126
} else
@@ -2128,7 +2134,7 @@ template <class _Key>
21282134
typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__lower_bound(
21292135
const _Key& __v, __node_pointer __root, __end_node_pointer __result) const {
21302136
while (__root != nullptr) {
2131-
if (!value_comp()(__root->__value_, __v)) {
2137+
if (!value_comp()(__root->__get_value(), __v)) {
21322138
__result = static_cast<__end_node_pointer>(__root);
21332139
__root = static_cast<__node_pointer>(__root->__left_);
21342140
} else
@@ -2142,7 +2148,7 @@ template <class _Key>
21422148
typename __tree<_Tp, _Compare, _Allocator>::iterator
21432149
__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result) {
21442150
while (__root != nullptr) {
2145-
if (value_comp()(__v, __root->__value_)) {
2151+
if (value_comp()(__v, __root->__get_value())) {
21462152
__result = static_cast<__end_node_pointer>(__root);
21472153
__root = static_cast<__node_pointer>(__root->__left_);
21482154
} else
@@ -2156,7 +2162,7 @@ template <class _Key>
21562162
typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__upper_bound(
21572163
const _Key& __v, __node_pointer __root, __end_node_pointer __result) const {
21582164
while (__root != nullptr) {
2159-
if (value_comp()(__v, __root->__value_)) {
2165+
if (value_comp()(__v, __root->__get_value())) {
21602166
__result = static_cast<__end_node_pointer>(__root);
21612167
__root = static_cast<__node_pointer>(__root->__left_);
21622168
} else
@@ -2173,10 +2179,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) {
21732179
__end_node_pointer __result = __end_node();
21742180
__node_pointer __rt = __root();
21752181
while (__rt != nullptr) {
2176-
if (value_comp()(__k, __rt->__value_)) {
2182+
if (value_comp()(__k, __rt->__get_value())) {
21772183
__result = static_cast<__end_node_pointer>(__rt);
21782184
__rt = static_cast<__node_pointer>(__rt->__left_);
2179-
} else if (value_comp()(__rt->__value_, __k))
2185+
} else if (value_comp()(__rt->__get_value(), __k))
21802186
__rt = static_cast<__node_pointer>(__rt->__right_);
21812187
else
21822188
return _Pp(iterator(__rt),
@@ -2195,10 +2201,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const {
21952201
__end_node_pointer __result = __end_node();
21962202
__node_pointer __rt = __root();
21972203
while (__rt != nullptr) {
2198-
if (value_comp()(__k, __rt->__value_)) {
2204+
if (value_comp()(__k, __rt->__get_value())) {
21992205
__result = static_cast<__end_node_pointer>(__rt);
22002206
__rt = static_cast<__node_pointer>(__rt->__left_);
2201-
} else if (value_comp()(__rt->__value_, __k))
2207+
} else if (value_comp()(__rt->__get_value(), __k))
22022208
__rt = static_cast<__node_pointer>(__rt->__right_);
22032209
else
22042210
return _Pp(
@@ -2217,10 +2223,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) {
22172223
__end_node_pointer __result = __end_node();
22182224
__node_pointer __rt = __root();
22192225
while (__rt != nullptr) {
2220-
if (value_comp()(__k, __rt->__value_)) {
2226+
if (value_comp()(__k, __rt->__get_value())) {
22212227
__result = static_cast<__end_node_pointer>(__rt);
22222228
__rt = static_cast<__node_pointer>(__rt->__left_);
2223-
} else if (value_comp()(__rt->__value_, __k))
2229+
} else if (value_comp()(__rt->__get_value(), __k))
22242230
__rt = static_cast<__node_pointer>(__rt->__right_);
22252231
else
22262232
return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),
@@ -2238,10 +2244,10 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const {
22382244
__end_node_pointer __result = __end_node();
22392245
__node_pointer __rt = __root();
22402246
while (__rt != nullptr) {
2241-
if (value_comp()(__k, __rt->__value_)) {
2247+
if (value_comp()(__k, __rt->__get_value())) {
22422248
__result = static_cast<__end_node_pointer>(__rt);
22432249
__rt = static_cast<__node_pointer>(__rt->__left_);
2244-
} else if (value_comp()(__rt->__value_, __k))
2250+
} else if (value_comp()(__rt->__get_value(), __k))
22452251
__rt = static_cast<__node_pointer>(__rt->__right_);
22462252
else
22472253
return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),

0 commit comments

Comments
 (0)