[gcc r17-908] libstdc++: Implement P3567R2 flat_meow fixes
Patrick Palka
ppalka@gcc.gnu.org
Thu May 28 14:39:48 GMT 2026
https://gcc.gnu.org/g:f46eccc9409136831225e30017a1d8ba6654a9b9
commit r17-908-gf46eccc9409136831225e30017a1d8ba6654a9b9
Author: Patrick Palka <ppalka@redhat.com>
Date: Thu May 28 10:39:29 2026 -0400
libstdc++: Implement P3567R2 flat_meow fixes
This implements the changes in sections 5, 6 and 8 of P3567R2; the other
changes (in section 4 and 7) are effectively already implemented.
libstdc++-v3/ChangeLog:
* include/bits/version.def (flat_map): Bump to 202511.
(flat_set): Likewise.
* include/bits/version.h: Regenerate.
* include/std/flat_map (_Flat_map_impl): Remove
is_nothrow_swappable_v assertions.
(_Flat_map_impl::_Flat_map_impl): Explicitly default copy ctor.
Define move ctor with corrected exception handling as per
P3567R2.
(_Flat_map_impl::operator=): Likewise.
(_Flat_map_impl::insert_range): Define new __sorted_t overload
as per P3567R2.
(_Flat_map_impl::swap): Make conditionally noexcept as per
P3567R2.
* include/std/flat_set (_Flat_set_impl): Remove
is_nothrow_swappable_v assertion.
(_Flat_set_impl::_Flat_set_impl): Explicitly default copy ctor.
Define move ctor with correct invariant preserving behavior as
per P3567R2.
(_Flat_set_impl::operator=): Likewise.
(_Flat_set_impl::_M_insert_range): Factored out from
insert_range. Add bool parameter __is_sorted defaulted to
false.
(_Flat_set_impl::insert_range): Define new __sorted_t overload
as per P3567R2.
(_Flat_set_impl::swap): Make conditionally noexcept as per
P3567R2. Correct to use ranges::swap instead of ADL swap.
* testsuite/23_containers/flat_map/1.cc (test11, test12):
New tests.
* testsuite/23_containers/flat_multimap/1.cc (test10, test11):
New tests.
* testsuite/23_containers/flat_multiset/1.cc (test10, test11):
New tests.
* testsuite/23_containers/flat_set/1.cc (test10, test11):
New tests.
Reviewed-by: Tomasz Kamiński <tkaminsk@redhat.com>
Reviewed-by: Jonathan Wakely <jwakely@redhat.com>
Diff:
---
libstdc++-v3/include/bits/version.def | 9 +-
libstdc++-v3/include/bits/version.h | 8 +-
libstdc++-v3/include/std/flat_map | 54 +++++++++--
libstdc++-v3/include/std/flat_set | 69 ++++++++++++--
libstdc++-v3/testsuite/23_containers/flat_map/1.cc | 104 ++++++++++++++++++++-
.../testsuite/23_containers/flat_multimap/1.cc | 102 ++++++++++++++++++++
.../testsuite/23_containers/flat_multiset/1.cc | 94 +++++++++++++++++++
libstdc++-v3/testsuite/23_containers/flat_set/1.cc | 96 ++++++++++++++++++-
8 files changed, 513 insertions(+), 23 deletions(-)
diff --git a/libstdc++-v3/include/bits/version.def b/libstdc++-v3/include/bits/version.def
index 2f32a8bda98f..97f7d6865190 100644
--- a/libstdc++-v3/include/bits/version.def
+++ b/libstdc++-v3/include/bits/version.def
@@ -1898,16 +1898,21 @@ ftms = {
ftms = {
name = flat_map;
+ // 202207 P0429R9 A Standard flat_map
+ // 202511 P3567R2 flat_meow Fixes
values = {
- v = 202207;
+ v = 202511; // P3567R2 applied as DR for C++23
cxxmin = 23;
};
};
ftms = {
name = flat_set;
+ // 202207 P1222R4 A Standard flat_set
+ // LWG3751 Missing feature macro for flat_set
+ // 202511 P3567R2 flat_meow Fixes
values = {
- v = 202207;
+ v = 202511; // P3567R2 applied as DR for C++23
cxxmin = 23;
};
};
diff --git a/libstdc++-v3/include/bits/version.h b/libstdc++-v3/include/bits/version.h
index 517b9020ec65..c31893e34c4e 100644
--- a/libstdc++-v3/include/bits/version.h
+++ b/libstdc++-v3/include/bits/version.h
@@ -2108,9 +2108,9 @@
#if !defined(__cpp_lib_flat_map)
# if (__cplusplus >= 202100L)
-# define __glibcxx_flat_map 202207L
+# define __glibcxx_flat_map 202511L
# if defined(__glibcxx_want_all) || defined(__glibcxx_want_flat_map)
-# define __cpp_lib_flat_map 202207L
+# define __cpp_lib_flat_map 202511L
# endif
# endif
#endif /* !defined(__cpp_lib_flat_map) */
@@ -2118,9 +2118,9 @@
#if !defined(__cpp_lib_flat_set)
# if (__cplusplus >= 202100L)
-# define __glibcxx_flat_set 202207L
+# define __glibcxx_flat_set 202511L
# if defined(__glibcxx_want_all) || defined(__glibcxx_want_flat_set)
-# define __cpp_lib_flat_set 202207L
+# define __cpp_lib_flat_set 202511L
# endif
# endif
#endif /* !defined(__cpp_lib_flat_set) */
diff --git a/libstdc++-v3/include/std/flat_map b/libstdc++-v3/include/std/flat_map
index a51c6625d54a..f06c75a16f65 100644
--- a/libstdc++-v3/include/std/flat_map
+++ b/libstdc++-v3/include/std/flat_map
@@ -74,9 +74,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
static_assert(is_same_v<_Tp, typename _MappedContainer::value_type>);
- static_assert(is_nothrow_swappable_v<_KeyContainer>);
- static_assert(is_nothrow_swappable_v<_MappedContainer>);
-
using _Derived = __conditional_t<_Multi,
flat_multimap<_Key, _Tp, _Compare,
_KeyContainer, _MappedContainer>,
@@ -395,6 +392,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: _Flat_map_impl(__s, __il.begin(), __il.end(), __comp, __a)
{ }
+ _Flat_map_impl(const _Flat_map_impl&) = default;
+ _Flat_map_impl& operator=(const _Flat_map_impl&) = default;
+
+ _GLIBCXX26_CONSTEXPR
+ _Flat_map_impl(_Flat_map_impl&& __other)
+ noexcept(is_nothrow_move_constructible_v<containers>
+ && is_nothrow_move_constructible_v<key_compare>)
+#if __cpp_exceptions
+ try
+#endif
+ : _M_cont(std::move(__other._M_cont)), _M_comp(std::move(__other._M_comp))
+ { __other.clear(); }
+#if __cpp_exceptions
+ catch (...)
+ { __other.clear(); }
+#endif
+
+ _GLIBCXX26_CONSTEXPR
+ _Flat_map_impl&
+ operator=(_Flat_map_impl&& __other)
+ noexcept(is_nothrow_move_assignable_v<containers>
+ && is_nothrow_move_assignable_v<key_compare>)
+ {
+ auto __guard = _M_make_clear_guard();
+ auto __guard_other = _ClearGuard{__other._M_cont};
+ _M_cont = std::move(__other._M_cont);
+ _M_comp = std::move(__other._M_comp);
+ __guard._M_disable();
+ // __guard_other._M_disable is deliberately not called.
+ return *this;
+ }
+
_GLIBCXX26_CONSTEXPR
_Derived&
operator=(initializer_list<value_type> __il)
@@ -644,6 +673,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
insert_range(_Rg&& __rg)
{ _M_insert(ranges::begin(__rg), ranges::end(__rg)); }
+ template<__detail::__container_compatible_range<value_type> _Rg>
+ _GLIBCXX26_CONSTEXPR
+ void
+ insert_range(__sorted_t, _Rg&& __rg)
+ { _M_insert(ranges::begin(__rg), ranges::end(__rg), true); }
+
_GLIBCXX26_CONSTEXPR
void
insert(initializer_list<value_type> __il)
@@ -728,11 +763,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX26_CONSTEXPR
void
- swap(_Derived& __y) noexcept
+ swap(_Derived& __y)
+ noexcept(is_nothrow_swappable_v<key_container_type>
+ && is_nothrow_swappable_v<mapped_container_type>
+ && is_nothrow_swappable_v<key_compare>)
{
- ranges::swap(_M_comp, __y._M_comp);
+ auto __guard = _M_make_clear_guard();
+ auto __guard_y = _ClearGuard{__y._M_cont};
ranges::swap(_M_cont.keys, __y._M_cont.keys);
ranges::swap(_M_cont.values, __y._M_cont.values);
+ ranges::swap(_M_comp, __y._M_comp);
+ __guard._M_disable();
+ __guard_y._M_disable();
}
_GLIBCXX26_CONSTEXPR
@@ -974,7 +1016,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
friend _GLIBCXX26_CONSTEXPR void
- swap(_Derived& __x, _Derived& __y) noexcept
+ swap(_Derived& __x, _Derived& __y) noexcept(noexcept(__x.swap(__y)))
{ return __x.swap(__y); }
template<typename _Predicate>
diff --git a/libstdc++-v3/include/std/flat_set b/libstdc++-v3/include/std/flat_set
index 286290896ae0..e92559949ebb 100644
--- a/libstdc++-v3/include/std/flat_set
+++ b/libstdc++-v3/include/std/flat_set
@@ -71,7 +71,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
class _Flat_set_impl
{
static_assert(is_same_v<_Key, typename _KeyContainer::value_type>);
- static_assert(is_nothrow_swappable_v<_KeyContainer>);
using _Derived = __conditional_t<_Multi,
flat_multiset<_Key, _Compare, _KeyContainer>,
@@ -324,6 +323,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: _Flat_set_impl(__s, __il.begin(), __il.end(), __comp, __a)
{ }
+ _Flat_set_impl(const _Flat_set_impl&) = default;
+ _Flat_set_impl& operator=(const _Flat_set_impl&) = default;
+
+ _GLIBCXX26_CONSTEXPR
+ _Flat_set_impl(_Flat_set_impl&& __other)
+ noexcept(is_nothrow_move_constructible_v<container_type>
+ && is_nothrow_move_constructible_v<key_compare>)
+#if __cpp_exceptions
+ try
+#endif
+ : _M_cont(std::move(__other._M_cont)), _M_comp(std::move(__other._M_comp))
+ { __other.clear(); }
+#if __cpp_exceptions
+ catch (...)
+ { __other.clear(); }
+#endif
+
+ _GLIBCXX26_CONSTEXPR
+ _Flat_set_impl&
+ operator=(_Flat_set_impl&& __other)
+ noexcept(is_nothrow_move_assignable_v<container_type>
+ && is_nothrow_move_assignable_v<key_compare>)
+ {
+ auto __guard = _M_make_clear_guard();
+ auto __guard_other = _ClearGuard{__other._M_cont};
+ _M_cont = std::move(__other._M_cont);
+ _M_comp = std::move(__other._M_comp);
+ __guard._M_disable();
+ // __guard_other._M_disable is deliberately not called.
+ return *this;
+ }
+
_GLIBCXX26_CONSTEXPR
_Derived&
operator=(initializer_list<value_type> __il)
@@ -540,10 +571,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__guard._M_disable();
}
- template<__detail::__container_compatible_range<value_type> _Rg>
+ template<typename _Rg>
_GLIBCXX26_CONSTEXPR
void
- insert_range(_Rg&& __rg)
+ _M_insert_range(_Rg&& __rg, bool __is_sorted = false)
{
auto __guard = _M_make_clear_guard();
typename container_type::iterator __it;
@@ -561,13 +592,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_cont.emplace_back(*__first);
__it = _M_cont.begin() + __n;
}
- std::sort(__it, _M_cont.end(), _M_comp);
+ if (__is_sorted)
+ _GLIBCXX_DEBUG_ASSERT(ranges::is_sorted(__it, _M_cont.end(), _M_comp));
+ else
+ std::sort(__it, _M_cont.end(), _M_comp);
std::inplace_merge(_M_cont.begin(), __it, _M_cont.end(), _M_comp);
if constexpr (!_Multi)
_M_unique();
__guard._M_disable();
}
+ template<__detail::__container_compatible_range<value_type> _Rg>
+ _GLIBCXX26_CONSTEXPR
+ void
+ insert_range(_Rg&& __rg)
+ { _M_insert_range(std::forward<_Rg>(__rg)); }
+
+ template<__detail::__container_compatible_range<value_type> _Rg>
+ _GLIBCXX26_CONSTEXPR
+ void
+ insert_range(__sorted_t, _Rg&& __rg)
+ { _M_insert_range(std::forward<_Rg>(__rg), true); }
+
_GLIBCXX26_CONSTEXPR
void
insert(initializer_list<value_type> __il)
@@ -628,11 +674,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX26_CONSTEXPR
void
- swap(_Derived& __x) noexcept
+ swap(_Derived& __y)
+ noexcept(is_nothrow_swappable_v<container_type>
+ && is_nothrow_swappable_v<key_compare>)
{
- using std::swap;
- swap(_M_cont, __x._M_cont);
- swap(_M_comp, __x._M_comp);
+ auto __guard = _M_make_clear_guard();
+ auto __guard_y = _ClearGuard{__y._M_cont};
+ ranges::swap(_M_comp, __y._M_comp);
+ ranges::swap(_M_cont, __y._M_cont);
+ __guard._M_disable();
+ __guard_y._M_disable();
}
_GLIBCXX26_CONSTEXPR
@@ -830,7 +881,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
friend _GLIBCXX26_CONSTEXPR void
- swap(_Derived& __x, _Derived& __y) noexcept
+ swap(_Derived& __x, _Derived& __y) noexcept(noexcept(__x.swap(__y)))
{ return __x.swap(__y); }
template<typename _Predicate>
diff --git a/libstdc++-v3/testsuite/23_containers/flat_map/1.cc b/libstdc++-v3/testsuite/23_containers/flat_map/1.cc
index 1cb088f511eb..7e22e0366ec2 100644
--- a/libstdc++-v3/testsuite/23_containers/flat_map/1.cc
+++ b/libstdc++-v3/testsuite/23_containers/flat_map/1.cc
@@ -3,7 +3,7 @@
#include <flat_map>
-#if __cpp_lib_flat_map != 202207L
+#if __cpp_lib_flat_map != 202511L
# error "Feature-test macro __cpp_lib_flat_map has wrong value in <flat_map>"
#endif
@@ -299,6 +299,103 @@ test10()
VERIFY (k == "world");
}
+template<typename T>
+struct throwing_vector : std::vector<T>
+{
+ static inline bool throw_on_move = false;
+
+ throwing_vector() = default;
+ throwing_vector(const throwing_vector&) = default;
+ throwing_vector& operator=(const throwing_vector&) = default;
+
+ throwing_vector(throwing_vector&& other)
+ : std::vector<T>(std::move(other))
+ {
+ if (throw_on_move)
+ throw std::runtime_error("move ctor");
+ }
+
+ throwing_vector&
+ operator=(throwing_vector&& other)
+ {
+ static_cast<std::vector<T>&>(*this) = std::move(other);
+ if (throw_on_move)
+ throw std::runtime_error("move assign");
+ return *this;
+ }
+};
+
+template<template<typename> class KC, template<typename> class MC>
+void
+test11()
+{
+#if __cpp_exceptions
+ using flat_map = std::flat_map<int, int, std::less<int>, KC<int>, MC<int>>;
+
+ auto is_really_empty = [](const flat_map& m) {
+ return m.empty() && m.keys().empty() && m.values().empty();
+ };
+ throwing_vector<int>::throw_on_move = true;
+
+ // Verify invariant preservation upon throwing move construction.
+ flat_map source;
+ source.insert({{1, 100}, {2, 200}});
+ try
+ {
+ flat_map target(std::move(source));
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( is_really_empty(source) );
+ }
+
+ // Verify invariant preservation upon throwing move assignment.
+ source.clear();
+ source.insert({{1, 100}, {2, 200}});
+ flat_map target;
+ target.insert({{3, 300}, {4, 400}});
+ try
+ {
+ target = std::move(source);
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( is_really_empty(source) );
+ VERIFY( is_really_empty(target) );
+ }
+
+ // Verify invariant preservation upon throwing swap.
+ source.clear();
+ source.insert({{1, 100}, {2, 200}});
+ target.clear();
+ target.insert({{3, 300}, {4, 400}});
+ try
+ {
+ source.swap(target);
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( is_really_empty(source) );
+ VERIFY( is_really_empty(target) );
+ }
+#endif
+}
+
+constexpr
+void
+test12()
+{
+ // Verify usability of flat_map::insert_range(sorted_unique_t, Rg&&).
+ std::flat_map<int, int> m = {{2, 200}};
+ std::pair<int, int> s[] = {{1, 100}, {3, 300}};
+ m.insert_range(std::sorted_unique, s);
+ VERIFY( std::ranges::equal(m.keys(), (int[]){1, 2, 3}) );
+ VERIFY( std::ranges::equal(m.values(), (int[]){100, 200, 300}) );
+}
+
void
test()
{
@@ -315,6 +412,9 @@ test()
test08();
test09();
test10();
+ test11<std::vector, throwing_vector>();
+ test11<throwing_vector, std::vector>();
+ test12();
}
constexpr
@@ -333,6 +433,8 @@ test_constexpr()
#if __cpp_lib_constexpr_string >= 201907L
test10();
#endif
+ // test11() is non-constexpr
+ test12();
return true;
}
diff --git a/libstdc++-v3/testsuite/23_containers/flat_multimap/1.cc b/libstdc++-v3/testsuite/23_containers/flat_multimap/1.cc
index 00644c14061a..48688b7583ed 100644
--- a/libstdc++-v3/testsuite/23_containers/flat_multimap/1.cc
+++ b/libstdc++-v3/testsuite/23_containers/flat_multimap/1.cc
@@ -252,6 +252,103 @@ test09()
using value_type = std::pair<int, int>;
}
+template<typename T>
+struct throwing_vector : std::vector<T>
+{
+ static inline bool throw_on_move = false;
+
+ throwing_vector() = default;
+ throwing_vector(const throwing_vector&) = default;
+ throwing_vector& operator=(const throwing_vector&) = default;
+
+ throwing_vector(throwing_vector&& other)
+ : std::vector<T>(std::move(other))
+ {
+ if (throw_on_move)
+ throw std::runtime_error("move ctor");
+ }
+
+ throwing_vector&
+ operator=(throwing_vector&& other)
+ {
+ static_cast<std::vector<T>&>(*this) = std::move(other);
+ if (throw_on_move)
+ throw std::runtime_error("move assign");
+ return *this;
+ }
+};
+
+template<template<typename> class KC, template<typename> class MC>
+void
+test10()
+{
+#if __cpp_exceptions
+ using flat_multimap = std::flat_multimap<int, int, std::less<int>, KC<int>, MC<int>>;
+
+ auto is_really_empty = [](const flat_multimap& m) {
+ return m.empty() && m.keys().empty() && m.values().empty();
+ };
+ throwing_vector<int>::throw_on_move = true;
+
+ // Verify invariant preservation upon throwing move construction.
+ flat_multimap source;
+ source.insert({{1, 100}, {2, 200}});
+ try
+ {
+ flat_multimap target(std::move(source));
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( is_really_empty(source) );
+ }
+
+ // Verify invariant preservation upon throwing move assignment.
+ source.clear();
+ source.insert({{1, 100}, {2, 200}});
+ flat_multimap target;
+ target.insert({{3, 300}, {4, 400}});
+ try
+ {
+ target = std::move(source);
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( is_really_empty(source) );
+ VERIFY( is_really_empty(target) );
+ }
+
+ // Verify invariant preservation upon throwing swap.
+ source.clear();
+ source.insert({{1, 100}, {2, 200}});
+ target.clear();
+ target.insert({{3, 300}, {4, 400}});
+ try
+ {
+ source.swap(target);
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( is_really_empty(source) );
+ VERIFY( is_really_empty(target) );
+ }
+#endif
+}
+
+constexpr
+void
+test11()
+{
+ // Verify usability of flat_multimap::insert_range(sorted_equivalent_t, Rg&&).
+ std::flat_multimap<int, int> m = {{2, 200}};;
+ std::pair<int, int> s[] = {{1, 100}, {3, 300}};
+ m.insert_range(std::sorted_equivalent, s);
+ VERIFY( std::ranges::equal(m.keys(), (int[]){1, 2, 3}) );
+ VERIFY( std::ranges::equal(m.values(), (int[]){100, 200, 300}) );
+}
+
void
test()
{
@@ -266,6 +363,9 @@ test()
test06();
test07();
test09();
+ test10<std::vector, throwing_vector>();
+ test10<throwing_vector, std::vector>();
+ test11();
}
constexpr
@@ -280,6 +380,8 @@ test_constexpr()
test06();
test07();
test09();
+ // test10() is non-constexpr
+ test11();
return true;
}
diff --git a/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc b/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc
index be330fefdd05..4544adb50770 100644
--- a/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc
+++ b/libstdc++-v3/testsuite/23_containers/flat_multiset/1.cc
@@ -265,6 +265,96 @@ test09()
VERIFY( std::ranges::equal(s, (int[]){2,2,4}) );
}
+template<typename T>
+struct throwing_vector : std::vector<T>
+{
+ static inline bool throw_on_move = false;
+
+ throwing_vector() = default;
+ throwing_vector(const throwing_vector&) = default;
+ throwing_vector& operator=(const throwing_vector&) = default;
+
+ throwing_vector(throwing_vector&& other)
+ : std::vector<T>(std::move(other))
+ {
+ if (throw_on_move)
+ throw std::runtime_error("move ctor");
+ }
+
+ throwing_vector&
+ operator=(throwing_vector&& other)
+ {
+ static_cast<std::vector<T>&>(*this) = std::move(other);
+ if (throw_on_move)
+ throw std::runtime_error("move assign");
+ return *this;
+ }
+};
+
+void
+test10()
+{
+#if __cpp_exceptions
+ using flat_multiset = std::flat_multiset<int, std::less<int>, throwing_vector<int>>;
+
+ throwing_vector<int>::throw_on_move = true;
+
+ // Verify invariant preservation upon throwing move construction.
+ flat_multiset source = {1, 2};
+ try
+ {
+ flat_multiset target(std::move(source));
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( source.empty() );
+ }
+
+ // Verify invariant preservation upon throwing move assignment.
+ source.clear();
+ source.insert({1, 2});
+ flat_multiset target = {3, 4};
+ try
+ {
+ target = std::move(source);
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( source.empty() );
+ VERIFY( target.empty() );
+ }
+
+ // Verify invariant preservation upon throwing swap.
+ source.clear();
+ source.insert({1, 2});
+ target.clear();
+ target.insert({3, 4});
+ try
+ {
+ source.swap(target);
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( source.empty() );
+ VERIFY( target.empty() );
+ }
+#endif
+}
+
+constexpr
+void
+test11()
+{
+ // Verify usability of flat_multiset::insert_range(sorted_equivalent_t, Rg&&).
+ std::flat_multiset<int> m = {2};
+ int s[] = {1, 3};
+ m.insert_range(std::sorted_equivalent, s);
+ VERIFY( std::ranges::equal(m, (int[]){1, 2, 3}) );
+}
+
void
test()
{
@@ -278,6 +368,8 @@ test()
test07();
test08();
test09();
+ test10();
+ test11();
}
constexpr
@@ -292,6 +384,8 @@ test_constexpr()
test07();
test08();
test09();
+ // test10() is non-constexpr
+ test11();
return true;
}
diff --git a/libstdc++-v3/testsuite/23_containers/flat_set/1.cc b/libstdc++-v3/testsuite/23_containers/flat_set/1.cc
index a14d03476e18..ac12815bd0d4 100644
--- a/libstdc++-v3/testsuite/23_containers/flat_set/1.cc
+++ b/libstdc++-v3/testsuite/23_containers/flat_set/1.cc
@@ -2,7 +2,7 @@
#include <flat_set>
-#if __cpp_lib_flat_set != 202207L
+#if __cpp_lib_flat_set != 202511L
# error "Feature-test macro __cpp_lib_flat_set has wrong value in <flat_set>"
#endif
@@ -277,6 +277,96 @@ test09()
VERIFY( std::ranges::equal(s, (int[]){2,4}) );
}
+template<typename T>
+struct throwing_vector : std::vector<T>
+{
+ static inline bool throw_on_move = false;
+
+ throwing_vector() = default;
+ throwing_vector(const throwing_vector&) = default;
+ throwing_vector& operator=(const throwing_vector&) = default;
+
+ throwing_vector(throwing_vector&& other)
+ : std::vector<T>(std::move(other))
+ {
+ if (throw_on_move)
+ throw std::runtime_error("move ctor");
+ }
+
+ throwing_vector&
+ operator=(throwing_vector&& other)
+ {
+ static_cast<std::vector<T>&>(*this) = std::move(other);
+ if (throw_on_move)
+ throw std::runtime_error("move assign");
+ return *this;
+ }
+};
+
+void
+test10()
+{
+#if __cpp_exceptions
+ using flat_set = std::flat_set<int, std::less<int>, throwing_vector<int>>;
+
+ throwing_vector<int>::throw_on_move = true;
+
+ // Verify invariant preservation upon throwing move construction.
+ flat_set source = {1, 2};
+ try
+ {
+ flat_set target(std::move(source));
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( source.empty() );
+ }
+
+ // Verify invariant preservation upon throwing move assignment.
+ source.clear();
+ source.insert({1, 2});
+ flat_set target = {3, 4};
+ try
+ {
+ target = std::move(source);
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( source.empty() );
+ VERIFY( target.empty() );
+ }
+
+ // Verify invariant preservation upon throwing swap.
+ source.clear();
+ source.insert({1, 2});
+ target.clear();
+ target.insert({3, 4});
+ try
+ {
+ source.swap(target);
+ VERIFY( false );
+ }
+ catch (const std::runtime_error&)
+ {
+ VERIFY( source.empty() );
+ VERIFY( target.empty() );
+ }
+#endif
+}
+
+constexpr
+void
+test11()
+{
+ // Verify usability of flat_set::insert_range(sorted_unique_t, Rg&&).
+ std::flat_set<int> m = {2};
+ int s[] = {1, 3};
+ m.insert_range(std::sorted_unique, s);
+ VERIFY( std::ranges::equal(m, (int[]){1, 2, 3}) );
+}
+
void
test()
{
@@ -290,6 +380,8 @@ test()
test07();
test08();
test09();
+ test10();
+ test11();
}
constexpr
@@ -304,6 +396,8 @@ test_constexpr()
test07();
test08();
test09();
+ // test10() is non-constexpr
+ test11();
return true;
}
More information about the Libstdc++-cvs
mailing list