mirrors/gcc
0
0
Fork 0
mirror of https://gcc.gnu.org/git/gcc.git synced 2024-12-18 16:44:57 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

libstdc++: Implement constexpr std::unique_ptr for C++23 (P2273R3)

Browse Source 
libstdc++-v3/ChangeLog:

	* include/bits/ptr_traits.h (__cpp_lib_constexpr_memory): Define
	conditionally.
	* include/bits/unique_ptr.h (__cpp_lib_constexpr_memory):
	Define for C++23.
	(default_delete, default_delete<T[]>, __uniq_ptr_impl)
	(unique_ptr, unique_ptr<T[], D>): Add constexpr to all member
	functions.
	* include/std/version (__cpp_lib_constexpr_memory): Define new
	value for C++23.
	* testsuite/20_util/unique_ptr/assign/constexpr.cc: New test.
	* testsuite/20_util/unique_ptr/comparison/constexpr.cc: New test.
	* testsuite/20_util/unique_ptr/cons/constexpr_c++20.cc: New test.
	* testsuite/20_util/unique_ptr/creation/constexpr.cc: New test.
	* testsuite/20_util/unique_ptr/modifiers/constexpr.cc: New test.
	* testsuite/20_util/unique_ptr/specialized_algorithms/constexpr.cc:
	New test.
This commit is contained in:
Jonathan Wakely 2022-04-25 14:24:48 +01:00
parent a5cee0480c
commit 2fbdcf5e58
9 changed files with 466 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
libstdc++-v3/include/bits/ptr_traits.h
View File

@ -36,7 +36,10 @@
#if __cplusplus > 201703L
#include <concepts>
#define __cpp_lib_constexpr_memory 201811L
# ifndef __cpp_lib_constexpr_memory
// Defined to a newer value in bits/unique_ptr.h for C++23
# define __cpp_lib_constexpr_memory 201811L
# endif
namespace __gnu_debug { struct _Safe_iterator_base; }
#endif

124
libstdc++-v3/include/bits/unique_ptr.h
View File

