FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

re PR libstdc++/8230 (Buggy allocator behaviour)

Browse source 
2002-11-15  Benjamin Kosnik  <bkoz@redhat.com>
            Gabriel Dos Reis  <gdr@integrable-solutions.net>

	PR libstdc++/8230
	* include/bits/stl_alloc.h: Use builtin_expect for the most
	obvious limit checks.
	(__default_alloc_template::allocate): Check for null, throw
	bad_alloc.
	* include/bits/vector.tcc: Formatting tweaks.
	* include/bits/stl_vector.h: Same.
	* testsuite/20_util/allocator_members.cc (test02): Add.
	* testsuite/23_containers/vector_capacity.cc (test03): Add.

Co-Authored-By: Gabriel Dos Reis <gdr@integrable-solutions.net>

From-SVN: r59169
This commit is contained in:
Benjamin Kosnik 2002-11-16 17:16:31 +00:00 • committed by Benjamin Kosnik
parent 5dab517fa0
commit af5fb6ab3b
6 changed files with 983 additions and 879 deletions
Download patch file Download diff file Expand all files Collapse all files

13
libstdc++-v3/ChangeLog
View file

@ -1,3 +1,16 @@
2002-11-15 Benjamin Kosnik <bkoz@redhat.com>
Gabriel Dos Reis <gdr@integrable-solutions.net>
PR libstdc++/8230
* include/bits/stl_alloc.h: Use builtin_expect for the most
obvious limit checks.
(__default_alloc_template::allocate): Check for null, throw
bad_alloc.
* include/bits/vector.tcc: Formatting tweaks.
* include/bits/stl_vector.h: Same.
* testsuite/20_util/allocator_members.cc (test02): Add.
* testsuite/23_containers/vector_capacity.cc (test03): Add.
2002-11-15 Rainer Orth <ro@TechFak.Uni-Bielefeld.DE> 2002-11-15 Rainer Orth <ro@TechFak.Uni-Bielefeld.DE>
* src/ios.cc [_GLIBCPP_HAVE_UNISTD_H]: Include unistd.h. * src/ios.cc [_GLIBCPP_HAVE_UNISTD_H]: Include unistd.h.

78
libstdc++-v3/include/bits/stl_alloc.h
View file

