OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

functional (_Require): Move to ...

Browse Source 
* include/std/functional (_Require): Move to ...
	* include/std/type_traits (_Require): ... here.
	* include/bits/shared_ptr_base.h (__shared_count::_S_create_from_up):
	Handle unique_ptr for arrays or with custom pointer types.
	(__shared_ptr::__shared_ptr(unique_ptr<_Tp1, _Del>&&): Likewise.
	* include/bits/unique_ptr.h (unique_ptr<_Tp[], _Dp>): Use
	_Dp::pointer if defined. Implement proposed resolution of LWG 2118.
	* testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc: New.
	* testsuite/20_util/unique_ptr/assign/cv_qual.cc: New.
	* testsuite/20_util/unique_ptr/cons/array_convertible_neg.cc: New.
	* testsuite/20_util/unique_ptr/cons/convertible_neg.cc: New.
	* testsuite/20_util/unique_ptr/cons/cv_qual.cc: New.
	* testsuite/20_util/unique_ptr/modifiers/cv_qual.cc: New.
	* testsuite/20_util/unique_ptr/requirements/pointer_type_array.cc: New.
	* testsuite/20_util/shared_ptr/cons/unique_ptr.cc: Adjust comments.
	* testsuite/20_util/unique_ptr/cons/pointer_array_convertible_neg.cc:
	Likewise.
	* testsuite/20_util/unique_ptr/requirements/pointer_type.cc: Likewise.
	* testsuite/20_util/bind/ref_neg.cc: Adjust dg-error line number.
	* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
	* testsuite/20_util/default_delete/48631_neg.cc: Likewise.
	* testsuite/20_util/shared_ptr/cons/43820_neg.cc: Likewise.
	* testsuite/20_util/unique_ptr/assign/48635_neg.cc: Likewise.
	* testsuite/20_util/unique_ptr/modifiers/reset_neg.cc: Adjust
	dg-error text.
	* testsuite/20_util/unique_ptr/cons/ptr_deleter_neg.cc: Use
	different instantiations so static_assert fails for each.

From-SVN: r194651
This commit is contained in:
Jonathan Wakely 2012-12-20 21:02:33 +00:00 committed by Jonathan Wakely
parent d89da9dbda
commit 23df853421
22 changed files with 668 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,33 @@
2012-12-20 Jonathan Wakely <jwakely.gcc@gmail.com>
* include/std/functional (_Require): Move to ...
* include/std/type_traits (_Require): ... here.
* include/bits/shared_ptr_base.h (__shared_count::_S_create_from_up):
Handle unique_ptr for arrays or with custom pointer types.
(__shared_ptr::__shared_ptr(unique_ptr<_Tp1, _Del>&&): Likewise.
* include/bits/unique_ptr.h (unique_ptr<_Tp[], _Dp>): Use
_Dp::pointer if defined. Implement proposed resolution of LWG 2118.
* testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc: New.
* testsuite/20_util/unique_ptr/assign/cv_qual.cc: New.
* testsuite/20_util/unique_ptr/cons/array_convertible_neg.cc: New.
* testsuite/20_util/unique_ptr/cons/convertible_neg.cc: New.
* testsuite/20_util/unique_ptr/cons/cv_qual.cc: New.
* testsuite/20_util/unique_ptr/modifiers/cv_qual.cc: New.
* testsuite/20_util/unique_ptr/requirements/pointer_type_array.cc: New.
* testsuite/20_util/shared_ptr/cons/unique_ptr.cc: Adjust comments.
* testsuite/20_util/unique_ptr/cons/pointer_array_convertible_neg.cc:
Likewise.
* testsuite/20_util/unique_ptr/requirements/pointer_type.cc: Likewise.
* testsuite/20_util/bind/ref_neg.cc: Adjust dg-error line number.
* testsuite/20_util/declval/requirements/1_neg.cc: Likewise.
* testsuite/20_util/default_delete/48631_neg.cc: Likewise.
* testsuite/20_util/shared_ptr/cons/43820_neg.cc: Likewise.
* testsuite/20_util/unique_ptr/assign/48635_neg.cc: Likewise.
* testsuite/20_util/unique_ptr/modifiers/reset_neg.cc: Adjust
dg-error text.
* testsuite/20_util/unique_ptr/cons/ptr_deleter_neg.cc: Use
different instantiations so static_assert fails for each.
2012-12-20 Jonathan Wakely <jwakely.gcc@gmail.com>
PR libstdc++/55741

8
libstdc++-v3/include/bits/shared_ptr_base.h
View File

@ -616,7 +616,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
typename std::enable_if<!std::is_reference<_Del>::value>::type* = 0)
{
return new _Sp_counted_deleter<_Tp*, _Del, std::allocator<void>,
typedef typename unique_ptr<_Tp, _Del>::pointer _Ptr;
return new _Sp_counted_deleter<_Ptr, _Del, std::allocator<void>,
_Lp>(__r.get(), __r.get_deleter());
}
@ -625,9 +626,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r,
typename std::enable_if<std::is_reference<_Del>::value>::type* = 0)
{
typedef typename unique_ptr<_Tp, _Del>::pointer _Ptr;
typedef typename std::remove_reference<_Del>::type _Del1;
typedef std::reference_wrapper<_Del1> _Del2;
return new _Sp_counted_deleter<_Tp*, _Del2, std::allocator<void>,
return new _Sp_counted_deleter<_Ptr, _Del2, std::allocator<void>,
_Lp>(__r.get(), std::ref(__r.get_deleter()));
}
@ -846,7 +848,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: _M_ptr(__r.get()), _M_refcount()
{
__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
_Tp1* __tmp = __r.get();
auto __tmp = std::__addressof(*__r.get());
_M_refcount = __shared_count<_Lp>(std::move(__r));
__enable_shared_from_this_helper(_M_refcount, __tmp, __tmp);
}

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

