// Vector implementation -*- C++ -*-
-// Copyright (C) 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
+// 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
#include <bits/functexcept.h>
#include <bits/concept_check.h>
-namespace _GLIBCXX_STD
-{
+_GLIBCXX_BEGIN_NESTED_NAMESPACE(std, _GLIBCXX_STD)
+
/**
* @if maint
* See bits/stl_deque.h's _Deque_base for an explanation.
public:
typedef _Alloc allocator_type;
- _Tp_alloc_type
+ _Tp_alloc_type&
+ _M_get_Tp_allocator()
+ { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+
+ const _Tp_alloc_type&
_M_get_Tp_allocator() const
{ return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
allocator_type
get_allocator() const
- { return _M_get_Tp_allocator(); }
+ { return allocator_type(_M_get_Tp_allocator()); }
_Vector_base(const allocator_type& __a)
: _M_impl(__a)
typedef _Alloc allocator_type;
protected:
- /** @if maint
- * These two functions and three data members are all from the
- * base class. They should be pretty self-explanatory, as
- * %vector uses a simple contiguous allocation scheme. @endif
- */
using _Base::_M_allocate;
using _Base::_M_deallocate;
using _Base::_M_impl;
* @a x (for fast expansion) will not be copied.
*/
vector(const vector& __x)
- : _Base(__x.size(), __x.get_allocator())
+ : _Base(__x.size(), __x._M_get_Tp_allocator())
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
*/
~vector()
{ std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
- _M_get_Tp_allocator());
- }
+ _M_get_Tp_allocator()); }
/**
* @brief %Vector assignment operator.
*/
iterator
begin()
- { return iterator (this->_M_impl._M_start); }
+ { return iterator(this->_M_impl._M_start); }
/**
* Returns a read-only (constant) iterator that points to the
*/
const_iterator
begin() const
- { return const_iterator (this->_M_impl._M_start); }
+ { return const_iterator(this->_M_impl._M_start); }
/**
* Returns a read/write iterator that points one past the last
*/
iterator
end()
- { return iterator (this->_M_impl._M_finish); }
+ { return iterator(this->_M_impl._M_finish); }
/**
* Returns a read-only (constant) iterator that points one past
*/
const_iterator
end() const
- { return const_iterator (this->_M_impl._M_finish); }
+ { return const_iterator(this->_M_impl._M_finish); }
/**
* Returns a read/write reverse iterator that points to the
/** Returns the number of elements in the %vector. */
size_type
size() const
- { return size_type(end() - begin()); }
+ { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
/** Returns the size() of the largest possible %vector. */
size_type
resize(size_type __new_size, value_type __x = value_type())
{
if (__new_size < size())
- erase(begin() + __new_size, end());
+ _M_erase_at_end(this->_M_impl._M_start + __new_size);
else
insert(end(), __new_size - size(), __x);
}
*/
size_type
capacity() const
- { return size_type(const_iterator(this->_M_impl._M_end_of_storage)
- - begin()); }
+ { return size_type(this->_M_impl._M_end_of_storage
+ - this->_M_impl._M_start); }
/**
* Returns true if the %vector is empty. (Thus begin() would
*/
reference
operator[](size_type __n)
- { return *(begin() + __n); }
+ { return *(this->_M_impl._M_start + __n); }
/**
* @brief Subscript access to the data contained in the %vector.
*/
const_reference
operator[](size_type __n) const
- { return *(begin() + __n); }
+ { return *(this->_M_impl._M_start + __n); }
protected:
/// @if maint Safety check used only from at(). @endif
back() const
{ return *(end() - 1); }
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // DR 464. Suggestion for new member functions in standard containers.
+ // data access
+ /**
+ * Returns a pointer such that [data(), data() + size()) is a valid
+ * range. For a non-empty %vector, data() == &front().
+ */
+ pointer
+ data()
+ { return pointer(this->_M_impl._M_start); }
+
+ const_pointer
+ data() const
+ { return const_pointer(this->_M_impl._M_start); }
+
// [23.2.4.3] modifiers
/**
* @brief Add data to the end of the %vector.
std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
std::swap(this->_M_impl._M_end_of_storage,
__x._M_impl._M_end_of_storage);
+
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 431. Swapping containers with unequal allocators.
+ std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
+ __x._M_get_Tp_allocator());
}
/**
*/
void
clear()
- { erase(begin(), end()); }
+ { _M_erase_at_end(this->_M_impl._M_start); }
protected:
/**
// Called by insert(p,x)
void
_M_insert_aux(iterator __position, const value_type& __x);
+
+ // Internal erase functions follow.
+
+ // Called by erase(q1,q2), clear(), resize(), _M_fill_assign,
+ // _M_assign_aux.
+ void
+ _M_erase_at_end(pointer __pos)
+ {
+ std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
+ this->_M_impl._M_finish = __pos;
+ }
};
inline void
swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
{ __x.swap(__y); }
-} // namespace std
+
+_GLIBCXX_END_NESTED_NAMESPACE
#endif /* _VECTOR_H */
OSDN Git Service