@ -139,7 +139,8 @@ namespace std
allocate(size_t __n) allocate(size_t __n)
{ {
void* __result = malloc(__n); void* __result = malloc(__n);
if (0 == __result) __result = _S_oom_malloc(__n); if (__builtin_expect(__result == 0, 0))
__result = _S_oom_malloc(__n);
return __result; return __result;
} }
@ -152,7 +153,7 @@ namespace std
reallocate(void* __p, size_t /* old_sz */, size_t __new_sz) reallocate(void* __p, size_t /* old_sz */, size_t __new_sz)
{ {
void* __result = realloc(__p, __new_sz); void* __result = realloc(__p, __new_sz);
if (0 == __result) if (__builtin_expect(__result == 0, 0))
__result = _S_oom_realloc(__p, __new_sz); __result = _S_oom_realloc(__p, __new_sz);
return __result; return __result;
} }
@ -181,8 +182,8 @@ namespace std
for (;;) for (;;)
{ {
__my_malloc_handler = __malloc_alloc_oom_handler; __my_malloc_handler = __malloc_alloc_oom_handler;
if (0 == __my_malloc_handler) if (__builtin_expect(__my_malloc_handler == 0, 0))
std::__throw_bad_alloc(); __throw_bad_alloc();
(*__my_malloc_handler)(); (*__my_malloc_handler)();
__result = malloc(__n); __result = malloc(__n);
if (__result) if (__result)
@ -202,8 +203,8 @@ namespace std
for (;;) for (;;)
{ {
__my_malloc_handler = __malloc_alloc_oom_handler; __my_malloc_handler = __malloc_alloc_oom_handler;
if (0 == __my_malloc_handler) if (__builtin_expect(__my_malloc_handler == 0, 0))
std::__throw_bad_alloc(); __throw_bad_alloc();
(*__my_malloc_handler)(); (*__my_malloc_handler)();
__result = realloc(__p, __n); __result = realloc(__p, __n);
if (__result) if (__result)
@ -232,7 +233,12 @@ namespace std
public: public:
static _Tp* static _Tp*
allocate(size_t __n) allocate(size_t __n)
{ return 0 == __n ? 0 : (_Tp*) _Alloc::allocate(__n * sizeof (_Tp)); } {
_Tp* __ret = 0;
if (__n)
__ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
return __ret;
}
static _Tp* static _Tp*
allocate() allocate()
@ -293,8 +299,8 @@ namespace std
{ {
char* __real_p = (char*)__p - (int) _S_extra; char* __real_p = (char*)__p - (int) _S_extra;
assert(*(size_t*)__real_p == __old_sz); assert(*(size_t*)__real_p == __old_sz);
char* __result = (char*) char* __result = (char*) _Alloc::reallocate(__real_p,
_Alloc::reallocate(__real_p, __old_sz + (int) _S_extra, __old_sz + (int) _S_extra,
__new_sz + (int) _S_extra); __new_sz + (int) _S_extra);
*(size_t*)__result = __new_sz; *(size_t*)__result = __new_sz;
return __result + (int) _S_extra; return __result + (int) _S_extra;
@ -362,7 +368,7 @@ namespace std
static size_t static size_t
_S_freelist_index(size_t __bytes) _S_freelist_index(size_t __bytes)
{ return (((__bytes) + (size_t)_ALIGN-1)/(size_t)_ALIGN - 1); } { return (((__bytes) + (size_t)_ALIGN - 1)/(size_t)_ALIGN - 1); }
// Returns an object of size __n, and optionally adds to size __n // Returns an object of size __n, and optionally adds to size __n
// free list. // free list.
@ -402,7 +408,7 @@ namespace std
else else
__atomic_add(&_S_force_new, -1); __atomic_add(&_S_force_new, -1);
// Trust but verify... // Trust but verify...
assert (_S_force_new != 0); assert(_S_force_new != 0);
} }
if ((__n > (size_t) _MAX_BYTES) || (_S_force_new > 0)) if ((__n > (size_t) _MAX_BYTES) || (_S_force_new > 0))
@ -416,13 +422,15 @@ namespace std
// unwinding. // unwinding.
_Lock __lock_instance; _Lock __lock_instance;
_Obj* __restrict__ __result = *__my_free_list; _Obj* __restrict__ __result = *__my_free_list;
if (__result == 0) if (__builtin_expect(__result == 0, 0))
__ret = _S_refill(_S_round_up(__n)); __ret = _S_refill(_S_round_up(__n));
else else
{ {
*__my_free_list = __result -> _M_free_list_link; *__my_free_list = __result -> _M_free_list_link;
__ret = __result; __ret = __result;
} }
if (__builtin_expect(__ret == 0, 0))
__throw_bad_alloc();
} }
return __ret; return __ret;
} }
@ -510,7 +518,7 @@ namespace std
*__my_free_list = (_Obj*)_S_start_free; *__my_free_list = (_Obj*)_S_start_free;
} }
_S_start_free = (char*) __new_alloc::allocate(__bytes_to_get); _S_start_free = (char*) __new_alloc::allocate(__bytes_to_get);
if (0 == _S_start_free) if (_S_start_free == 0)
{ {
size_t __i; size_t __i;
_Obj* volatile* __my_free_list; _Obj* volatile* __my_free_list;
@ -523,7 +531,7 @@ namespace std
{ {
__my_free_list = _S_free_list + _S_freelist_index(__i); __my_free_list = _S_free_list + _S_freelist_index(__i);
__p = *__my_free_list; __p = *__my_free_list;
if (0 != __p) if (__p != 0)
{ {
*__my_free_list = __p -> _M_free_list_link; *__my_free_list = __p -> _M_free_list_link;
_S_start_free = (char*)__p; _S_start_free = (char*)__p;
@ -579,7 +587,7 @@ namespace std
else else
__current_obj -> _M_free_list_link = __next_obj; __current_obj -> _M_free_list_link = __next_obj;
} }
return(__result); return __result;
} }
@ -600,7 +608,7 @@ namespace std
__copy_sz = __new_sz > __old_sz? __old_sz : __new_sz; __copy_sz = __new_sz > __old_sz? __old_sz : __new_sz;
memcpy(__result, __p, __copy_sz); memcpy(__result, __p, __copy_sz);
deallocate(__p, __old_sz); deallocate(__p, __old_sz);
return(__result); return __result;
} }
#endif #endif
@ -669,13 +677,20 @@ namespace std
const_pointer const_pointer
address(const_reference __x) const { return &__x; } address(const_reference __x) const { return &__x; }
// __n is permitted to be 0. The C++ standard says nothing about what // NB: __n is permitted to be 0. The C++ standard says nothing
// the return value is when __n == 0. // about what the return value is when __n == 0.
_Tp* _Tp*
allocate(size_type __n, const void* = 0) allocate(size_type __n, const void* = 0)
{ {
return __n != 0 _Tp* __ret = 0;
? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp))) : 0; if (__n)
{
if (__n <= this->max_size())
__ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
else
__throw_bad_alloc();
}
return __ret;
} }
// __p is not permitted to be a null pointer. // __p is not permitted to be a null pointer.
@ -719,12 +734,13 @@ namespace std
/** /**
* @if maint * @if maint
* Allocator adaptor to turn an "SGI" style allocator (e.g., __alloc, * Allocator adaptor to turn an "SGI" style allocator (e.g.,
* __malloc_alloc_template) into a "standard" conforming allocator. Note * __alloc, __malloc_alloc_template) into a "standard" conforming
* that this adaptor does *not* assume that all objects of the underlying * allocator. Note that this adaptor does *not* assume that all
* alloc class are identical, nor does it assume that all of the underlying * objects of the underlying alloc class are identical, nor does it
* alloc's member functions are static member functions. Note, also, that * assume that all of the underlying alloc's member functions are
* __allocator<_Tp, __alloc> is essentially the same thing as allocator<_Tp>. * static member functions. Note, also, that __allocator<_Tp,
* __alloc> is essentially the same thing as allocator<_Tp>.
* @endif * @endif
* (See @link Allocators allocators info @endlink for more.) * (See @link Allocators allocators info @endlink for more.)
*/ */
@ -761,13 +777,15 @@ namespace std
const_pointer const_pointer
address(const_reference __x) const { return &__x; } address(const_reference __x) const { return &__x; }
// __n is permitted to be 0. // NB: __n is permitted to be 0. The C++ standard says nothing
// about what the return value is when __n == 0.
_Tp* _Tp*
allocate(size_type __n, const void* = 0) allocate(size_type __n, const void* = 0)
{ {
return __n != 0 _Tp* __ret = 0;
? static_cast<_Tp*>(__underlying_alloc.allocate(__n * sizeof(_Tp))) if (__n)
: 0; __ret = static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp)));
return __ret;
} }
// __p is not permitted to be a null pointer. // __p is not permitted to be a null pointer.

313
libstdc++-v3/include/bits/stl_vector.h
View file