@ -56,7 +56,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
std::enable_if<std::is_convertible<_Up*, _Tp*>::value>::type>
enable_if<is_convertible<_Up*, _Tp*>::value>::type>
default_delete(const default_delete<_Up>&) noexcept { }
void
@ -74,8 +74,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp>
struct default_delete<_Tp[]>
{
private:
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
// Like is_base_of<_Tp, _Up> but false if unqualified types are the same
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
public:
constexpr default_delete() noexcept = default;
template<typename _Up, typename = typename
enable_if<!__is_derived_Tp<_Up>::value>::type>
default_delete(const default_delete<_Up[]>&) noexcept { }
void
operator()(_Tp* __ptr) const
{
@ -84,7 +99,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
delete [] __ptr;
}
template<typename _Up> void operator()(_Up*) const = delete;
template<typename _Up>
typename enable_if<__is_derived_Tp<_Up>::value>::type
operator()(_Up*) const = delete;
};
/// 20.7.1.2 unique_ptr for single objects.
@ -103,7 +120,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype( __test<_Del>(0)) type;
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
@ -117,54 +134,45 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Constructors.
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!std::is_pointer<deleter_type>::value,
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
unique_ptr(pointer __p,
typename std::conditional<std::is_reference<deleter_type>::value,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
unique_ptr(pointer __p,
typename std::remove_reference<deleter_type>::type&& __d) noexcept
typename remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
// Move constructors.
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
template<typename _Up, typename _Ep, typename = typename
std::enable_if
<std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value
&& !std::is_array<_Up>::value
&& ((std::is_reference<_Dp>::value
&& std::is_same<_Ep, _Dp>::value)
|| (!std::is_reference<_Dp>::value
&& std::is_convertible<_Ep, _Dp>::value))>
::type>
template<typename _Up, typename _Ep, typename = _Require<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
#if _GLIBCXX_USE_DEPRECATED
template<typename _Up, typename = typename
std::enable_if<std::is_convertible<_Up*, _Tp*>::value
&& std::is_same<_Dp,
default_delete<_Tp>>::value>::type>
template<typename _Up, typename = _Require<
is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
#endif
@ -186,12 +194,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return *this;
}
template<typename _Up, typename _Ep, typename = typename
std::enable_if
<std::is_convertible<typename unique_ptr<_Up, _Ep>::pointer,
pointer>::value
&& !std::is_array<_Up>::value>::type>
unique_ptr&
template<typename _Up, typename _Ep>
typename enable_if< __and_<
is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
__not_<is_array<_Up>>
>::value,
unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
@ -207,7 +215,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
// Observers.
typename std::add_lvalue_reference<element_type>::type
typename add_lvalue_reference<element_type>::type
operator*() const
{
_GLIBCXX_DEBUG_ASSERT(get() != pointer());
@ -273,11 +281,47 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp, typename _Dp>
class unique_ptr<_Tp[], _Dp>
{
typedef std::tuple<_Tp*, _Dp> __tuple_type;
__tuple_type _M_t;
// use SFINAE to determine whether _Del::pointer exists
class _Pointer
{
template<typename _Up>
static typename _Up::pointer __test(typename _Up::pointer*);
template<typename _Up>
static _Tp* __test(...);
typedef typename remove_reference<_Dp>::type _Del;
public:
typedef decltype(__test<_Del>(0)) type;
};
typedef std::tuple<typename _Pointer::type, _Dp> __tuple_type;
__tuple_type _M_t;
template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;
// like is_base_of<_Tp, _Up> but false if unqualified types are the same
template<typename _Up>
using __is_derived_Tp
= __and_< is_base_of<_Tp, _Up>,
__not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
template<typename _Up, typename _Ep,
typename _Tp_pointer = typename _Pointer::type,
typename _Up_pointer = typename unique_ptr<_Up, _Ep>::pointer>
using __safe_conversion = __and_<
is_convertible<_Up_pointer, _Tp_pointer>,
is_array<_Up>,
__or_<__not_<is_pointer<_Up_pointer>>,
__not_<is_pointer<_Tp_pointer>>,
__not_<__is_derived_Tp<typename remove_extent<_Up>::type>>
>
>;
public:
typedef _Tp* pointer;
typedef typename _Pointer::type pointer;
typedef _Tp element_type;
typedef _Dp deleter_type;
@ -285,35 +329,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr unique_ptr() noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
"constructed with null function pointer deleter"); }
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p, deleter_type())
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
{ static_assert(!is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
explicit
unique_ptr(_Up* __p) = delete;
unique_ptr(pointer __p,
typename std::conditional<std::is_reference<deleter_type>::value,
typename conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type __d) noexcept
: _M_t(__p, __d) { }
unique_ptr(pointer __p, typename
std::remove_reference<deleter_type>::type && __d) noexcept
remove_reference<deleter_type>::type&& __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ static_assert(!std::is_reference<deleter_type>::value,
{ static_assert(!is_reference<deleter_type>::value,
"rvalue deleter bound to reference"); }
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
{ static_assert(!std::is_pointer<deleter_type>::value,
"constructed with null function pointer deleter"); }
// Move constructors.
// Move constructor.
unique_ptr(unique_ptr&& __u) noexcept
: _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }
template<typename _Up, typename _Ep>
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }
template<typename _Up, typename _Ep,
typename = _Require<__safe_conversion<_Up, _Ep>,
typename conditional<is_reference<_Dp>::value,
is_same<_Ep, _Dp>,
is_convertible<_Ep, _Dp>>::type
>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }
@ -337,7 +388,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
template<typename _Up, typename _Ep>
unique_ptr&
typename
enable_if<__safe_conversion<_Up, _Ep>::value, unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
reset(__u.release());
@ -385,7 +437,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
void
reset(pointer __p = pointer()) noexcept
reset() noexcept
{ reset(pointer()); }
void
reset(pointer __p) noexcept
{
using std::swap;
swap(std::get<0>(_M_t), __p);
@ -393,18 +449,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
get_deleter()(__p);
}
void
reset(nullptr_t) noexcept
{
pointer __p = get();
std::get<0>(_M_t) = pointer();
if (__p != nullptr)
get_deleter()(__p);
}
// DR 821.
template<typename _Up>
void reset(_Up) = delete;
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
void reset(_Up*) = delete;
void
swap(unique_ptr& __u) noexcept
@ -418,23 +465,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
unique_ptr& operator=(const unique_ptr&) = delete;
// Disable construction from convertible pointer types.
// (N2315 - 20.7.1.3.1)
template<typename _Up>
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
std::conditional<std::is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type,
typename std::enable_if<std::is_convertible<_Up*,
pointer>::value>::type* = 0) = delete;
conditional<is_reference<deleter_type>::value,
deleter_type, const deleter_type&>::type) = delete;
template<typename _Up>
unique_ptr(_Up*, typename std::remove_reference<deleter_type>::type&&,
typename std::enable_if<std::is_convertible<_Up*,
pointer>::value>::type* = 0) = delete;
template<typename _Up>
explicit
unique_ptr(_Up*, typename std::enable_if<std::is_convertible<_Up*,
pointer>::value>::type* = 0) = delete;
template<typename _Up, typename = _Require<is_pointer<pointer>,
is_convertible<_Up*, pointer>, __is_derived_Tp<_Up>>>
unique_ptr(_Up*, typename
remove_reference<deleter_type>::type&&) = delete;
};
template<typename _Tp, typename _Dp>

