+2011-11-09 Jonathan Wakely <jwakely.gcc@gmail.com>
+
+ * include/bits/stl_vector.h (vector::_Alloc_traits): Make private.
+ * include/debug/vector: Add allocator-extended constructors, ensure
+ move assignment and swap have same allocator propagation semantics
+ and exceptions specification as base class.
+ * include/profile/vector: Likewise.
+ (vector::push_back(_Tp&&)): Forward argument as rvalue.
+ * testsuite/23_containers/vector/debug/alloc_prop.cc: New.
+ * doc/xml/manual/status_cxx2011.xml: Clarify status of container
+ requirements with respect to allocators.
+ (status.iso.200x): Add anchor for old ID to preserve existing links.
+
2011-11-08 Jonathan Wakely <jwakely.gcc@gmail.com>
* include/bits/shared_ptr_base.h (_Sp_counted_ptr): Make 'final'.
</info>
<para>
+<anchor xml:id="status.iso.200x" /> <!-- preserve links to old section ID -->
This table is based on the table of contents of ISO/IEC
JTC1 SC22 WG21 Doc No: N3290 Date: 2011-04-11
Final Draft International Standard, Standard for Programming Language C++
<entry/>
</row>
<row>
+ <?dbhtml bgcolor="#B0B0B0" ?>
<entry>23.2.1</entry>
<entry>General container requirements</entry>
- <entry>Y</entry>
- <entry/>
+ <entry>Partial</entry>
+ <entry>Only <code>vector</code> meets the requirements
+ relating to allocator use and propagation.</entry>
</row>
<row>
<entry>23.2.2</entry>
typedef _Vector_base<_Tp, _Alloc> _Base;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+ typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
public:
typedef _Tp value_type;
typedef typename _Base::pointer pointer;
- typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;
typedef typename _Alloc_traits::const_pointer const_pointer;
typedef typename _Alloc_traits::reference reference;
typedef typename _Alloc_traits::const_reference const_reference;
typedef typename _Base::const_iterator _Base_const_iterator;
typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
public:
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
__x._M_guaranteed_capacity = 0;
}
+ vector(const vector& __x, const allocator_type& __a)
+ : _Base(__x, __a), _M_guaranteed_capacity(__x.size()) { }
+
+ vector(vector&& __x, const allocator_type& __a)
+ : _Base(std::move(__x), __a),
+ _M_guaranteed_capacity(this->size())
+ {
+ __x._M_invalidate_all();
+ __x._M_guaranteed_capacity = 0;
+ }
+
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a),
#ifdef __GXX_EXPERIMENTAL_CXX0X__
vector&
- operator=(vector&& __x)
+ operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
- // NB: DR 1204.
- // NB: DR 675.
- clear();
- swap(__x);
+ _Base::operator=(std::move(__x));
+ this->_M_invalidate_all();
+ _M_update_guaranteed_capacity();
+ __x._M_invalidate_all();
+ __x._M_guaranteed_capacity = 0;
return *this;
}
void
swap(vector& __x)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
{
_Base::swap(__x);
this->_M_swap(__x);
{
typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator> _Base;
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ typedef __gnu_cxx::__alloc_traits<_Allocator> _Alloc_traits;
+#endif
+
public:
typedef typename _Base::reference reference;
typedef typename _Base::const_reference const_reference;
__profcxx_vector_construct2(this);
}
+ vector(const _Base& __x, const _Allocator& __a)
+ : _Base(__x)
+ {
+ __profcxx_vector_construct(this, this->capacity());
+ __profcxx_vector_construct2(this);
+ }
+
+ vector(vector&& __x, const _Allocator& __a) noexcept
+ : _Base(std::move(__x), __a)
+ {
+ __profcxx_vector_construct(this, this->capacity());
+ __profcxx_vector_construct2(this);
+ }
+
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__l, __a) { }
#ifdef __GXX_EXPERIMENTAL_CXX0X__
vector&
- operator=(vector&& __x)
+ operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move())
{
- // NB: DR 1204.
- // NB: DR 675.
- this->clear();
- this->swap(__x);
+ __profcxx_vector_destruct(this, this->capacity(), this->size());
+ __profcxx_vector_destruct2(this);
+ static_cast<_Base&>(*this) = std::move(__x);
return *this;
}
push_back(_Tp&& __x)
{
size_type __old_size = this->capacity();
- _Base::push_back(__x);
+ _Base::push_back(std::move(__x));
_M_profile_resize(this, __old_size, this->capacity());
}
void
swap(vector& __x)
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+ noexcept(_Alloc_traits::_S_nothrow_swap())
+#endif
{
_Base::swap(__x);
}
--- /dev/null
+// Copyright (C) 2011 Free Software Foundation, Inc.
+//
+// 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/>.
+//
+// { dg-do compile }
+// { dg-options "-std=gnu++11" }
+
+#include <debug/vector>
+#include <type_traits>
+#include <testsuite_allocator.h>
+
+template<typename T, typename A>
+ void
+ test()
+ {
+ typedef std::vector<T, A> base;
+ typedef __gnu_debug::vector<T, A> debug;
+
+ using std::is_nothrow_default_constructible;
+ using std::is_nothrow_copy_constructible;
+ using std::is_nothrow_move_constructible;
+ using std::is_nothrow_copy_assignable;
+ using std::is_nothrow_move_assignable;
+
+ static_assert(
+ is_nothrow_default_constructible<base>::value
+ == is_nothrow_default_constructible<debug>::value,
+ "nothrow default constructible");
+
+ static_assert(
+ is_nothrow_copy_constructible<base>::value
+ == is_nothrow_copy_constructible<debug>::value,
+ "nothrow copy constructible");
+
+ static_assert(
+ is_nothrow_move_constructible<base>::value
+ == is_nothrow_move_constructible<debug>::value,
+ "nothrow move constructible");
+
+ static_assert(
+ is_nothrow_copy_assignable<base>::value
+ == is_nothrow_copy_assignable<debug>::value,
+ "nothrow move assignable");
+
+ static_assert(
+ is_nothrow_move_assignable<base>::value
+ == is_nothrow_move_assignable<debug>::value,
+ "nothrow move assignable");
+ }
+
+struct X
+{
+ X() { }
+ ~X() { }
+ X(const X&) { }
+ X(X&&) { }
+ X& operator=(const X&) { }
+ X& operator=(X&&) { }
+};
+
+int main()
+{
+ using __gnu_test::propagating_allocator;
+ using __gnu_test::SimpleAllocator;
+
+ test<int, std::allocator<int>>();
+ test<int, SimpleAllocator<int>>();
+ test<int, propagating_allocator<int, true>>();
+ test<int, propagating_allocator<int, false>>();
+ test<X, std::allocator<X>>();
+ test<X, SimpleAllocator<X>>();
+ test<X, propagating_allocator<X, true>>();
+ test<X, propagating_allocator<X, false>>();
+
+ return 0;
+}
OSDN Git Service
