Tested x86_64-linux. Pushed to trunk.
-- >8 --
This was recently approved for C++26, but we can apply the changes for
all modes back to C++11. There's no reason not to make the assignment
usable in constant expressions for C++11 mode, and noexcept for all
modes.
Move the definitions to <bits/utility.h> so they're available in
<utility> as well as <tuple>.
libstdc++-v3/ChangeLog:
* include/bits/utility.h (_Swallow_assign): Make assignment
constexpr for C++11 as well, and add noexcept.
* include/std/tuple (_Swallow_assign, ignore): Move to
bits/utility.h.
* testsuite/20_util/headers/utility/ignore.cc: New test.
---
libstdc++-v3/include/bits/utility.h | 29 +++++++++++++++++
libstdc++-v3/include/std/tuple | 31 -------------------
.../20_util/headers/utility/ignore.cc | 29 +++++++++++++++++
3 files changed, 58 insertions(+), 31 deletions(-)
create mode 100644 libstdc++-v3/testsuite/20_util/headers/utility/ignore.cc
diff --git a/libstdc++-v3/include/bits/utility.h
b/libstdc++-v3/include/bits/utility.h
index 9f3b99231b3..44c74333e92 100644
--- a/libstdc++-v3/include/bits/utility.h
+++ b/libstdc++-v3/include/bits/utility.h
@@ -280,6 +280,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} // namespace __detail
#endif
+ // A class (and instance) which can be used in 'tie' when an element
+ // of a tuple is not required.
+ struct _Swallow_assign
+ {
+ template<class _Tp>
+ constexpr const _Swallow_assign&
+ operator=(const _Tp&) const noexcept
+ { return *this; }
+ };
+
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 2773. Making std::ignore constexpr
+ /** Used with `std::tie` to ignore an element of a tuple
+ *
+ * When using `std::tie` to assign the elements of a tuple to variables,
+ * unwanted elements can be ignored by using `std::ignore`. For example:
+ *
+ * ```
+ * int x, y;
+ * std::tie(x, std::ignore, y) = std::make_tuple(1, 2, 3);
+ * ```
+ *
+ * This assignment will perform `x=1; std::ignore=2; y=3;` which results
+ * in the second element being ignored.
+ *
+ * @since C++11
+ */
+ _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};
+
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
index df3f6e38eeb..93b649e7d21 100644
--- a/libstdc++-v3/include/std/tuple
+++ b/libstdc++-v3/include/std/tuple
@@ -2845,37 +2845,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
#endif
- // A class (and instance) which can be used in 'tie' when an element
- // of a tuple is not required.
- // _GLIBCXX14_CONSTEXPR
- // 2933. PR for LWG 2773 could be clearer
- struct _Swallow_assign
- {
- template<class _Tp>
- _GLIBCXX14_CONSTEXPR const _Swallow_assign&
- operator=(const _Tp&) const
- { return *this; }
- };
-
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 2773. Making std::ignore constexpr
- /** Used with `std::tie` to ignore an element of a tuple
- *
- * When using `std::tie` to assign the elements of a tuple to variables,
- * unwanted elements can be ignored by using `std::ignore`. For example:
- *
- * ```
- * int x, y;
- * std::tie(x, std::ignore, y) = std::make_tuple(1, 2, 3);
- * ```
- *
- * This assignment will perform `x=1; std::ignore=2; y=3;` which results
- * in the second element being ignored.
- *
- * @since C++11
- */
- _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};
-
/// Partial specialization for tuples
template<typename... _Types, typename _Alloc>
struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
diff --git a/libstdc++-v3/testsuite/20_util/headers/utility/ignore.cc
b/libstdc++-v3/testsuite/20_util/headers/utility/ignore.cc
new file mode 100644
index 00000000000..fc7a45dc55b
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/headers/utility/ignore.cc
@@ -0,0 +1,29 @@
+// { dg-do compile { target c++11 } }
+
+// P2968R2 Make std::ignore a first-class object.
+// This is a C++26 change, but we treat it as a DR against C++11.
+
+// C++26 [tuple.general]:
+// In addition to being available via inclusion of the <tuple> header,
+// ignore is available when <utility> is included.
+#include <utility>
+
+using ignore_type = std::remove_const<decltype(std::ignore)>::type;
+
+#ifdef __cpp_lib_is_aggregate
+static_assert( std::is_aggregate_v<ignore_type> );
+#endif
+
+static_assert( std::is_nothrow_default_constructible<ignore_type>::value, "" );
+static_assert( std::is_nothrow_copy_constructible<ignore_type>::value, "" );
+static_assert( std::is_nothrow_copy_assignable<ignore_type>::value, "" );
+
+static_assert( std::is_nothrow_assignable<const ignore_type&, int>::value,
+ "assignable from arbitrary types" );
+static_assert( std::is_nothrow_assignable<const ignore_type&, long*>::value,
+ "assignable from arbitrary types" );
+
+constexpr ignore_type ignore;
+constexpr ignore_type ignore_more(ignore);
+constexpr ignore_type ignore_morer(ignore = ignore);
+constexpr ignore_type ignore_morest(ignore = "");
--
2.45.2