@ -73,7 +73,7 @@ namespace std
* See bits/stl_deque.h's _Deque_alloc_base for an explanation. * See bits/stl_deque.h's _Deque_alloc_base for an explanation.
* @endif * @endif
*/ */
template <typename _Tp, typename _Allocator, bool _IsStatic> template<typename _Tp, typename _Allocator, bool _IsStatic>
class _Vector_alloc_base class _Vector_alloc_base
{ {
public: public:
@ -85,7 +85,7 @@ namespace std
_Vector_alloc_base(const allocator_type& __a) _Vector_alloc_base(const allocator_type& __a)
: _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0) : _M_data_allocator(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
{} { }
protected: protected:
allocator_type _M_data_allocator; allocator_type _M_data_allocator;
@ -102,7 +102,7 @@ namespace std
}; };
/// @if maint Specialization for instanceless allocators. @endif /// @if maint Specialization for instanceless allocators. @endif
template <typename _Tp, typename _Allocator> template<typename _Tp, typename _Allocator>
class _Vector_alloc_base<_Tp, _Allocator, true> class _Vector_alloc_base<_Tp, _Allocator, true>
{ {
public: public:
@ -114,7 +114,7 @@ namespace std
_Vector_alloc_base(const allocator_type&) _Vector_alloc_base(const allocator_type&)
: _M_start(0), _M_finish(0), _M_end_of_storage(0) : _M_start(0), _M_finish(0), _M_end_of_storage(0)
{} { }
protected: protected:
_Tp* _M_start; _Tp* _M_start;
@ -136,7 +136,7 @@ namespace std
* See bits/stl_deque.h's _Deque_base for an explanation. * See bits/stl_deque.h's _Deque_base for an explanation.
* @endif * @endif
*/ */
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
struct _Vector_base struct _Vector_base
: public _Vector_alloc_base<_Tp, _Alloc, : public _Vector_alloc_base<_Tp, _Alloc,
_Alloc_traits<_Tp, _Alloc>::_S_instanceless> _Alloc_traits<_Tp, _Alloc>::_S_instanceless>
@ -148,7 +148,8 @@ namespace std
typedef typename _Base::allocator_type allocator_type; typedef typename _Base::allocator_type allocator_type;
_Vector_base(const allocator_type& __a) _Vector_base(const allocator_type& __a)
: _Base(__a) {} : _Base(__a) { }
_Vector_base(size_t __n, const allocator_type& __a) _Vector_base(size_t __n, const allocator_type& __a)
: _Base(__a) : _Base(__a)
{ {
@ -157,7 +158,8 @@ namespace std
_M_end_of_storage = _M_start + __n; _M_end_of_storage = _M_start + __n;
} }
~_Vector_base() { _M_deallocate(_M_start, _M_end_of_storage - _M_start); } ~_Vector_base()
{ _M_deallocate(_M_start, _M_end_of_storage - _M_start); }
}; };
@ -179,10 +181,10 @@ namespace std
* and saves the user from worrying about memory and size allocation. * and saves the user from worrying about memory and size allocation.
* Subscripting ( @c [] ) access is also provided as with C-style arrays. * Subscripting ( @c [] ) access is also provided as with C-style arrays.
*/ */
template <typename _Tp, typename _Alloc = allocator<_Tp> > template<typename _Tp, typename _Alloc = allocator<_Tp> >
class vector : protected _Vector_base<_Tp, _Alloc> class vector : protected _Vector_base<_Tp, _Alloc>
{ {
// concept requirements // Concept requirements.
__glibcpp_class_requires(_Tp, _SGIAssignableConcept) __glibcpp_class_requires(_Tp, _SGIAssignableConcept)
typedef _Vector_base<_Tp, _Alloc> _Base; typedef _Vector_base<_Tp, _Alloc> _Base;
@ -205,11 +207,10 @@ namespace std
protected: protected:
/** @if maint /** @if maint
* These two functions and three data members are all from the top-most * These two functions and three data members are all from the
* base class, which varies depending on the type of %allocator. They * top-most base class, which varies depending on the type of
* should be pretty self-explanatory, as %vector uses a simple contiguous * %allocator. They should be pretty self-explanatory, as
* allocation scheme. * %vector uses a simple contiguous allocation scheme. @endif
* @endif
*/ */
using _Base::_M_allocate; using _Base::_M_allocate;
using _Base::_M_deallocate; using _Base::_M_deallocate;
@ -225,7 +226,7 @@ namespace std
*/ */
explicit explicit
vector(const allocator_type& __a = allocator_type()) vector(const allocator_type& __a = allocator_type())
: _Base(__a) {} : _Base(__a) { }
/** /**
* @brief Create a %vector with copies of an exemplar element. * @brief Create a %vector with copies of an exemplar element.
@ -255,8 +256,9 @@ namespace std
* @brief %Vector copy constructor. * @brief %Vector copy constructor.
* @param x A %vector of identical element and allocator types. * @param x A %vector of identical element and allocator types.
* *
* The newly-created %vector uses a copy of the allocation object used * The newly-created %vector uses a copy of the allocation
* by @a x. All the elements of @a x are copied, but any extra memory in * object used by @a x. All the elements of @a x are copied,
* but any extra memory in
* @a x (for fast expansion) will not be copied. * @a x (for fast expansion) will not be copied.
*/ */
vector(const vector& __x) vector(const vector& __x)
@ -268,7 +270,8 @@ namespace std
* @param first An input iterator. * @param first An input iterator.
* @param last An input iterator. * @param last An input iterator.
* *
* Create a %vector consisting of copies of the elements from [first,last). * Create a %vector consisting of copies of the elements from
* [first,last).
* *
* If the iterators are forward, bidirectional, or random-access, then * If the iterators are forward, bidirectional, or random-access, then
* this will call the elements' copy constructor N times (where N is * this will call the elements' copy constructor N times (where N is
@ -276,7 +279,7 @@ namespace std
* input iterators are used, then this will do at most 2N calls to the * input iterators are used, then this will do at most 2N calls to the
* copy constructor, and logN memory reallocations. * copy constructor, and logN memory reallocations.
*/ */
template <typename _InputIterator> template<typename _InputIterator>
vector(_InputIterator __first, _InputIterator __last, vector(_InputIterator __first, _InputIterator __last,
const allocator_type& __a = allocator_type()) const allocator_type& __a = allocator_type())
: _Base(__a) : _Base(__a)
@ -297,9 +300,9 @@ namespace std
* @brief %Vector assignment operator. * @brief %Vector assignment operator.
* @param x A %vector of identical element and allocator types. * @param x A %vector of identical element and allocator types.
* *
* All the elements of @a x are copied, but any extra memory in @a x (for * All the elements of @a x are copied, but any extra memory in
* fast expansion) will not be copied. Unlike the copy constructor, the * @a x (for fast expansion) will not be copied. Unlike the
* allocator object is not copied. * copy constructor, the allocator object is not copied.
*/ */
vector& vector&
operator=(const vector& __x); operator=(const vector& __x);
@ -309,13 +312,14 @@ namespace std
* @param n Number of elements to be assigned. * @param n Number of elements to be assigned.
* @param val Value to be assigned. * @param val Value to be assigned.
* *
* This function fills a %vector with @a n copies of the given value. * This function fills a %vector with @a n copies of the given
* Note that the assignment completely changes the %vector and that the * value. Note that the assignment completely changes the
* resulting %vector's size is the same as the number of elements assigned. * %vector and that the resulting %vector's size is the same as
* Old data may be lost. * the number of elements assigned. Old data may be lost.
*/ */
void void
assign(size_type __n, const value_type& __val) { _M_fill_assign(__n, __val); } assign(size_type __n, const value_type& __val)
{ _M_fill_assign(__n, __val); }
/** /**
* @brief Assigns a range to a %vector. * @brief Assigns a range to a %vector.
@ -325,9 +329,9 @@ namespace std
* This function fills a %vector with copies of the elements in the * This function fills a %vector with copies of the elements in the
* range [first,last). * range [first,last).
* *
* Note that the assignment completely changes the %vector and that the * Note that the assignment completely changes the %vector and
* resulting %vector's size is the same as the number of elements assigned. * that the resulting %vector's size is the same as the number
* Old data may be lost. * of elements assigned. Old data may be lost.
*/ */
template<typename _InputIterator> template<typename _InputIterator>
void void
@ -351,15 +355,17 @@ namespace std
begin() { return iterator (_M_start); } begin() { return iterator (_M_start); }
/** /**
* Returns a read-only (constant) iterator that points to the first element * Returns a read-only (constant) iterator that points to the
* in the %vector. Iteration is done in ordinary element order. * first element in the %vector. Iteration is done in ordinary
* element order.
*/ */
const_iterator const_iterator
begin() const { return const_iterator (_M_start); } begin() const { return const_iterator (_M_start); }
/** /**
* Returns a read/write iterator that points one past the last element in * Returns a read/write iterator that points one past the last
* the %vector. Iteration is done in ordinary element order. * element in the %vector. Iteration is done in ordinary
* element order.
*/ */
iterator iterator
end() { return iterator (_M_finish); } end() { return iterator (_M_finish); }
@ -372,15 +378,17 @@ namespace std
end() const { return const_iterator (_M_finish); } end() const { return const_iterator (_M_finish); }
/** /**
* Returns a read/write reverse iterator that points to the last element in * Returns a read/write reverse iterator that points to the
* the %vector. Iteration is done in reverse element order. * last element in the %vector. Iteration is done in reverse
* element order.
*/ */
reverse_iterator reverse_iterator
rbegin() { return reverse_iterator(end()); } rbegin() { return reverse_iterator(end()); }
/** /**
* Returns a read-only (constant) reverse iterator that points to the last * Returns a read-only (constant) reverse iterator that points
* element in the %vector. Iteration is done in reverse element order. * to the last element in the %vector. Iteration is done in
* reverse element order.
*/ */
const_reverse_iterator const_reverse_iterator
rbegin() const { return const_reverse_iterator(end()); } rbegin() const { return const_reverse_iterator(end()); }
@ -394,9 +402,9 @@ namespace std
rend() { return reverse_iterator(begin()); } rend() { return reverse_iterator(begin()); }
/** /**
* Returns a read-only (constant) reverse iterator that points to one * Returns a read-only (constant) reverse iterator that points
* before the first element in the %vector. Iteration is done in reverse * to one before the first element in the %vector. Iteration
* element order. * is done in reverse element order.
*/ */
const_reverse_iterator const_reverse_iterator
rend() const { return const_reverse_iterator(begin()); } rend() const { return const_reverse_iterator(begin()); }
@ -415,10 +423,11 @@ namespace std
* @param new_size Number of elements the %vector should contain. * @param new_size Number of elements the %vector should contain.
* @param x Data with which new elements should be populated. * @param x Data with which new elements should be populated.
* *
* This function will %resize the %vector to the specified number of * This function will %resize the %vector to the specified
* elements. If the number is smaller than the %vector's current size the * number of elements. If the number is smaller than the
* %vector is truncated, otherwise the %vector is extended and new elements * %vector's current size the %vector is truncated, otherwise
* are populated with given data. * the %vector is extended and new elements are populated with
* given data.
*/ */
void void
resize(size_type __new_size, const value_type& __x) resize(size_type __new_size, const value_type& __x)
@ -433,10 +442,11 @@ namespace std
* @brief Resizes the %vector to the specified number of elements. * @brief Resizes the %vector to the specified number of elements.
* @param new_size Number of elements the %vector should contain. * @param new_size Number of elements the %vector should contain.
* *
* This function will resize the %vector to the specified number of * This function will resize the %vector to the specified
* elements. If the number is smaller than the %vector's current size the * number of elements. If the number is smaller than the
* %vector is truncated, otherwise the %vector is extended and new elements * %vector's current size the %vector is truncated, otherwise
* are default-constructed. * the %vector is extended and new elements are
* default-constructed.
*/ */
void void
resize(size_type __new_size) { resize(__new_size, value_type()); } resize(size_type __new_size) { resize(__new_size, value_type()); }
@ -450,7 +460,8 @@ namespace std
{ return size_type(const_iterator(_M_end_of_storage) - begin()); } { return size_type(const_iterator(_M_end_of_storage) - begin()); }
/** /**
* Returns true if the %vector is empty. (Thus begin() would equal end().) * Returns true if the %vector is empty. (Thus begin() would
* equal end().)
*/ */
bool bool
empty() const { return begin() == end(); } empty() const { return begin() == end(); }
@ -461,14 +472,16 @@ namespace std
* @param n Number of elements required. * @param n Number of elements required.
* @throw std::length_error If @a n exceeds @c max_size(). * @throw std::length_error If @a n exceeds @c max_size().
* *
* This function attempts to reserve enough memory for the %vector to hold * This function attempts to reserve enough memory for the
* the specified number of elements. If the number requested is more than * %vector to hold the specified number of elements. If the
* max_size(), length_error is thrown. * number requested is more than max_size(), length_error is
* thrown.
* *
* The advantage of this function is that if optimal code is a necessity * The advantage of this function is that if optimal code is a
* and the user can determine the number of elements that will be required, * necessity and the user can determine the number of elements
* the user can reserve the memory in %advance, and thus prevent a possible * that will be required, the user can reserve the memory in
* reallocation of memory and copying of %vector data. * %advance, and thus prevent a possible reallocation of memory
* and copying of %vector data.
*/ */
void void
reserve(size_type __n); reserve(size_type __n);
@ -480,20 +493,23 @@ namespace std
* @return Read/write reference to data. * @return Read/write reference to data.
* *
* This operator allows for easy, array-style, data access. * This operator allows for easy, array-style, data access.
* Note that data access with this operator is unchecked and out_of_range * Note that data access with this operator is unchecked and
* lookups are not defined. (For checked lookups see at().) * out_of_range lookups are not defined. (For checked lookups
* see at().)
*/ */
reference reference
operator[](size_type __n) { return *(begin() + __n); } operator[](size_type __n) { return *(begin() + __n); }
/** /**
* @brief Subscript access to the data contained in the %vector. * @brief Subscript access to the data contained in the %vector.
* @param n The index of the element for which data should be accessed. * @param n The index of the element for which data should be
* accessed.
* @return Read-only (constant) reference to data. * @return Read-only (constant) reference to data.
* *
* This operator allows for easy, array-style, data access. * This operator allows for easy, array-style, data access.
* Note that data access with this operator is unchecked and out_of_range * Note that data access with this operator is unchecked and
* lookups are not defined. (For checked lookups see at().) * out_of_range lookups are not defined. (For checked lookups
* see at().)
*/ */
const_reference const_reference
operator[](size_type __n) const { return *(begin() + __n); } operator[](size_type __n) const { return *(begin() + __n); }
@ -510,7 +526,8 @@ namespace std
public: public:
/** /**
* @brief Provides access to the data contained in the %vector. * @brief Provides access to the data contained in the %vector.
* @param n The index of the element for which data should be accessed. * @param n The index of the element for which data should be
* accessed.
* @return Read/write reference to data. * @return Read/write reference to data.
* @throw std::out_of_range If @a n is an invalid index. * @throw std::out_of_range If @a n is an invalid index.
* *
@ -523,20 +540,21 @@ namespace std
/** /**
* @brief Provides access to the data contained in the %vector. * @brief Provides access to the data contained in the %vector.
* @param n The index of the element for which data should be accessed. * @param n The index of the element for which data should be
* accessed.
* @return Read-only (constant) reference to data. * @return Read-only (constant) reference to data.
* @throw std::out_of_range If @a n is an invalid index. * @throw std::out_of_range If @a n is an invalid index.
* *
* This function provides for safer data access. The parameter is first * This function provides for safer data access. The parameter
* checked that it is in the range of the vector. The function throws * is first checked that it is in the range of the vector. The
* out_of_range if the check fails. * function throws out_of_range if the check fails.
*/ */
const_reference const_reference
at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; } at(size_type __n) const { _M_range_check(__n); return (*this)[__n]; }
/** /**
* Returns a read/write reference to the data at the first element of the * Returns a read/write reference to the data at the first
* %vector. * element of the %vector.
*/ */
reference reference
front() { return *begin(); } front() { return *begin(); }
@ -567,10 +585,11 @@ namespace std
* @brief Add data to the end of the %vector. * @brief Add data to the end of the %vector.
* @param x Data to be added. * @param x Data to be added.
* *
* This is a typical stack operation. The function creates an element at * This is a typical stack operation. The function creates an
* the end of the %vector and assigns the given data to it. * element at the end of the %vector and assigns the given data
* Due to the nature of a %vector this operation can be done in constant * to it. Due to the nature of a %vector this operation can be
* time if the %vector has preallocated space available. * done in constant time if the %vector has preallocated space
* available.
*/ */
void void
push_back(const value_type& __x) push_back(const value_type& __x)
@ -605,34 +624,34 @@ namespace std
* @param x Data to be inserted. * @param x Data to be inserted.
* @return An iterator that points to the inserted data. * @return An iterator that points to the inserted data.
* *
* This function will insert a copy of the given value before the specified * This function will insert a copy of the given value before
* location. * the specified location. Note that this kind of operation
* Note that this kind of operation could be expensive for a %vector and if * could be expensive for a %vector and if it is frequently
* it is frequently used the user should consider using std::list. * used the user should consider using std::list.
*/ */
iterator iterator
insert(iterator __position, const value_type& __x); insert(iterator __position, const value_type& __x);
#ifdef _GLIBCPP_DEPRECATED #ifdef _GLIBCPP_DEPRECATED
/** /**
* @brief Inserts an element into the %vector. * @brief Inserts an element into the %vector.
* @param position An iterator into the %vector. * @param position An iterator into the %vector.
* @return An iterator that points to the inserted element. * @return An iterator that points to the inserted element.
* *
* This function will insert a default-constructed element before the * This function will insert a default-constructed element
* specified location. You should consider using * before the specified location. You should consider using
* insert(position,value_type()) instead. * insert(position,value_type()) instead. Note that this kind
* Note that this kind of operation could be expensive for a vector and if * of operation could be expensive for a vector and if it is
* it is frequently used the user should consider using std::list. * frequently used the user should consider using std::list.
* *
* @note This was deprecated in 3.2 and will be removed in 3.4. You must * @note This was deprecated in 3.2 and will be removed in 3.4.
* define @c _GLIBCPP_DEPRECATED to make this visible in 3.2; see * You must define @c _GLIBCPP_DEPRECATED to make this visible
* c++config.h. * in 3.2; see c++config.h.
*/ */
iterator iterator
insert(iterator __position) insert(iterator __position)
{ return insert(__position, value_type()); } { return insert(__position, value_type()); }
#endif #endif
/** /**
* @brief Inserts a number of copies of given data into the %vector. * @brief Inserts a number of copies of given data into the %vector.
@ -640,14 +659,15 @@ namespace std
* @param n Number of elements to be inserted. * @param n Number of elements to be inserted.
* @param x Data to be inserted. * @param x Data to be inserted.
* *
* This function will insert a specified number of copies of the given data * This function will insert a specified number of copies of
* before the location specified by @a position. * the given data before the location specified by @a position.
* *
* Note that this kind of operation could be expensive for a %vector and if * Note that this kind of operation could be expensive for a
* it is frequently used the user should consider using std::list. * %vector and if it is frequently used the user should
* consider using std::list.
*/ */
void void
insert (iterator __pos, size_type __n, const value_type& __x) insert(iterator __pos, size_type __n, const value_type& __x)
{ _M_fill_insert(__pos, __n, __x); } { _M_fill_insert(__pos, __n, __x); }
/** /**
@ -656,11 +676,13 @@ namespace std
* @param first An input iterator. * @param first An input iterator.
* @param last An input iterator. * @param last An input iterator.
* *
* This function will insert copies of the data in the range [first,last) * This function will insert copies of the data in the range
* into the %vector before the location specified by @a pos. * [first,last) into the %vector before the location specified
* by @a pos.
* *
* Note that this kind of operation could be expensive for a %vector and if * Note that this kind of operation could be expensive for a
* it is frequently used the user should consider using std::list. * %vector and if it is frequently used the user should
* consider using std::list.
*/ */
template<typename _InputIterator> template<typename _InputIterator>
void void
@ -679,10 +701,11 @@ namespace std
* This function will erase the element at the given position and thus * This function will erase the element at the given position and thus
* shorten the %vector by one. * shorten the %vector by one.
* *
* Note This operation could be expensive and if it is frequently used the * Note This operation could be expensive and if it is
* user should consider using std::list. The user is also cautioned that * frequently used the user should consider using std::list.
* this function only erases the element, and that if the element is itself * The user is also cautioned that this function only erases
* a pointer, the pointed-to memory is not touched in any way. Managing * the element, and that if the element is itself a pointer,
* the pointed-to memory is not touched in any way. Managing
* the pointer is the user's responsibilty. * the pointer is the user's responsibilty.
*/ */
iterator iterator
@ -699,11 +722,12 @@ namespace std
* This function will erase the elements in the range [first,last) and * This function will erase the elements in the range [first,last) and
* shorten the %vector accordingly. * shorten the %vector accordingly.
* *
* Note This operation could be expensive and if it is frequently used the * Note This operation could be expensive and if it is
* user should consider using std::list. The user is also cautioned that * frequently used the user should consider using std::list.
* this function only erases the elements, and that if the elements * The user is also cautioned that this function only erases
* themselves are pointers, the pointed-to memory is not touched in any * the elements, and that if the elements themselves are
* way. Managing the pointer is the user's responsibilty. * pointers, the pointed-to memory is not touched in any way.
* Managing the pointer is the user's responsibilty.
*/ */
iterator iterator
erase(iterator __first, iterator __last); erase(iterator __first, iterator __last);
@ -741,7 +765,7 @@ namespace std
* obtain @a n bytes of memory, and then copies [first,last) into it. * obtain @a n bytes of memory, and then copies [first,last) into it.
* @endif * @endif
*/ */
template <typename _ForwardIterator> template<typename _ForwardIterator>
pointer pointer
_M_allocate_and_copy(size_type __n, _M_allocate_and_copy(size_type __n,
_ForwardIterator __first, _ForwardIterator __last) _ForwardIterator __first, _ForwardIterator __last)
@ -762,7 +786,7 @@ namespace std
// Internal constructor functions follow. // Internal constructor functions follow.
// called by the range constructor to implement [23.1.1]/9 // Called by the range constructor to implement [23.1.1]/9
template<typename _Integer> template<typename _Integer>
void void
_M_initialize_dispatch(_Integer __n, _Integer __value, __true_type) _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
@ -772,7 +796,7 @@ namespace std
_M_finish = uninitialized_fill_n(_M_start, __n, __value); _M_finish = uninitialized_fill_n(_M_start, __n, __value);
} }
// called by the range constructor to implement [23.1.1]/9 // Called by the range constructor to implement [23.1.1]/9
template<typename _InputIter> template<typename _InputIter>
void void
_M_initialize_dispatch(_InputIter __first, _InputIter __last, _M_initialize_dispatch(_InputIter __first, _InputIter __last,
@ -783,8 +807,8 @@ namespace std
_M_range_initialize(__first, __last, _IterCategory()); _M_range_initialize(__first, __last, _IterCategory());
} }
// called by the second initialize_dispatch above // Called by the second initialize_dispatch above
template <typename _InputIterator> template<typename _InputIterator>
void void
_M_range_initialize(_InputIterator __first, _M_range_initialize(_InputIterator __first,
_InputIterator __last, input_iterator_tag) _InputIterator __last, input_iterator_tag)
@ -793,9 +817,10 @@ namespace std
push_back(*__first); push_back(*__first);
} }
// called by the second initialize_dispatch above // Called by the second initialize_dispatch above
template <typename _ForwardIterator> template<typename _ForwardIterator>
void _M_range_initialize(_ForwardIterator __first, void
_M_range_initialize(_ForwardIterator __first,
_ForwardIterator __last, forward_iterator_tag) _ForwardIterator __last, forward_iterator_tag)
{ {
size_type __n = distance(__first, __last); size_type __n = distance(__first, __last);
@ -808,7 +833,7 @@ namespace std
// Internal assign functions follow. The *_aux functions do the actual // Internal assign functions follow. The *_aux functions do the actual
// assignment work for the range versions. // assignment work for the range versions.
// called by the range assign to implement [23.1.1]/9 // Called by the range assign to implement [23.1.1]/9
template<typename _Integer> template<typename _Integer>
void void
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type) _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
@ -817,7 +842,7 @@ namespace std
static_cast<value_type>(__val)); static_cast<value_type>(__val));
} }
// called by the range assign to implement [23.1.1]/9 // Called by the range assign to implement [23.1.1]/9
template<typename _InputIter> template<typename _InputIter>
void void
_M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type) _M_assign_dispatch(_InputIter __first, _InputIter __last, __false_type)
@ -827,27 +852,27 @@ namespace std
_M_assign_aux(__first, __last, _IterCategory()); _M_assign_aux(__first, __last, _IterCategory());
} }
// called by the second assign_dispatch above // Called by the second assign_dispatch above
template <typename _InputIterator> template<typename _InputIterator>
void void
_M_assign_aux(_InputIterator __first, _InputIterator __last, _M_assign_aux(_InputIterator __first, _InputIterator __last,
input_iterator_tag); input_iterator_tag);
// called by the second assign_dispatch above // Called by the second assign_dispatch above
template <typename _ForwardIterator> template<typename _ForwardIterator>
void void
_M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag); forward_iterator_tag);
// Called by assign(n,t), and the range assign when it turns out to be the // Called by assign(n,t), and the range assign when it turns out
// same thing. // to be the same thing.
void void
_M_fill_assign(size_type __n, const value_type& __val); _M_fill_assign(size_type __n, const value_type& __val);
// Internal insert functions follow. // Internal insert functions follow.
// called by the range insert to implement [23.1.1]/9 // Called by the range insert to implement [23.1.1]/9
template<typename _Integer> template<typename _Integer>
void void
_M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
@ -857,7 +882,7 @@ namespace std
static_cast<value_type>(__val)); static_cast<value_type>(__val));
} }
// called by the range insert to implement [23.1.1]/9 // Called by the range insert to implement [23.1.1]/9
template<typename _InputIterator> template<typename _InputIterator>
void void
_M_insert_dispatch(iterator __pos, _InputIterator __first, _M_insert_dispatch(iterator __pos, _InputIterator __first,
@ -868,33 +893,31 @@ namespace std
_M_range_insert(__pos, __first, __last, _IterCategory()); _M_range_insert(__pos, __first, __last, _IterCategory());
} }
// called by the second insert_dispatch above // Called by the second insert_dispatch above
template <typename _InputIterator> template<typename _InputIterator>
void void
_M_range_insert(iterator __pos, _M_range_insert(iterator __pos, _InputIterator __first,
_InputIterator __first, _InputIterator __last, _InputIterator __last, input_iterator_tag);
input_iterator_tag);
// called by the second insert_dispatch above // Called by the second insert_dispatch above
template <typename _ForwardIterator> template<typename _ForwardIterator>
void void
_M_range_insert(iterator __pos, _M_range_insert(iterator __pos, _ForwardIterator __first,
_ForwardIterator __first, _ForwardIterator __last, _ForwardIterator __last, forward_iterator_tag);
forward_iterator_tag);
// Called by insert(p,n,x), and the range insert when it turns out to be // Called by insert(p,n,x), and the range insert when it turns out to be
// the same thing. // the same thing.
void void
_M_fill_insert (iterator __pos, size_type __n, const value_type& __x); _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
// called by insert(p,x) // Called by insert(p,x)
void void
_M_insert_aux(iterator __position, const value_type& __x); _M_insert_aux(iterator __position, const value_type& __x);
#ifdef _GLIBCPP_DEPRECATED #ifdef _GLIBCPP_DEPRECATED
// unused now (same situation as in deque) // Unused now (same situation as in deque)
void _M_insert_aux(iterator __position); void _M_insert_aux(iterator __position);
#endif #endif
}; };
@ -908,7 +931,7 @@ namespace std
* vectors. Vectors are considered equivalent if their sizes are equal, * vectors. Vectors are considered equivalent if their sizes are equal,
* and if corresponding elements compare equal. * and if corresponding elements compare equal.
*/ */
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
inline bool inline bool
operator==(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) operator==(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y)
{ {
@ -927,7 +950,7 @@ namespace std
* *
* See std::lexographical_compare() for how the determination is made. * See std::lexographical_compare() for how the determination is made.
*/ */
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
inline bool inline bool
operator<(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) operator<(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y)
{ {
@ -936,31 +959,31 @@ namespace std
} }
/// Based on operator== /// Based on operator==
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
inline bool inline bool
operator!=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) operator!=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y)
{ return !(__x == __y); } { return !(__x == __y); }
/// Based on operator< /// Based on operator<
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
inline bool inline bool
operator>(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) operator>(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y)
{ return __y < __x; } { return __y < __x; }
/// Based on operator< /// Based on operator<
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
inline bool inline bool
operator<=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) operator<=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y)
{ return !(__y < __x); } { return !(__y < __x); }
/// Based on operator< /// Based on operator<
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
inline bool inline bool
operator>=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y) operator>=(const vector<_Tp,_Alloc>& __x, const vector<_Tp,_Alloc>& __y)
{ return !(__x < __y); } { return !(__x < __y); }
/// See std::vector::swap(). /// See std::vector::swap().
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
inline void inline void
swap(vector<_Tp,_Alloc>& __x, vector<_Tp,_Alloc>& __y) swap(vector<_Tp,_Alloc>& __x, vector<_Tp,_Alloc>& __y)
{ __x.swap(__y); } { __x.swap(__y); }