@ -41,6 +41,14 @@
# include <ostream>
#endif
#if __cplusplus > 202002L && __cpp_constexpr_dynamic_alloc
# if __cpp_lib_constexpr_memory < 202202L
// Defined with older value in bits/ptr_traits.h for C++20
# undef __cpp_lib_constexpr_memory
# define __cpp_lib_constexpr_memory 202202L
# endif
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
@ -72,9 +80,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<typename _Up,
typename = _Require<is_convertible<_Up*, _Tp*>>>
_GLIBCXX23_CONSTEXPR
default_delete(const default_delete<_Up>&) noexcept { }
/// Calls `delete __ptr`
_GLIBCXX23_CONSTEXPR
void
operator()(_Tp* __ptr) const
{
@ -108,10 +118,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<typename _Up,
typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
_GLIBCXX23_CONSTEXPR
default_delete(const default_delete<_Up[]>&) noexcept { }
/// Calls `delete[] __ptr`
template<typename _Up>
_GLIBCXX23_CONSTEXPR
typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
{
@ -152,16 +164,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
" or an lvalue reference type" );
__uniq_ptr_impl() = default;
_GLIBCXX23_CONSTEXPR
__uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }
template<typename _Del>
__uniq_ptr_impl(pointer __p, _Del&& __d)
_GLIBCXX23_CONSTEXPR
__uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }
_GLIBCXX23_CONSTEXPR
__uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
: _M_t(std::move(__u._M_t))
{ __u._M_ptr() = nullptr; }
_GLIBCXX23_CONSTEXPR
__uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
{
reset(__u.release());
@ -169,11 +185,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return *this;
}
_GLIBCXX23_CONSTEXPR
pointer& _M_ptr() noexcept { return std::get<0>(_M_t); }
_GLIBCXX23_CONSTEXPR
pointer _M_ptr() const noexcept { return std::get<0>(_M_t); }
_GLIBCXX23_CONSTEXPR
_Dp& _M_deleter() noexcept { return std::get<1>(_M_t); }
_GLIBCXX23_CONSTEXPR
const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); }
_GLIBCXX23_CONSTEXPR
void reset(pointer __p) noexcept
{
const pointer __old_p = _M_ptr();
@ -182,6 +203,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_deleter()(__old_p);
}
_GLIBCXX23_CONSTEXPR
pointer release() noexcept
{
pointer __p = _M_ptr();
@ -189,6 +211,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __p;
}
_GLIBCXX23_CONSTEXPR
void
swap(__uniq_ptr_impl& __rhs) noexcept
{
@ -281,6 +304,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* The deleter will be value-initialized.
*/
template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
_GLIBCXX23_CONSTEXPR
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
@ -295,6 +319,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<typename _Del = deleter_type,
typename = _Require<is_copy_constructible<_Del>>>
_GLIBCXX23_CONSTEXPR
unique_ptr(pointer __p, const deleter_type& __d) noexcept
: _M_t(__p, __d) { }
@ -307,6 +332,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<typename _Del = deleter_type,
typename = _Require<is_move_constructible<_Del>>>
_GLIBCXX23_CONSTEXPR
unique_ptr(pointer __p,
__enable_if_t<!is_lvalue_reference<_Del>::value,
_Del&&> __d) noexcept
@ -315,6 +341,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Del = deleter_type,
typename _DelUnref = typename remove_reference<_Del>::type>
_GLIBCXX23_CONSTEXPR
unique_ptr(pointer,
__enable_if_t<is_lvalue_reference<_Del>::value,
_DelUnref&&>) = delete;
@ -341,6 +368,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__conditional_t<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>>>
_GLIBCXX23_CONSTEXPR
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
@ -356,6 +384,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif
/// Destructor, invokes the deleter if the stored pointer is not null.
#if __cplusplus > 202002L && __cpp_constexpr_dynamic_alloc
constexpr
#endif
~unique_ptr() noexcept
{
static_assert(__is_invocable<deleter_type&, pointer>::value,
@ -382,6 +413,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* Invokes the deleter if this object owns a pointer.
*/
template<typename _Up, typename _Ep>
_GLIBCXX23_CONSTEXPR
typename enable_if< __and_<
__safe_conversion_up<_Up, _Ep>,
is_assignable<deleter_type&, _Ep&&>
@ -395,6 +427,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
/// Reset the %unique_ptr to empty, invoking the deleter if necessary.
_GLIBCXX23_CONSTEXPR
unique_ptr&
operator=(nullptr_t) noexcept
{
@ -405,6 +438,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Observers.
/// Dereference the stored pointer.
_GLIBCXX23_CONSTEXPR
typename add_lvalue_reference<element_type>::type
operator*() const noexcept(noexcept(*std::declval<pointer>()))
{
@ -413,6 +447,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
/// Return the stored pointer.
_GLIBCXX23_CONSTEXPR
pointer
operator->() const noexcept
{
@ -421,27 +456,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
/// Return the stored pointer.
_GLIBCXX23_CONSTEXPR
pointer
get() const noexcept
{ return _M_t._M_ptr(); }
/// Return a reference to the stored deleter.
_GLIBCXX23_CONSTEXPR
deleter_type&
get_deleter() noexcept
{ return _M_t._M_deleter(); }
/// Return a reference to the stored deleter.
_GLIBCXX23_CONSTEXPR
const deleter_type&
get_deleter() const noexcept
{ return _M_t._M_deleter(); }
/// Return @c true if the stored pointer is not null.
_GLIBCXX23_CONSTEXPR
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
// Modifiers.
/// Release ownership of any stored pointer.
_GLIBCXX23_CONSTEXPR
pointer
release() noexcept
{ return _M_t.release(); }
@ -452,6 +492,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*
* The deleter will be invoked if a pointer is already owned.
*/
_GLIBCXX23_CONSTEXPR
void
reset(pointer __p = pointer()) noexcept
{
@ -461,6 +502,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
/// Exchange the pointer and deleter with another object.
_GLIBCXX23_CONSTEXPR
void
swap(unique_ptr& __u) noexcept
{
@ -551,6 +593,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename = _DeleterConstraint<_Vp>,
typename = typename enable_if<
__safe_conversion_raw<_Up>::value, bool>::type>
_GLIBCXX23_CONSTEXPR
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p)
@ -567,8 +610,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Up, typename _Del = deleter_type,
typename = _Require<__safe_conversion_raw<_Up>,
is_copy_constructible<_Del>>>
unique_ptr(_Up __p, const deleter_type& __d) noexcept
: _M_t(__p, __d) { }
_GLIBCXX23_CONSTEXPR
unique_ptr(_Up __p, const deleter_type& __d) noexcept
: _M_t(__p, __d) { }
/** Takes ownership of a pointer.
*
@ -581,6 +625,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Up, typename _Del = deleter_type,
typename = _Require<__safe_conversion_raw<_Up>,
is_move_constructible<_Del>>>
_GLIBCXX23_CONSTEXPR
unique_ptr(_Up __p,
__enable_if_t<!is_lvalue_reference<_Del>::value,
_Del&&> __d) noexcept
@ -608,11 +653,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__conditional_t<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>>>
_GLIBCXX23_CONSTEXPR
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
/// Destructor, invokes the deleter if the stored pointer is not null.
#if __cplusplus > 202002L && __cpp_constexpr_dynamic_alloc
constexpr
#endif
~unique_ptr()
{
auto& __ptr = _M_t._M_ptr();
@ -638,6 +687,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* Invokes the deleter if this object owns a pointer.
*/
template<typename _Up, typename _Ep>
_GLIBCXX23_CONSTEXPR
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
is_assignable<deleter_type&, _Ep&&>
@ -651,6 +701,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
/// Reset the %unique_ptr to empty, invoking the deleter if necessary.
_GLIBCXX23_CONSTEXPR
unique_ptr&
operator=(nullptr_t) noexcept
{
@ -661,6 +712,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Observers.
/// Access an element of owned array.
_GLIBCXX23_CONSTEXPR
typename std::add_lvalue_reference<element_type>::type
operator[](size_t __i) const
{
@ -669,27 +721,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
/// Return the stored pointer.
_GLIBCXX23_CONSTEXPR
pointer
get() const noexcept
{ return _M_t._M_ptr(); }
/// Return a reference to the stored deleter.
_GLIBCXX23_CONSTEXPR
deleter_type&
get_deleter() noexcept
{ return _M_t._M_deleter(); }
/// Return a reference to the stored deleter.
_GLIBCXX23_CONSTEXPR
const deleter_type&
get_deleter() const noexcept
{ return _M_t._M_deleter(); }
/// Return @c true if the stored pointer is not null.
_GLIBCXX23_CONSTEXPR
explicit operator bool() const noexcept
{ return get() == pointer() ? false : true; }
// Modifiers.
/// Release ownership of any stored pointer.
_GLIBCXX23_CONSTEXPR
pointer
release() noexcept
{ return _M_t.release(); }
@ -712,14 +769,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
>
>
>>
_GLIBCXX23_CONSTEXPR
void
reset(_Up __p) noexcept
{ _M_t.reset(std::move(__p)); }
_GLIBCXX23_CONSTEXPR
void reset(nullptr_t = nullptr) noexcept
{ reset(pointer()); }
/// Exchange the pointer and deleter with another object.
_GLIBCXX23_CONSTEXPR
void
swap(unique_ptr& __u) noexcept
{
@ -740,6 +800,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
inline
#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
// Constrained free swap overload, see p0185r1
_GLIBCXX23_CONSTEXPR
typename enable_if<__is_swappable<_Dp>::value>::type
#else
void
@ -758,41 +819,47 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Equality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() == __y.get(); }
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return !__x; }
#ifndef __cpp_lib_three_way_comparison
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD
inline bool
operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return !__x; }
/// Inequality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return __x.get() != __y.get(); }
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD
inline bool
operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
{ return (bool)__x; }
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD
inline bool
operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
{ return (bool)__x; }
#endif // three way comparison
@ -800,7 +867,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{
@ -812,7 +880,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{
return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
@ -821,7 +890,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{
return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
@ -831,34 +901,39 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__y < __x); }
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(nullptr < __x); }
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{ return !(__x < nullptr); }
/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return (__y < __x); }
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{
return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
@ -867,7 +942,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
{
return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
@ -877,14 +953,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
typename _Up, typename _Ep>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
{ return !(__x < __y); }
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
_GLIBCXX_NODISCARD inline bool
_GLIBCXX_NODISCARD _GLIBCXX23_CONSTEXPR
inline bool
operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
{ return !(__x < nullptr); }
@ -898,6 +976,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Dp, typename _Up, typename _Ep>
requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer,
typename unique_ptr<_Up, _Ep>::pointer>
_GLIBCXX23_CONSTEXPR
inline
compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer,
typename unique_ptr<_Up, _Ep>::pointer>
@ -907,6 +986,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Dp>
requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer>
_GLIBCXX23_CONSTEXPR
inline
compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer>
operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
@ -979,6 +1059,7 @@ namespace __detail
* @relates unique_ptr
*/
template<typename _Tp, typename... _Args>
_GLIBCXX23_CONSTEXPR
inline __detail::__unique_ptr_t<_Tp>
make_unique(_Args&&... __args)
{ return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
@ -993,6 +1074,7 @@ namespace __detail
* The array elements are value-initialized.
*/
template<typename _Tp>
_GLIBCXX23_CONSTEXPR
inline __detail::__unique_ptr_array_t<_Tp>
make_unique(size_t __num)
{ return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
@ -1014,6 +1096,7 @@ namespace __detail
* @relates unique_ptr
*/
template<typename _Tp>
_GLIBCXX23_CONSTEXPR
inline __detail::__unique_ptr_t<_Tp>
make_unique_for_overwrite()
{ return unique_ptr<_Tp>(new _Tp); }
@ -1026,6 +1109,7 @@ namespace __detail
* @relates unique_ptr
*/
template<typename _Tp>
_GLIBCXX23_CONSTEXPR
inline __detail::__unique_ptr_array_t<_Tp>
make_unique_for_overwrite(size_t __num)
{ return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]); }

4
libstdc++-v3/include/std/version
View File

@ -307,6 +307,10 @@
#if _GLIBCXX_HOSTED
#define __cpp_lib_adaptor_iterator_pair_constructor 202106L
#if __cpp_constexpr_dynamic_alloc
# undef __cpp_lib_constexpr_memory
# define __cpp_lib_constexpr_memory 202202L
#endif
#if __cpp_concepts >= 202002L
# define __cpp_lib_expected 202202L
#endif

48
libstdc++-v3/testsuite/20_util/unique_ptr/assign/constexpr.cc Normal file
View File

@ -0,0 +1,48 @@
// { dg-options "-std=gnu++23" }
// { dg-do compile { target c++23 } }
#include <memory>
#include <testsuite_hooks.h>
constexpr bool
test_move()
{
std::unique_ptr<int> p1(new int(2));
std::unique_ptr<int> p2;
p2 = std::move(p1);
VERIFY( *p2 == 2 );
std::unique_ptr<int[]> a1(new int[]{0, 1, 2});
std::unique_ptr<int[]> a2;
a2 = std::move(a1);
VERIFY( a2[2] == 2 );
return true;
}
static_assert( test_move() );
constexpr bool
test_convert()
{
std::unique_ptr<int> p1(new int(2));
std::unique_ptr<const int> p2;
p2 = std::move(p1);
VERIFY( *p2 == 2 );
std::unique_ptr<int[]> a1(new int[]{0, 1, 2});
std::unique_ptr<const int[]> a2;
a2 = std::move(a1);
VERIFY( a2[2] == 2 );
return true;
}
static_assert( test_convert() );
constexpr bool
test_null()
{
std::unique_ptr<int> p(new int(2));
p = nullptr;
VERIFY( !p );
p = nullptr;
return true;
}
static_assert( test_null() );

73
libstdc++-v3/testsuite/20_util/unique_ptr/comparison/constexpr.cc Normal file
View File

@ -0,0 +1,73 @@
// { dg-options "-std=gnu++23" }
// { dg-do compile { target c++23 } }
#include <memory>
#include <testsuite_hooks.h>
constexpr bool
test_eq()
{
std::unique_ptr<int> p1, p2;
VERIFY( p1 == p2 );
p1.reset(new int(1));
VERIFY( p1 == p1 );
VERIFY( p1 != p2 );
struct null_deleter { constexpr void operator()(const void*) const { } };
std::unique_ptr<const int[], null_deleter> p3(p1.get());
VERIFY( p3 == p3 );
VERIFY( p1 == p3 );
VERIFY( p3 != p2 );
return true;
}
static_assert( test_eq() );
constexpr bool
test_rel()
{
std::unique_ptr<int> p1, p2;
VERIFY( !(p1 < p2) );
VERIFY( !(p1 > p2) );
VERIFY( p1 <= p2 );
VERIFY( p1 >= p2 );
p1.reset(new int(1));
VERIFY( p1 <= p1 );
VERIFY( p1 >= p1 );
VERIFY( p1 > p2 );
VERIFY( p2 < p1 );
VERIFY( p2 <= p1 );
VERIFY( p1 >= p2 );
struct null_deleter { constexpr void operator()(const void*) const { } };
std::unique_ptr<const int[], null_deleter> p3(p1.get());
VERIFY( p3 <= p3 );
VERIFY( p3 >= p3 );
VERIFY( p1 <= p3 );
VERIFY( p3 > p2 );
VERIFY( p3 >= p2 );
VERIFY( p2 < p3 );
VERIFY( p2 <= p3 );
return true;
}
static_assert( test_rel() );
constexpr bool
test_3way()
{
std::unique_ptr<int> p1, p2;
VERIFY( (p1 <=> p1) == 0 );
VERIFY( (p1 <=> p2) == 0 );
p1.reset(new int(1));
VERIFY( (p1 <=> p1) == 0 );
VERIFY( (p1 <=> p2) > 0 );
VERIFY( (p2 <=> p1) < 0 );
struct null_deleter { constexpr void operator()(const void*) const { } };
std::unique_ptr<const int[], null_deleter> p3(p1.get());
VERIFY( (p3 <=> p3) == 0 );
VERIFY( (p1 <=> p3) == 0 );
VERIFY( (p3 <=> p2) > 0 );
VERIFY( (p2 <=> p3) < 0 );
return true;
}
static_assert( test_3way() );

85
libstdc++-v3/testsuite/20_util/unique_ptr/cons/constexpr_c++20.cc Normal file
View File

@ -0,0 +1,85 @@
// { dg-options "-std=gnu++23" }
// { dg-do compile { target c++23 } }
#include <memory>
#ifndef __cpp_lib_constexpr_memory
# error "Feature test macro for constexpr unique_ptr is missing in <memory>"
#elif __cpp_lib_constexpr_memory < 202202L
# error "Feature test macro for constexpr unique_ptr has wrong value in <memory>"
#endif
#include <testsuite_hooks.h>
constexpr bool
test_default()
{
std::unique_ptr<int> p;
std::unique_ptr<int> np(nullptr);
VERIFY( p == np );
std::unique_ptr<int[]> a;
std::unique_ptr<int[]> na(nullptr);
VERIFY( a == na );
return true;
}
static_assert( test_default() );
constexpr bool
test_ptr()
{
std::unique_ptr<int> p(new int(2));
VERIFY( *p == 2 );
std::unique_ptr<int[]> a(new int[]{0, 1, 2});
VERIFY( a[2] == 2 );
return true;
}
static_assert( test_ptr() );
constexpr bool
test_del()
{
const std::default_delete<int> pd;
std::unique_ptr<int> p1(new int(1), pd);
VERIFY( *p1 == 1 );
std::unique_ptr<int> p2(new int(2), std::default_delete<int>{});
VERIFY( *p2 == 2 );
const std::default_delete<int[]> ad;
std::unique_ptr<int[]> a1(new int[]{3, 4}, ad);
VERIFY( a1[0] == 3 );
std::unique_ptr<int[]> a2(new int[]{5, 6}, std::default_delete<int[]>{});
VERIFY( a2[1] == 6 );
return true;
}
static_assert( test_del() );
constexpr bool
test_move()
{
std::unique_ptr<int> p1(new int(2));
std::unique_ptr<int> p2 = std::move(p1);
VERIFY( *p2 == 2 );
std::unique_ptr<int[]> a1(new int[]{0, 1, 2});
std::unique_ptr<int[]> a2 = std::move(a1);
VERIFY( a2[2] == 2 );
return true;
}
static_assert( test_move() );
constexpr bool
test_convert()
{
std::unique_ptr<int> p1(new int(2));
std::unique_ptr<const int> p2 = std::move(p1);
VERIFY( *p2 == 2 );
std::unique_ptr<int[]> a1(new int[]{0, 1, 2});
std::unique_ptr<const int[]> a2 = std::move(a1);
VERIFY( a2[2] == 2 );
return true;
}
static_assert( test_convert() );

34
libstdc++-v3/testsuite/20_util/unique_ptr/creation/constexpr.cc Normal file
View File

@ -0,0 +1,34 @@
// { dg-options "-std=gnu++23" }
// { dg-do compile { target c++23 } }
#include <memory>
#include <testsuite_hooks.h>
constexpr bool
test_creation_single()
{
std::unique_ptr<int> p = std::make_unique<int>(1);
VERIFY( *p == 1 );
p = std::make_unique_for_overwrite<int>();
*p = 2;
VERIFY( *p == 2 );
return true;
}
static_assert( test_creation_single() );
constexpr bool
test_creation_array()
{
std::unique_ptr<int[]> a = std::make_unique<int[]>(2);
VERIFY( a[0] == 0 );
VERIFY( a[1] == 0 );
a = std::make_unique_for_overwrite<int[]>(2);
a[0] = 1;
a[1] = 2;
VERIFY( a[0] == 1 );
VERIFY( a[1] == 2 );
return true;
}
static_assert( test_creation_array() );

68
libstdc++-v3/testsuite/20_util/unique_ptr/modifiers/constexpr.cc Normal file
View File

@ -0,0 +1,68 @@
// { dg-options "-std=gnu++23" }
// { dg-do compile { target c++23 } }
#include <memory>
#include <testsuite_hooks.h>
constexpr bool
test_release()
{
std::unique_ptr<int> p1;
int* r = p1.release();
VERIFY( !r );
VERIFY( !p1 );
std::unique_ptr<int> p2(new int(2));
r = p2.release();
VERIFY( r );
VERIFY( !p2 );
delete r;
std::unique_ptr<int[]> a1;
r = a1.release();
VERIFY( !r );
VERIFY( !a1 );
std::unique_ptr<int[]> a2(new int[2]{});
r = a2.release();
VERIFY( r );
VERIFY( !a2 );
delete[] r;
return true;
}
static_assert( test_release() );
constexpr bool
test_reset()
{
std::unique_ptr<int> p1;
p1.reset();
VERIFY( !p1 );
p1.reset(nullptr);
VERIFY( !p1 );
p1.reset(new int(2));
VERIFY( *p1 == 2 );
p1.reset(new int(3));
VERIFY( *p1 == 3 );
p1.reset(nullptr);
VERIFY( !p1 );
std::unique_ptr<int[]> a1;
a1.reset();
VERIFY( !a1 );
a1.reset(nullptr);
VERIFY( !a1 );
a1.reset(new int[]{2,3});
VERIFY( a1[0] == 2 );
a1.reset(new int[]{4,5,6});
VERIFY( a1[1] == 5 );
a1.reset(nullptr);
VERIFY( !a1 );
std::unique_ptr<const int[]> a2;
a2.reset(new int[2]{});
return true;
}
static_assert( test_reset() );

46
libstdc++-v3/testsuite/20_util/unique_ptr/specialized_algorithms/constexpr.cc Normal file
View File

@ -0,0 +1,46 @@
// { dg-options "-std=gnu++23" }
// { dg-do compile { target c++23 } }
#include <memory>
#include <testsuite_hooks.h>
constexpr bool
test_swap_single()
{
std::unique_ptr<int> p1;
swap(p1, p1);
VERIFY( !p1 );
std::unique_ptr<int> p2;
swap(p1, p2);
VERIFY( !p1 && !p2 );
std::unique_ptr<int> p3(new int(3));
swap(p3, p3);
VERIFY( *p3 == 3 );
swap(p1, p3);
VERIFY( *p1 == 3 );
std::unique_ptr<int> p4(new int(4));
swap(p4, p1);
VERIFY( *p4 == 3 );
VERIFY( *p1 == 4 );
return true;
}
static_assert( test_swap_single() );
constexpr bool
test_swap_array()
{
std::unique_ptr<int[]> a1;
std::unique_ptr<int[]> a2;
swap(a1, a2);
VERIFY( !a1 && !a2 );
std::unique_ptr<int[]> a3(new int[]{3});
swap(a1, a3);
VERIFY( a1[0] == 3 );
std::unique_ptr<int[]> a4(new int[]{4, 5});
swap(a1, a4);
VERIFY( a1[1] == 5 );
return true;
}
static_assert( test_swap_array() );