【笔记】《STL源码剖析》chapter4 序列式容器
chapter4 序列式容器
vector
/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/
/* NOTE: This is an internal header file, included by other STL headers.
* You should not attempt to use it directly.
*/
#ifndef __SGI_STL_INTERNAL_VECTOR_H
#define __SGI_STL_INTERNAL_VECTOR_H
__STL_BEGIN_NAMESPACE
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1174
#endif
template <class T, class Alloc = alloc>
class vector {
public:
typedef T value_type; // 元素类型 --annotated by hsby
typedef value_type *pointer; // 元素类型指针 --annotated by hsby
typedef const value_type *const_pointer;
typedef value_type *iterator; // 直接用指向元素的指针作为迭代器 --annotated by hsby
typedef const value_type *const_iterator;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
#ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
#else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
typedef reverse_iterator<const_iterator, value_type, const_reference, difference_type> const_reverse_iterator;
typedef reverse_iterator<iterator, value_type, reference, difference_type>
reverse_iterator;
#endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
protected:
typedef simple_alloc<value_type, Alloc> data_allocator; // 空间配置器 --annotated by hsby
iterator start; // 当前使用空间的头 --annotated by hsby
iterator finish; // 当前使用空间的尾 --annotated by hsby
iterator end_of_storage; // 当前可用空间的尾 --annotated by hsby
void insert_aux( iterator position, const T& x );
void deallocate() { // 释放当前可用空间 --annotated by hsby
if ( start )
data_allocator::deallocate( start, end_of_storage - start );
}
// 申请空间并初始化所有使用元素为value --annotated by hsby
void fill_initialize( size_type n, const T& value ) {
start = allocate_and_fill( n, value );
finish = start + n;
end_of_storage = finish;
}
public:
// begin of 返回迭代器 --annotated by hsby
iterator begin() {
return start;
}
const_iterator begin() const {
return start;
}
iterator end() {
return finish;
}
const_iterator end() const {
return finish;
}
reverse_iterator rbegin() {
return reverse_iterator( end() );
}
const_reverse_iterator rbegin() const {
return const_reverse_iterator( end() );
}
reverse_iterator rend() {
return reverse_iterator( begin() );
}
const_reverse_iterator rend() const {
return const_reverse_iterator( begin() );
}
// end of 返回迭代器 --annotated by hsby
size_type size() const {
return size_type( end() - begin() );
}
size_type max_size() const {
return size_type( -1 ) / sizeof( T );
}
size_type capacity() const {
return size_type( end_of_storage - begin() );
}
bool empty() const {
return begin() == end();
}
reference operator[]( size_type n ) {
return *( begin() + n );
}
const_reference operator[]( size_type n ) const { // const修饰this指针，可以作为绑定标记 --annotated by hsby
return *( begin() + n );
}
// begin of constructor --annotated by hsby
vector() : start( 0 ), finish( 0 ), end_of_storage( 0 ) {}
vector( size_type n, const T& value ) {
fill_initialize( n, value );
}
vector( int n, const T& value ) {
fill_initialize( n, value );
}
vector( long n, const T& value ) {
fill_initialize( n, value );
}
explicit vector( size_type n ) { // explicit 禁止隐性转换 --annotated by hsby
fill_initialize( n, T() );
}
vector( const vector<T, Alloc>& x ) {
start = allocate_and_copy( x.end() - x.begin(), x.begin(), x.end() );
finish = start + ( x.end() - x.begin() );
end_of_storage = finish;
}
#ifdef __STL_MEMBER_TEMPLATES
template <class InputIterator> vector( InputIterator first, InputIterator last ) :
start( 0 ), finish( 0 ), end_of_storage( 0 ) { // 使用迭代器初始化的构造函数 --annotated by hsby
range_initialize( first, last, iterator_category( first ) );
}
#else /* __STL_MEMBER_TEMPLATES */
vector( const_iterator first, const_iterator last ) {
size_type n = 0;
distance( first, last, n );
start = allocate_and_copy( n, first, last );
finish = start + n;
end_of_storage = finish;
}
#endif /* __STL_MEMBER_TEMPLATES */
~vector() {
destroy( start, finish );
deallocate();
}
// 赋值构造函数 --annotated by hsby
vector<T, Alloc>& operator=( const vector<T, Alloc>& x );
// end of constructor --annotated by hsby
// 扩容 --annotated by hsby
void reserve( size_type n ) {
if ( capacity() < n ) {
const size_type old_size = size();
iterator tmp = allocate_and_copy( n, start, finish );
destroy( start, finish );
deallocate();
start = tmp;
finish = tmp + old_size;
end_of_storage = start + n;
}
}
reference front() {
return *begin();
}
const_reference front() const {
return *begin();
}
reference back() {
return *( end() - 1 );
}
const_reference back() const {
return *( end() - 1 );
}
// 推入元素 --notated by hsby
void push_back( const T& x ) {
if ( finish != end_of_storage ) { // 判断是否需要扩容 --annotated by hsby
construct( finish, x );
++finish;
} else
insert_aux( end(), x );
}
// 与其它容器交换空间 --annotated by hsby
void swap( vector<T, Alloc>& x ) {
__STD::swap( start, x.start );
__STD::swap( finish, x.finish );
__STD::swap( end_of_storage, x.end_of_storage );
}
// 在position前插入元素 --annotated by hsby
iterator insert( iterator position, const T& x ) {
size_type n = position - begin();
if ( finish != end_of_storage && position == end() ) { // 如果pos刚好是尾部而且容量足够，则直接构造 --annotated by hsby
construct( finish, x );
++finish;
} else // 否则调用辅助插入函数 --annotated by hsby
insert_aux( position, x );
return begin() + n;
}
iterator insert( iterator position ) {
return insert( position, T() );
}
#ifdef __STL_MEMBER_TEMPLATES
template <class InputIterator>
void insert( iterator position, InputIterator first, InputIterator last ) {
range_insert( position, first, last, iterator_category( first ) );
}
#else /* __STL_MEMBER_TEMPLATES */
void insert( iterator position,
const_iterator first, const_iterator last );
#endif /* __STL_MEMBER_TEMPLATES */
void insert( iterator pos, size_type n, const T& x );
void insert( iterator pos, int n, const T& x ) {
insert( pos, ( size_type ) n, x );
}
void insert( iterator pos, long n, const T& x ) {
insert( pos, ( size_type ) n, x );
}
void pop_back() {
--finish;
destroy( finish );
}
iterator erase( iterator position ) {
if ( position + 1 != end() )
copy( position + 1, finish, position );
--finish;
destroy( finish );
return position;
}
// 擦除范围，将last到finish复制到first之后，将i到finish之间的元素析构，将finish重置为finish-(last-first) --annotated by hsby
iterator erase( iterator first, iterator last ) {
iterator i = copy( last, finish, first );
destroy( i, finish );
finish = finish - ( last - first );
return first;
}
void resize( size_type new_size, const T& x ) {
if ( new_size < size() )
erase( begin() + new_size, end() );
else
insert( end(), new_size - size(), x );
}
void resize( size_type new_size ) {
resize( new_size, T() );
}
void clear() {
erase( begin(), end() );
}
protected:
// 申请内存并填充为T --annotated by hsby
iterator allocate_and_fill( size_type n, const T& x ) {
iterator result = data_allocator::allocate( n );
__STL_TRY {
uninitialized_fill_n( result, n, x );
return result;
}
__STL_UNWIND( data_allocator::deallocate( result, n ) );
}
#ifdef __STL_MEMBER_TEMPLATES
// 申请内存并填充为为指定范围的内容，需要自行保证n > last-first --annotated by hsby
template <class ForwardIterator>
iterator allocate_and_copy( size_type n,
ForwardIterator first, ForwardIterator last ) {
iterator result = data_allocator::allocate( n );
__STL_TRY {
uninitialized_copy( first, last, result );
return result;
}
__STL_UNWIND( data_allocator::deallocate( result, n ) );
}
#else /* __STL_MEMBER_TEMPLATES */
iterator allocate_and_copy( size_type n,
const_iterator first, const_iterator last ) {
iterator result = data_allocator::allocate( n );
__STL_TRY {
uninitialized_copy( first, last, result );
return result;
}
__STL_UNWIND( data_allocator::deallocate( result, n ) );
}
#endif /* __STL_MEMBER_TEMPLATES */
#ifdef __STL_MEMBER_TEMPLATES
// 偏例化，对于步进的迭代器，只能一个一个填充 --annotated by hsby
template <class InputIterator>
void range_initialize( InputIterator first, InputIterator last,
input_iterator_tag ) {
for ( ; first != last; ++first )
push_back( *first );
}
// This function is only called by the constructor. We have to worry
// about resource leaks, but not about maintaining invariants.
// 偏特化，对于单向迭代器，直接将选择复制方式这个职责交给allocate_and_copy，当然allocate也会将责任再转交给uninitialized_copy --annotated by hsby
template <class ForwardIterator>
void range_initialize( ForwardIterator first, ForwardIterator last,
forward_iterator_tag ) {
size_type n = 0;
distance( first, last, n ); // 传引用获取距离n --annotated by hsby
start = allocate_and_copy( n, first, last );
finish = start + n;
end_of_storage = finish;
}
template <class InputIterator>
void range_insert( iterator pos,
InputIterator first, InputIterator last,
input_iterator_tag );
template <class ForwardIterator>
void range_insert( iterator pos,
ForwardIterator first, ForwardIterator last,
forward_iterator_tag );
#endif /* __STL_MEMBER_TEMPLATES */
};
template <class T, class Alloc>
inline bool operator==( const vector<T, Alloc>& x, const vector<T, Alloc>& y ) {
return x.size() == y.size() && equal( x.begin(), x.end(), y.begin() );
}
template <class T, class Alloc>
inline bool operator<( const vector<T, Alloc>& x, const vector<T, Alloc>& y ) {
return lexicographical_compare( x.begin(), x.end(), y.begin(), y.end() );
}
#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER
template <class T, class Alloc>
inline void swap( vector<T, Alloc>& x, vector<T, Alloc>& y ) {
x.swap( y );
}
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */
template <class T, class Alloc>
vector<T, Alloc>& vector<T, Alloc>::operator=( const vector<T, Alloc>& x ) {
if ( &x != this ) {
if ( x.size() > capacity() ) {
iterator tmp = allocate_and_copy( x.end() - x.begin(),
x.begin(), x.end() );
destroy( start, finish );
deallocate();
start = tmp;
end_of_storage = start + ( x.end() - x.begin() );
} else if ( size() >= x.size() ) {
iterator i = copy( x.begin(), x.end(), begin() );
destroy( i, finish );
} else {
copy( x.begin(), x.begin() + size(), start );
uninitialized_copy( x.begin() + size(), x.end(), finish );
}
finish = start + x.size();
}
return *this;
}
template <class T, class Alloc>
void vector<T, Alloc>::insert_aux( iterator position, const T& x ) {
if ( finish != end_of_storage ) {
construct( finish, *( finish - 1 ) );
++finish;
T x_copy = x;
copy_backward( position, finish - 2, finish - 1 );
*position = x_copy;
} else {
const size_type old_size = size();
const size_type len = old_size != 0 ? 2 * old_size : 1;
iterator new_start = data_allocator::allocate( len );
iterator new_finish = new_start;
__STL_TRY {
new_finish = uninitialized_copy( start, position, new_start );
construct( new_finish, x );
++new_finish;
new_finish = uninitialized_copy( position, finish, new_finish );
}
# ifdef __STL_USE_EXCEPTIONS
catch ( ... ) {
destroy( new_start, new_finish );
data_allocator::deallocate( new_start, len );
throw;
}
# endif /* __STL_USE_EXCEPTIONS */
destroy( begin(), end() );
deallocate();
start = new_start;
finish = new_finish;
end_of_storage = new_start + len;
}
}
template <class T, class Alloc>
void vector<T, Alloc>::insert( iterator position, size_type n, const T& x ) {
if ( n != 0 ) {
if ( size_type( end_of_storage - finish ) >= n ) { // 如果容量充足 --annotated by hsby
T x_copy = x;
const size_type elems_after = finish - position; // 需要被后移的元素数量 --annotated by hsby
iterator old_finish = finish;
if ( elems_after > n ) { // 如果需要被后移的元素比n多 --annotated by hsby
uninitialized_copy( finish - n, finish, finish ); // 先将需要被后移的最后n个元素后移到finish --annotated by hsby
finish += n;
copy_backward( position, old_finish - n, old_finish ); // 从后往前复制需要被后移的元素剩下的元素 --annotated by hsby
fill( position, position + n, x_copy ); // 在position之后填充x --annotated by hsby
} else {
uninitialized_fill_n( finish, n - elems_after, x_copy );
finish += n - elems_after;
uninitialized_copy( position, old_finish, finish );
finish += elems_after;
fill( position, old_finish, x_copy );
}
} else {
const size_type old_size = size();
const size_type len = old_size + max( old_size, n );
iterator new_start = data_allocator::allocate( len );
iterator new_finish = new_start;
__STL_TRY {
new_finish = uninitialized_copy( start, position, new_start );
new_finish = uninitialized_fill_n( new_finish, n, x );
new_finish = uninitialized_copy( position, finish, new_finish );
}
# ifdef __STL_USE_EXCEPTIONS
catch ( ... ) {
destroy( new_start, new_finish );
data_allocator::deallocate( new_start, len );
throw;
}
# endif /* __STL_USE_EXCEPTIONS */
destroy( start, finish );
deallocate();
start = new_start;
finish = new_finish;
end_of_storage = new_start + len;
}
}
}
#ifdef __STL_MEMBER_TEMPLATES
template <class T, class Alloc> template <class InputIterator>
void vector<T, Alloc>::range_insert( iterator pos,
InputIterator first, InputIterator last,
input_iterator_tag ) {
for ( ; first != last; ++first ) {
pos = insert( pos, *first );
++pos;
}
}
template <class T, class Alloc> template <class ForwardIterator>
void vector<T, Alloc>::range_insert( iterator position,
ForwardIterator first,
ForwardIterator last,
forward_iterator_tag ) {
if ( first != last ) {
size_type n = 0;
distance( first, last, n );
if ( size_type( end_of_storage - finish ) >= n ) {
const size_type elems_after = finish - position;
iterator old_finish = finish;
if ( elems_after > n ) {
uninitialized_copy( finish - n, finish, finish );
finish += n;
copy_backward( position, old_finish - n, old_finish );
copy( first, last, position );
} else {
ForwardIterator mid = first;
advance( mid, elems_after );
uninitialized_copy( mid, last, finish );
finish += n - elems_after;
uninitialized_copy( position, old_finish, finish );
finish += elems_after;
copy( first, mid, position );
}
} else {
const size_type old_size = size();
const size_type len = old_size + max( old_size, n );
iterator new_start = data_allocator::allocate( len );
iterator new_finish = new_start;
__STL_TRY {
new_finish = uninitialized_copy( start, position, new_start );
new_finish = uninitialized_copy( first, last, new_finish );
new_finish = uninitialized_copy( position, finish, new_finish );
}
# ifdef __STL_USE_EXCEPTIONS
catch ( ... ) {
destroy( new_start, new_finish );
data_allocator::deallocate( new_start, len );
throw;
}
# endif /* __STL_USE_EXCEPTIONS */
destroy( start, finish );
deallocate();
start = new_start;
finish = new_finish;
end_of_storage = new_start + len;
}
}
}
#else /* __STL_MEMBER_TEMPLATES */
template <class T, class Alloc>
void vector<T, Alloc>::insert( iterator position,
const_iterator first,
const_iterator last ) {
if ( first != last ) {
size_type n = 0;
distance( first, last, n );
if ( size_type( end_of_storage - finish ) >= n ) { // 如果容量足够 --annotated by hsby
const size_type elems_after = finish - position; // 记录需要被移动的元素的数量
iterator old_finish = finish;
if ( elems_after > n ) {
uninitialized_copy( finish - n, finish, finish );
finish += n;
copy_backward( position, old_finish - n, old_finish );
copy( first, last, position );
} else {
uninitialized_copy( first + elems_after, last, finish );
finish += n - elems_after;
uninitialized_copy( position, old_finish, finish );
finish += elems_after;
copy( first, first + elems_after, position );
}
} else {
const size_type old_size = size();
const size_type len = old_size + max( old_size, n );
iterator new_start = data_allocator::allocate( len );
iterator new_finish = new_start;
__STL_TRY {
new_finish = uninitialized_copy( start, position, new_start );
new_finish = uninitialized_copy( first, last, new_finish );
new_finish = uninitialized_copy( position, finish, new_finish );
}
# ifdef __STL_USE_EXCEPTIONS
catch ( ... ) {
destroy( new_start, new_finish );
data_allocator::deallocate( new_start, len );
throw;
}
# endif /* __STL_USE_EXCEPTIONS */
destroy( start, finish );
deallocate();
start = new_start;
finish = new_finish;
end_of_storage = new_start + len;
}
}
}
#endif /* __STL_MEMBER_TEMPLATES */
#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1174
#endif
__STL_END_NAMESPACE
#endif /* __SGI_STL_INTERNAL_VECTOR_H */
// Local Variables:
// mode:C++
// End:
list
list中node指向刻意置于尾端的空白节点，这样符合STL对于“左闭右开”区间的要求
list的数据结构
和verctor一样，默认使用alloc作为空间配置器
public:
list() {
empty_initialize();
}
iterator begin() {
return ( link_type )( ( *node ).next );
}
const_iterator begin() const {
return ( link_type )( ( *node ).next );
}
iterator end() {
return node;
}
const_iterator end() const {
return node;
}
reverse_iterator rbegin() {
return reverse_iterator( end() );
}
const_reverse_iterator rbegin() const {
return const_reverse_iterator( end() );
}
reverse_iterator rend() {
return reverse_iterator( begin() );
}
const_reverse_iterator rend() const {
return const_reverse_iterator( begin() );
}
bool empty() const {
return node->next == node;
}
size_type size() const {
size_type result = 0;
distance( begin(), end(), result );
return result;
}
size_type max_size() const {
return size_type( -1 );
}
reference front() {
return *begin();
}
const_reference front() const {
return *begin();
}
reference back() {
return *( --end() );
}
const_reference back() const {
return *( --end() );
}
protected:
void empty_initialize() {
node = get_node();
node->next = node;
node->prev = node;
}
list 的构造与内存管理
protected:
link_type get_node() {
return list_node_allocator::allocate();
}
void put_node( link_type p ) {
list_node_allocator::deallocate( p );
}
// 创建节点 --annotated by hsby
link_type create_node( const T& x ) {
link_type p = get_node(); // 获取空间 --annotated by hsby
__STL_TRY {
construct( &p->data, x ); // 构造节点数据 --annotated by hsby
}
__STL_UNWIND( put_node( p ) ); // 如果构造时抛出错误，直接摧毁并抛出错误 --annotated by hsby
return p;
}
void destroy_node( link_type p ) {
destroy( &p->data );
put_node( p );
}
protected:
void empty_initialize() { // 初始化一个空节点，前置和后置指针均指向本身 --annotated by hsby
node = get_node();
node->next = node;
node->prev = node;
}
deque
deque是维护了逻辑上的连续空间，而且能够原地成长，由一段一段的定量连续空间组成，一旦有必要在deque的前端或尾端增加新空间，便配置一段定量连续空间，串接在整个deque的头端或尾端
deque的中控器
class deque {
public: // Basic types
typedef T value_type;
typedef value_type* pointer;
...
protected: // Internal typedefs
typedef pointer* map_pointer;
...
}
deque使用一块map来储存缓冲区的指针，即map_pointer的类型是value_type**
inline size_t __deque_buf_size( size_t n, size_t sz ) {
return n != 0 ? n : ( sz < 512 ? size_t( 512 / sz ) : size_t( 1 ) );
}
这是deque计算缓冲区大小的全局函数，如果n被指定大小，则返回n，否则如果sz小于512，返回512/sz，否则返回1
deque的迭代器
template <class T, class Ref, class Ptr>
struct __deque_iterator {
typedef __deque_iterator<T, T&, T *> iterator;
typedef __deque_iterator<T, const T&, const T *> const_iterator;
static size_t buffer_size() {
return __deque_buf_size( 0, sizeof( T ) );
}
#endif
typedef random_access_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T **map_pointer;
typedef __deque_iterator self;
T *cur; // 指向当前迭代器所指元素
T *first; // 指向当前迭代器所在缓冲区的头
T *last; // 指向当前迭代器所在缓冲区的尾
map_pointer node; // 指向当前迭代器所在缓冲区
__deque_iterator( T *x, map_pointer y )
: cur( x ), first( *y ), last( *y + buffer_size() ), node( y ) {}
__deque_iterator() : cur( 0 ), first( 0 ), last( 0 ), node( 0 ) {}
__deque_iterator( const iterator& x )
: cur( x.cur ), first( x.first ), last( x.last ), node( x.node ) {}
reference operator*() const {
return *cur;
}
#ifndef __SGI_STL_NO_ARROW_OPERATOR
pointer operator->() const {
return &( operator*() );
}
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
difference_type operator-( const self& x ) const {
return difference_type( buffer_size() ) * ( node - x.node - 1 ) +
( cur - first ) + ( x.last - x.cur );
}
self& operator++() {
++cur;
if ( cur == last ) {
set_node( node + 1 );
cur = first;
}
return *this;
}
self operator++( int ) {
self tmp = *this;
++*this;
return tmp;
}
self& operator--() {
if ( cur == first ) {
set_node( node - 1 );
cur = last;
}
--cur;
return *this;
}
self operator--( int ) {
self tmp = *this;
--*this;
return tmp;
}
self& operator+=( difference_type n ) {
difference_type offset = n + ( cur - first );
if ( offset >= 0 &&
offset < difference_type( buffer_size() ) ) // 如果偏移量非负，而且在单个缓冲区之内 --annotated by hsby
cur += n;
else {
difference_type node_offset =
offset > 0 ? offset / difference_type( buffer_size() ) // 如果是超过单个缓冲区 --annotated by hsby
: -difference_type( ( -offset - 1 ) / buffer_size() ) - 1; // 如果是负数的偏移量 --annotated by hsby
set_node( node + node_offset );
cur = first + ( offset - node_offset * difference_type( buffer_size() ) );
}
return *this;
}
self operator+( difference_type n ) const {
self tmp = *this;
return tmp += n;
}
self& operator-=( difference_type n ) {
return *this += -n;
}
self operator-( difference_type n ) const {
self tmp = *this;
return tmp -= n;
}
reference operator[]( difference_type n ) const {
return *( *this + n );
}
bool operator==( const self& x ) const {
return cur == x.cur;
}
bool operator!=( const self& x ) const {
return !( *this == x );
}
bool operator<( const self& x ) const {
return ( node == x.node ) ? ( cur < x.cur ) : ( node < x.node );
}
void set_node( map_pointer new_node ) {
node = new_node;
first = *new_node;
last = first + difference_type( buffer_size() );
}
};
deque的数据结构
iterator start;
iterator finish;
map_pointer map;
size_type map_size;