3
libstdc++-v3/include/std/functional
View File

@ -501,9 +501,6 @@ _GLIBCXX_HAS_NESTED_TYPE(result_type)
// @} group functors
template<typename... _Cond>
using _Require = typename enable_if<__and_<_Cond...>::value>::type;
template<typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)>
{ };

2
libstdc++-v3/include/std/type_traits
View File

@ -1771,6 +1771,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct enable_if<true, _Tp>
{ typedef _Tp type; };
template<typename... _Cond>
using _Require = typename enable_if<__and_<_Cond...>::value>::type;
// Primary template.
/// Define a member typedef @c type to one of two argument types.

8
libstdc++-v3/testsuite/20_util/bind/ref_neg.cc
View File

@ -30,10 +30,10 @@ void test01()
{
const int dummy = 0;
std::bind(&inc, _1)(0); // { dg-error "no match" }
// { dg-error "rvalue|const" "" { target *-*-* } 1349 }
// { dg-error "rvalue|const" "" { target *-*-* } 1363 }
// { dg-error "rvalue|const" "" { target *-*-* } 1377 }
// { dg-error "rvalue|const" "" { target *-*-* } 1391 }
// { dg-error "rvalue|const" "" { target *-*-* } 1346 }
// { dg-error "rvalue|const" "" { target *-*-* } 1360 }
// { dg-error "rvalue|const" "" { target *-*-* } 1374 }
// { dg-error "rvalue|const" "" { target *-*-* } 1388 }
std::bind(&inc, std::ref(dummy))(); // { dg-error "no match" }
}

