C++中的
vector是一个动态数组，它的
源码实现在标准头文件<
vector>中。下面是
vector的一些关键实现细节：
```
//
vector的定义
template <typename _Tp, typename _Alloc = std::allocator<_Tp>>
class
vector {
public:
// 构造函数
vector() noexcept(noexcept(_Alloc())) :
vector(_Alloc()) {}
explicit
vector(const _Alloc& __a) noexcept;
explicit
vector(size_type __n);
vector(size_type __n, const value_type& __value,
const _Alloc& __a = _Alloc());
template <typename _InputIterator>
vector(_InputIterator __first, _InputIterator __last,
const _Alloc& __a = _Alloc());
vector(const
vector& __x);
vector(
vector&& __x) noexcept;
vector(initializer_list<value_type> __l, const _Alloc& __a = _Alloc());
// 析构函数
~
vector();
// 元素访问
reference operator[](size_type __n) { return *(this->_M_impl._M_start + __n); }
const_reference operator[](size_type __n) const { return *(this->_M_impl._M_start + __n); }
reference at(size_type __n);
const_reference at(size_type __n) const;
reference front() { return *begin(); }
const_reference front() const { return *begin(); }
reference back() { return *(end() - 1); }
const_reference back() const { return *(end() - 1); }
pointer data() noexcept { return pointer_traits<pointer>::pointer_to(this->_M_impl._M_start); }
const_pointer data() const noexcept { return pointer_traits<const_pointer>::pointer_to(this->_M_impl._M_start); }
// 迭代器
iterator begin() noexcept { return iterator(this->_M_impl._M_start); }
const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_start); }
iterator end() noexcept { return iterator(this->_M_impl._M_finish); }
const_iterator end() const noexcept { return const_iterator(this->_M_impl._M_finish); }
reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept { return const_iterator(this->_M_impl._M_start); }
const_iterator cend() const noexcept { return const_iterator(this->_M_impl._M_finish); }
const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }
const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); }
// 容量
bool empty() const noexcept { return begin() == end(); }
size_type size() const noexcept { return static_cast<size_type>(end() - begin()); }
size_type max_size() const noexcept;
void reserve(size_type __n);
size_type capacity() const noexcept { return static_cast<size_type>(this->_M_impl._M_end_of_storage - this->_M_impl._M_start); }
void shrink_to_fit() noexcept;
// 修改器
void clear() noexcept { _M_erase_at_end(this->_M_impl._M_start); }
iterator insert(const_iterator __position, const value_type& __x);
iterator insert(const_iterator __position, value_type&& __x);
iterator insert(const_iterator __position, size_type __n, const value_type& __x);
template <typename _InputIterator>
iterator insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
iterator insert(const_iterator __position, initializer_list<value_type> __l) { return insert(__position, __l.begin(), __l.end()); }
template <typename... _Args>
iterator emplace(const_iterator __position, _Args&&... __args);
iterator erase(const_iterator __position);
iterator erase(const_iterator __first, const_iterator __last);
void push_back(const value_type& __x);
void push_back(value_type&& __x);
template <typename... _Args>
reference emplace_back(_Args&&... __args);
void pop_back();
void resize(size_type __new_size) { resize(__new_size, value_type()); }
void resize(size_type __new_size, const value_type& __x);
void swap(
vector& __x) noexcept(_Alloc_traits::_S_nothrow_swap());
};
```
1155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