38
libstdc++-v3/include/bits/vector.tcc
View file

@ -63,7 +63,7 @@
namespace std namespace std
{ {
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
reserve(size_type __n) reserve(size_type __n)
@ -82,7 +82,7 @@ namespace std
} }
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
typename vector<_Tp,_Alloc>::iterator typename vector<_Tp,_Alloc>::iterator
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
insert(iterator __position, const value_type& __x) insert(iterator __position, const value_type& __x)
@ -98,7 +98,7 @@ namespace std
return begin() + __n; return begin() + __n;
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
typename vector<_Tp,_Alloc>::iterator typename vector<_Tp,_Alloc>::iterator
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
erase(iterator __position) erase(iterator __position)
@ -110,7 +110,7 @@ namespace std
return __position; return __position;
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
typename vector<_Tp,_Alloc>::iterator typename vector<_Tp,_Alloc>::iterator
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
erase(iterator __first, iterator __last) erase(iterator __first, iterator __last)
@ -121,7 +121,7 @@ namespace std
return __first; return __first;
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
vector<_Tp,_Alloc>& vector<_Tp,_Alloc>&
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
operator=(const vector<_Tp,_Alloc>& __x) operator=(const vector<_Tp,_Alloc>& __x)
@ -152,7 +152,7 @@ namespace std
return *this; return *this;
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_fill_assign(size_t __n, const value_type& __val) _M_fill_assign(size_t __n, const value_type& __val)
@ -171,7 +171,7 @@ namespace std
erase(fill_n(begin(), __n, __val), end()); erase(fill_n(begin(), __n, __val), end());
} }
template <typename _Tp, typename _Alloc> template <typename _InputIter> template<typename _Tp, typename _Alloc> template<typename _InputIter>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag) _M_assign_aux(_InputIter __first, _InputIter __last, input_iterator_tag)
@ -185,7 +185,7 @@ namespace std
insert(end(), __first, __last); insert(end(), __first, __last);
} }
template <typename _Tp, typename _Alloc> template <typename _ForwardIter> template<typename _Tp, typename _Alloc> template<typename _ForwardIter>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_assign_aux(_ForwardIter __first, _ForwardIter __last, _M_assign_aux(_ForwardIter __first, _ForwardIter __last,
@ -216,7 +216,7 @@ namespace std
} }
} }
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_insert_aux(iterator __position, const _Tp& __x) _M_insert_aux(iterator __position, const _Tp& __x)
@ -259,7 +259,7 @@ namespace std
} }
#ifdef _GLIBCPP_DEPRECATED #ifdef _GLIBCPP_DEPRECATED
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_insert_aux(iterator __position) _M_insert_aux(iterator __position)
@ -302,14 +302,15 @@ namespace std
} }
#endif #endif
template <typename _Tp, typename _Alloc> template<typename _Tp, typename _Alloc>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_fill_insert(iterator __position, size_type __n, const value_type& __x) _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
{ {
if (__n != 0) if (__n != 0)
{ {
if (size_type(_M_end_of_storage - _M_finish) >= __n) { if (size_type(_M_end_of_storage - _M_finish) >= __n)
{
value_type __x_copy = __x; value_type __x_copy = __x;
const size_type __elems_after = end() - __position; const size_type __elems_after = end() - __position;
iterator __old_finish(_M_finish); iterator __old_finish(_M_finish);
@ -340,8 +341,8 @@ namespace std
__new_finish = uninitialized_copy(begin(), __position, __new_finish = uninitialized_copy(begin(), __position,
__new_start); __new_start);
__new_finish = uninitialized_fill_n(__new_finish, __n, __x); __new_finish = uninitialized_fill_n(__new_finish, __n, __x);
__new_finish __new_finish = uninitialized_copy(__position, end(),
= uninitialized_copy(__position, end(), __new_finish); __new_finish);
} }
catch(...) catch(...)
{ {
@ -358,7 +359,7 @@ namespace std
} }
} }
template <typename _Tp, typename _Alloc> template <typename _InputIterator> template<typename _Tp, typename _Alloc> template<typename _InputIterator>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_range_insert(iterator __pos, _M_range_insert(iterator __pos,
@ -372,12 +373,11 @@ namespace std
} }
} }
template <typename _Tp, typename _Alloc> template <typename _ForwardIterator> template<typename _Tp, typename _Alloc> template<typename _ForwardIterator>
void void
vector<_Tp,_Alloc>:: vector<_Tp,_Alloc>::
_M_range_insert(iterator __position, _M_range_insert(iterator __position,_ForwardIterator __first,
_ForwardIterator __first, _ForwardIterator __last, _ForwardIterator __last, forward_iterator_tag)
forward_iterator_tag)
{ {
if (__first != __last) if (__first != __last)
{ {

33
libstdc++-v3/testsuite/20_util/allocator_members.cc
View file

@ -1,6 +1,6 @@
// 2001-06-14 Benjamin Kosnik <bkoz@redhat.com> // 2001-06-14 Benjamin Kosnik <bkoz@redhat.com>
// Copyright (C) 2001 Free Software Foundation, Inc. // Copyright (C) 2001, 2002 Free Software Foundation, Inc.
// //
// This file is part of the GNU ISO C++ Library. This library is free // 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 // software; you can redistribute it and/or modify it under the
@ -21,6 +21,7 @@
// 20.4.1.1 allocator members // 20.4.1.1 allocator members
#include <memory> #include <memory>
#include <stdexcept>
#include <cstdlib> #include <cstdlib>
#include <testsuite_hooks.h> #include <testsuite_hooks.h>
@ -42,7 +43,7 @@ void operator delete(void *v) throw()
return std::free(v); return std::free(v);
} }
int main(void) void test01()
{ {
bool test = true; bool test = true;
std::allocator<gnu> obj; std::allocator<gnu> obj;
@ -55,6 +56,34 @@ int main(void)
obj.deallocate(pobj, 256); obj.deallocate(pobj, 256);
VERIFY( check_delete ); VERIFY( check_delete );
}
// libstdc++/8230
void test02()
{
bool test = true;
try
{
std::allocator<int> alloc;
const std::allocator<int>::size_type n = alloc.max_size();
int* p = alloc.allocate(n + 1);
p[n] = 2002;
}
catch(const std::bad_alloc& e)
{
// Allowed.
test = true;
}
catch(...)
{
test = false;
}
VERIFY( test );
}
int main()
{
test01();
test02();
return 0; return 0;
} }

21
libstdc++-v3/testsuite/23_containers/vector_capacity.cc
View file

@ -99,9 +99,30 @@ void test02()
} }
} }
void test03()
{
bool test = true;
std::vector<int> v;
try
{
v.resize(v.max_size());
v[v.max_size() - 1] = 2002;
}
catch (const std::bad_alloc& error)
{
test = true;
}
catch (...)
{
test = false;
}
VERIFY( test );
}
int main() int main()
{ {
test01(); test01();
test02(); test02();
test03();
return 0; return 0;
} }