2
libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc
View File

@ -19,7 +19,7 @@
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// { dg-error "static assertion failed" "" { target *-*-* } 1869 }
// { dg-error "static assertion failed" "" { target *-*-* } 1871 }
#include <utility>

2
libstdc++-v3/testsuite/20_util/default_delete/48631_neg.cc
View File

@ -27,4 +27,4 @@ struct D : B { };
D d;
std::default_delete<B[]> db;
typedef decltype(db(&d)) type; // { dg-error "use of deleted function" }
// { dg-error "declared here" "" { target *-*-* } 87 }
// { dg-error "declared here" "" { target *-*-* } 104 }

2
libstdc++-v3/testsuite/20_util/shared_ptr/cons/43820_neg.cc
View File

@ -32,7 +32,7 @@ void test01()
{
X* px = 0;
std::shared_ptr<X> p1(px); // { dg-error "here" }
// { dg-error "incomplete" "" { target *-*-* } 769 }
// { dg-error "incomplete" "" { target *-*-* } 771 }
std::shared_ptr<X> p9(ap()); // { dg-error "here" }
// { dg-error "incomplete" "" { target *-*-* } 307 }

8
libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr.cc
View File

@ -1,6 +1,6 @@
// { dg-options "-std=gnu++0x" }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2008, 2009 Free Software Foundation
// Copyright (C) 2008-2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -17,14 +17,14 @@
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 20.7.12.2 Template class shared_ptr [util.smartptr.shared]
// 20.7.2.2 Class template shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
struct A { };
// 20.7.12.2.1 shared_ptr constructors [util.smartptr.shared.const]
// 20.7.2.2.1 shared_ptr constructors [util.smartptr.shared.const]
// Construction from unique_ptr
int

59
libstdc++-v3/testsuite/20_util/shared_ptr/cons/unique_ptr_array.cc Normal file
View File

@ -0,0 +1,59 @@
// { dg-options "-std=gnu++11" }
// Copyright (C) 2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 20.7.2.2 Class template shared_ptr [util.smartptr.shared]
#include <memory>
#include <testsuite_hooks.h>
int destroyed = 0;
struct A : std::enable_shared_from_this<A>
{
~A() { ++destroyed; }
};
// 20.7.2.2.1 shared_ptr constructors [util.smartptr.shared.const]
// Construction from unique_ptr<A[]>
int
test01()
{
bool test __attribute__((unused)) = true;
std::unique_ptr<A[]> up(new A[2]);
std::shared_ptr<A> sp(std::move(up));
VERIFY( up.get() == 0 );
VERIFY( sp.get() != 0 );
VERIFY( sp.use_count() == 1 );
VERIFY( sp->shared_from_this() != nullptr );
sp.reset();
VERIFY( destroyed == 2 );
return 0;
}
int
main()
{
test01();
return 0;
}

4
libstdc++-v3/testsuite/20_util/unique_ptr/assign/48635_neg.cc
View File

@ -41,10 +41,10 @@ void f()
std::unique_ptr<int, B&> ub(nullptr, b);
std::unique_ptr<int, D&> ud(nullptr, d);
ub = std::move(ud);
// { dg-error "use of deleted function" "" { target *-*-* } 198 }
// { dg-error "use of deleted function" "" { target *-*-* } 206 }
std::unique_ptr<int[], B&> uba(nullptr, b);
std::unique_ptr<int[], D&> uda(nullptr, d);
uba = std::move(uda);
// { dg-error "use of deleted function" "" { target *-*-* } 344 }
// { dg-error "use of deleted function" "" { target *-*-* } 396 }
}

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

