} // 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
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 { };
--- /dev/null
+// { 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 = "");