@ -0,0 +1,89 @@
// { dg-options "-std=gnu++11" }
// { dg-do compile }
// Copyright (C) 2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 20.7.1 Class template unique_ptr [unique.ptr]
#include <memory>
struct A { virtual ~A() = default; };
struct B : A { };
// Assignment from objects with different cv-qualification
void
test01()
{
std::unique_ptr<A> upA;
std::unique_ptr<const A> cA;
cA = std::move(upA);
std::unique_ptr<volatile A> vA;
vA = std::move(upA);
std::unique_ptr<const volatile A> cvA;
cvA = std::move(upA);
}
void
test02()
{
std::unique_ptr<B> upB;
std::unique_ptr<const A> cA;
cA = std::move(upB);
std::unique_ptr<volatile A> vA;
vA = std::move(upB);
std::unique_ptr<const volatile A> cvA;
cvA = std::move(upB);
}
void
test03()
{
std::unique_ptr<A[]> upA;
std::unique_ptr<const A[]> cA;
cA = std::move(upA);
std::unique_ptr<volatile A[]> vA;
vA = std::move(upA);
std::unique_ptr<const volatile A[]> cvA;
cvA = std::move(upA);
}
struct A_pointer { operator A*() const { return nullptr; } };
template<typename T>
struct deleter
{
deleter() = default;
template<typename U>
deleter(const deleter<U>) { }
typedef T pointer;
void operator()(T) const { }
};
void
test04()
{
// Allow conversions from user-defined pointer-like types
std::unique_ptr<B[], deleter<A_pointer>> p;
std::unique_ptr<A[], deleter<A*>> upA;
upA = std::move(p);
}

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

@ -0,0 +1,58 @@
// { dg-do compile }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <memory>
struct A
{
};
struct B : A
{
virtual ~B() { }
};
// 20.7.1.3 unique_ptr for array objects [unique.ptr.runtime]
struct D
{
template<typename T>
void operator()(const T* p) const { delete[] p; }
};
// Conversion from different type of unique_ptr<T[], D>
void
test01()
{
std::unique_ptr<B[], D> b(new B[1]);
std::unique_ptr<A[], D> a(std::move(b)); //{ dg-error "no matching function" }
a = std::move(b); //{ dg-error "no match" }
}
// Conversion from non-array form of unique_ptr
void
test02()
{
std::unique_ptr<A> nonarray(new A);
std::unique_ptr<A[]> array(std::move(nonarray)); //{ dg-error "no matching function" }
array = std::move(nonarray); //{ dg-error "no match" }
}
// { dg-prune-output "include" }

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

@ -0,0 +1,38 @@
// { dg-do compile }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <memory>
struct A
{
};
// 20.7.1.3 unique_ptr for array objects [unique.ptr.runtime]
// Conversion to non-array form of unique_ptr
void
test01()
{
std::unique_ptr<A[]> array(new A[1]);
std::unique_ptr<A> nonarray(std::move(array)); //{ dg-error "no matching function" }
nonarray = std::move(array); //{ dg-error "no match" }
}
// { dg-prune-output "include" }

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

@ -0,0 +1,115 @@
// { dg-options "-std=gnu++11" }
// { dg-do compile }
// Copyright (C) 2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 20.7.1 Class template unique_ptr [unique.ptr]
#include <memory>
struct A { virtual ~A() = default; };
struct B : A { };
// Construction from objects with different cv-qualification
void
test01()
{
std::unique_ptr<const A> cA(new A);
std::unique_ptr<volatile A> vA(new A);
std::unique_ptr<const volatile A> cvA(new A);
}
void
test02()
{
std::unique_ptr<const A> cB(new B);
std::unique_ptr<volatile A> vB(new B);
std::unique_ptr<const volatile A> cvB(new B);
}
void
test03()
{
std::unique_ptr<A> upA;
std::unique_ptr<const A> cA(std::move(upA));
std::unique_ptr<volatile A> vA(std::move(upA));
std::unique_ptr<const volatile A> cvA(std::move(upA));
}
void
test04()
{
std::unique_ptr<B> upB;
std::unique_ptr<const A> cA(std::move(upB));
std::unique_ptr<volatile A> vA(std::move(upB));
std::unique_ptr<const volatile A> cvA(std::move(upB));
}
void
test05()
{
std::unique_ptr<const A[]> cA(new A[1]);
std::unique_ptr<volatile A[]> vA(new A[1]);
std::unique_ptr<const volatile A[]> cvA(new A[1]);
}
void
test06()
{
std::unique_ptr<A[]> upA;
std::unique_ptr<const A[]> cA(std::move(upA));
std::unique_ptr<volatile A[]> vA(std::move(upA));
std::unique_ptr<const volatile A[]> cvA(std::move(upA));
}
struct A_pointer { operator A*() const { return nullptr; } };
void
test07()
{
// Allow conversions from user-defined pointer-like types
A_pointer p;
std::unique_ptr<A[]> upA(p);
std::unique_ptr<const A[]> cA(p);
std::unique_ptr<volatile A[]> vA(p);
std::unique_ptr<const volatile A[]> cvA(p);
}
template<typename T>
struct deleter
{
deleter() = default;
template<typename U>
deleter(const deleter<U>) { }
typedef T pointer;
void operator()(T) const { }
};
void
test08()
{
// Allow conversions from user-defined pointer-like types
std::unique_ptr<B[], deleter<A_pointer>> p;
std::unique_ptr<A[], deleter<A*>> upA(std::move(p));
}

6
libstdc++-v3/testsuite/20_util/unique_ptr/cons/pointer_array_convertible_neg.cc
View File

@ -1,7 +1,7 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2008, 2009 Free Software Foundation
// Copyright (C) 2008-2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -29,7 +29,7 @@ struct B : A
virtual ~B() { }
};
// 20.4.5.1 unique_ptr constructors [unique.ptr.cons]
// 20.7.1.3.1 unique_ptr constructors [unique.ptr.runtime.ctor]
// Construction from pointer of derived type
void

13
libstdc++-v3/testsuite/20_util/unique_ptr/cons/ptr_deleter_neg.cc
View File

@ -1,7 +1,7 @@
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2010 Free Software Foundation
// Copyright (C) 2010-2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -18,10 +18,9 @@
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 20.6.11 Template class unique_ptr [unique.ptr]
// 20.7.1 Class template unique_ptr [unique.ptr]
#include <memory>
#include <testsuite_hooks.h>
using std::unique_ptr;
@ -30,9 +29,9 @@ using std::unique_ptr;
void
test01()
{
unique_ptr<int, void(*)(int*)> p1; // { dg-error "here" }
unique_ptr<long, void(*)(long*)> p1; // { dg-error "here" }
unique_ptr<int, void(*)(int*)> p2(nullptr); // { dg-error "here" }
unique_ptr<short, void(*)(short*)> p2(nullptr); // { dg-error "here" }
unique_ptr<int, void(*)(int*)> p3(new int); // { dg-error "here" }
}
@ -40,9 +39,9 @@ test01()
void
test02()
{
unique_ptr<int[], void(*)(int*)> p1; // { dg-error "here" }
unique_ptr<long[], void(*)(long*)> p1; // { dg-error "here" }
unique_ptr<int[], void(*)(int*)> p2(nullptr); // { dg-error "here" }
unique_ptr<short[], void(*)(short*)> p2(nullptr); // { dg-error "here" }
unique_ptr<int[], void(*)(int*)> p3(new int[1]); // { dg-error "here" }
}

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

@ -0,0 +1,79 @@
// { dg-options "-std=gnu++11" }
// { dg-do compile }
// Copyright (C) 2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 20.7.1 Class template unique_ptr [unique.ptr]
#include <memory>
struct A { virtual ~A() = default; };
struct B : A { };
// Construction from objects with different cv-qualification
void
test01()
{
std::unique_ptr<const A> cA;
cA.reset(new A);
std::unique_ptr<volatile A> vA;
vA.reset(new A);
std::unique_ptr<const volatile A> cvA;
cvA.reset(new A);
}
void
test02()
{
std::unique_ptr<const A> cB;
cB.reset(new B);
std::unique_ptr<volatile A> vB;
vB.reset(new B);
std::unique_ptr<const volatile A> cvB;
cvB.reset(new B);
}
void
test03()
{
std::unique_ptr<const A[]> cA;
cA.reset(new A[1]);
std::unique_ptr<volatile A[]> vA;
vA.reset(new A[1]);
std::unique_ptr<const volatile A[]> cvA;
cvA.reset(new A[1]);
}
struct A_pointer { operator A*() const { return nullptr; } };
void
test07()
{
// Allow conversions from user-defined pointer-like types
A_pointer p;
std::unique_ptr<A[]> upA;
upA.reset(p);
std::unique_ptr<const A[]> cA;
cA.reset(p);
std::unique_ptr<volatile A[]> vA;
vA.reset(p);
std::unique_ptr<const volatile A[]> cvA;
cvA.reset(p);
}

4
libstdc++-v3/testsuite/20_util/unique_ptr/modifiers/reset_neg.cc
View File

@ -1,7 +1,7 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2008, 2009, 2010 Free Software Foundation
// Copyright (C) 2008-2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -32,7 +32,7 @@ struct B : A
void test01()
{
std::unique_ptr<B[]> up;
up.reset(new A[3]); // { dg-error "deleted" }
up.reset(new A[3]); // { dg-error "invalid conversion" }
}
// { dg-prune-output "include" }

7
libstdc++-v3/testsuite/20_util/unique_ptr/requirements/pointer_type.cc
View File

@ -1,7 +1,7 @@
// { dg-do compile }
// { dg-options "-std=gnu++0x" }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2010, 2011 Free Software Foundation
// Copyright (C) 2010-2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
@ -18,10 +18,9 @@
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 20.6.11 Template class unique_ptr [unique.ptr.single]
// 20.7.1.2 unique_ptr for single objects [unique.ptr.single]
#include <memory>
#include <testsuite_hooks.h>
struct A
{

49
libstdc++-v3/testsuite/20_util/unique_ptr/requirements/pointer_type_array.cc Normal file
View File

@ -0,0 +1,49 @@
// { dg-do compile }
// { dg-options "-std=gnu++11" }
// Copyright (C) 2010-2012 Free Software Foundation
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
// 20.7.1.3 unique_ptr for array objects [unique.ptr.runtime]
#include <memory>
struct A
{
void operator()(void*) const { }
};
struct B
{
typedef char* pointer;
void operator()(pointer) const { }
};
int main()
{
typedef std::unique_ptr<int[]> up;
typedef std::unique_ptr<int[], A> upA;
typedef std::unique_ptr<int[], B> upB;
typedef std::unique_ptr<int[], A&> upAr;
typedef std::unique_ptr<int[], B&> upBr;
static_assert( std::is_same< up::pointer, int*>::value, "" );
static_assert( std::is_same< upA::pointer, int*>::value, "" );
static_assert( std::is_same< upB::pointer, char*>::value, "" );
static_assert( std::is_same< upAr::pointer, int*>::value, "" );
static_assert( std::is_same< upBr::pointer, char*>::value, "" );
}