¿Cuál es el prototipo de vector en C++?
clase Vector: protected_Vector_base<_Tp,_Alloc>
{
//Requisitos conceptuales.
__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
typedef _ Vector _ base & lt_Tp, _ Alloc & gt_ Base
typedef Vector & lt_Tp, _ Alloc & gtvector _ tipo
Público:
typedef _ Tp valor _ tipo
typedef nombre de tipo _Alloc::puntero puntero;
typedef nombre de tipo _ Alloc ::const _ puntero const _ puntero;
typedef nombre de tipo _ Alloc::referencia de referencia;
typedef nombre de tipo _ Alloc::const _ referencia const _ referencia
typedef _ _ GNU _ cxx::_ _ normal _ iterador & lt; puntero, tipo de vector & gt iterador
typedef _ _ GNU _ cxx::_ _ normal _ iterador & lt; puntero, tipo de vector & gt
const _ iterator
typedef STD::reverse _ iterator & lt; const _ iterator & gtconst _ reverse _ iterator
typedef STD::reverse_iterator<iterator>reverse_iterator
typedef tamaño _ t tamaño _ tipo
typedef ptr diff _ t diferencia _ tipo;
typedef typename_Base::allocator_type allocator_type;
Protegido:
usando _Base::_ M_allocate;
usando _ Base::_ M _ desasignar
usando _ Base ::_ M _ impl;
Público:
Explícito
Vector (asignador constante _ tipo & amp__a = tipo de asignador ())
:_Base(__a) { }
Explícito
Vector (tamaño tipo__n)
:_Base(__n, tipo de asignador())
{this->_M_impl. _M_finish = STD::initialized_fill_n(this->_M_impl.
_M_start,
__n, value_type());}
Vector (vector constante y amp__x)
: _Base(__x.size(),__x .get_allocator ())
{Esto->_M_impl. _M_finish = STD::initialized_copy(__x.begin(),__x.end(),
Esto->_M_impl._M_start);
}
Plantilla y lttypename _ InputIterator & gt
vector(_ operador de entrada _ _ primero, _ InputIterator _ _ último,
Tipo de asignador constante & amp__a = tipo de asignador())
:_Base(__a)
{
//Comprueba si es un número entero. Si es así, no es un iterador.
typedef typename _ Is _ integer & lt_ InputIterator & gt::_ Integral _ Integral
_M_initialize_dispatch(__first, _last, _ Integral()
); }
~ vector(){ STD::_ Destroy(this->_M_impl._M_start,this->_M_impl._M_finish);}
Vector y matemáticas.
Operador = (vector constante & amp_ _ x);
Vacío
Asignación (tamaño_tipo __n, valor constante _ tipo & amp__val)
{ _M_fill_assign(__n, _ _ val);}
Plantilla & lttypename _ InputIterator & gt
Vacío
Asignación(_ InputIterator _ _ primero, _ InputIterator _ _ último)
{
//Comprueba si es un número entero. Si es así, no es un iterador.
typedef typename _ Is _ integer & lt_ InputIterator & gt::_ Integral _ Integral
_M_assign_dispatch(__first, _last, _ Integral()
); }
///Obtener una copia del objeto de asignación de memoria.
using_Base::get_allocator;
Iterador
begin() {return iterator(this->_M_impl._M_ start);}
Iterador constante
begin()const { return const _ iterador(this->_M_impl._M_start);}
Iterador
end() { return iterator(this->_M_impl._M_finish);}
Iterador constante
end()const { return const _ iterator(this->_M_impl.
_ M _ terminar);}
Iterador inverso
Rb comenzar(){ return reverso _ iterador(end());}
Constante_ Inverso _ iterador
Rb comenzar()const { return const _ revertir _ iterador(end());}
Iterador inverso
rend (){ devolver revertir _ iterador (begin());}
Constant_reverse_iterator
rend()const { return const _ reverse _ iterator(begin());}
//[ 23.2.4.2]Capacidad
/** Devuelve el número de elementos en %vector. */
Size_type
size()const { return size _ type(end()-begin());}
/**Return Máximo posible tamaño de %vector(). */
Tipo_tamaño
max _ tamaño()const { return tamaño _ tipo(-1)/tamañode(valor _ tipo);}
vacío
resize(size_type __new_size, valor constante _ tipo & amp__x)
{
if(_ _ new _ size & lt;size())
erase(begin() + __new_size, end());
Otros
insert(end(), __new_size - size(), _ _ x );
}
Vacío
resize(tamaño _ tipo _ _ nuevo _ tamaño){ resize(_ _ nuevo _ tamaño, valor _ tipo());}
size_type
capacidad() constante
{ return size_type(const_iterator(this->_M_impl._ M _ fin_ de _ almacenamiento)-begin( ));}
Partes dobladas
vacía()const { return begin()= = end();}
Vacía
reserva(tamaño _ tipo _ _ n);
Referencia
Operador[](tamaño _ tipo _ _ n) { return *(begin()+_ _ n); }
Referencia_constante
operador[](tamaño _ tipo _ _ n)const { return *(begin() +_ _ n);}
Protegido :
/// @if La verificación de seguridad de mantenimiento solo se usa a partir de las ().
@endif
Vacío
_M_range_check(size_type __n) constante
{
Si (_ _ n & gt= this-& gt ; tamaño())
_ _ throw _ out _ of _ range(_ _ N(" vector::_ M _ range _ check ");
}
Público:
Referencia
at(size _ type _ _ n){ _ M _ range _ check(_ _ n); return(* this)[ _ _ n];}
Referencia_constante
at(size_type__n)const { _ M_range_check(__n); return(* this )[_ _ n];}
Referencia
front(){ return * comenzar();}
Referencia_constante
front()const { return * comenzar();}
Referencia
back(){ return *(end()-1);}
referencia_constante
back()const { return *( end()-1);}
Vacío
push_back(tipo de valor constante y amp__x)
{
si (esto- >_M_impl._M_finished!= this->_M_impl._M_end de almacenamiento)
{
STD::_construct(this->_M_impl._M_finish,__x);
++ this->_M_impl._M_finish
p>
}
Otro
_M_insert_aux(end(),_ _ x);
}
Vacío
Retorno pop()
{
-this->; _M_finish
STD::_ Destroy(this) ->_M_impl._M_finish);
}
Iterador
insert(iterator_position , const_value_type&__ x);
Vacío
insert(iterador __position, size_type __n, valor constante _ type & amp__x)
{ _M_fill_insert(__position, __n, _ _ x);}
Plantilla & lttypename _ InputIterator & gt
Vacío
insert(iterador __posición, _ InputIterator _ _ primero,
_ InputIterator _ _ last)
{
//Comprueba si es un número entero. Si es así, no es un iterador.
typedef typename _ Is _ integer & lt_ InputIterator & gt::_ Integral _ Integral
_M_insert_dispatch(__position, __first, __last, _ integer());
}
Programa iterativo
erase(iterator__position);
Programa iterativo
erase(iterator__first , iterator_ _ last);
Vacío
Intercambio (vector & amp__x)
{
STD::swap (this->_M_impl._M_start,__x. _M_impl._M_start);
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);
}
Vacío
p>clear() { erase(begin(), end());}
Protegido:
Plantilla y lttypename _ ForwardIterator & gt
Puntero
_ M _ asignar _ y _ copiar (tamaño _ tipo _ _ n,
_ForwardIterator __first, _ForwardIterator __last)
{
puntero _ _ resultado = this->_ M _ allocate(_ _ n) ;
Probar
{
STD:: inicializado_copia(__primero,__último,__resultado);
Devolver__resultado
}
Catch(...)
p>{
_M_deallocate(__resultado, _ _ n); lanzar _ excepción _ otra vez
}
}
Plantilla<typename_Integer>
Vacío
_ M_initialize_dispatch(_Integer__n, _Integer __value, __true_type)
{
Esto->_M_impl. _M_start = _M_allocate(_ _n);
Esto->_M_impl. _M_end_of_storage = esto->_M_impl. _M_start+__n;
Esto->_M_impl. _M_finish = STD::initialized_fill_n(this->_M_impl.
_M_start,
__n,_ _ value);
}
//Implementado por la llamada al constructor de alcance [23.1.1]/9
Plantilla<typename_InputIterator>
Vacío
_M_initialize_dispatch(_inputoperator__first,_InputIterator__last,
__false_type)
{
typedef typename iterator_traits<_InputIterator>*Iterator_Category
_ IterCategory
_M_range_initialize(__primera, __última, _ categoría ITER());
}
/ /Llamado por el segundo inicialize_dispatch anterior
Template& lttypename _ InputIterator & gt
Vacío
_ M _ range _ inicialize(_ operador de entrada _ _ primero,
_InputIterator __last, input_iterator_tag)
{
for(;_ _priority!= _ _ last++__first)
push _ back (* _ _ primero);
}
//Llamado por el segundo inicialize_dispatch arriba
Template & lttypename _ ForwardIterator & gt
Vacío
_ M _ rango _ inicializar(_ iterador directo _ _ primero,
_ForwardIterator __último, forward_iterator_tag)
{
tamaño _ tipo _ _ n = STD:: distancia(__primero,__último);
Esto->_M_impl. _M_start = esto->_M_allocate(_ _n);
Esto->_M_impl. _M_end_of_storage = esto->_M_impl. _M_start+__n;
Esto->_M_impl. _M_finish = STD::initialized_copy(__first,__last,
This->_M_impl._M_start);
}
//La función de asignación interna sigue. La función *_aux realiza la operación real
//La asignación de la versión del rango.
//Llamado por asignación de rango para implementar [23.1.1]/9
Plantilla & lttypename _ Integer & gt
Vacío
_M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
{
_ M_fill_assign(static_cast<size_type>(__n),
static_cast<value_type>(_ _ val)) ;
}
//Llamado por asignación de rango para implementar [23.1.1 ]/9
Plantilla<typename_InputIterator>
Vacío
_ M_assign_dispatch(_input operator__first,_InputIterator_ _ last,
__false_type)
{
typedef typename iterador _ rasgos <_InputIterator & gt*iterator_category
_ IterCategory
_M_assign_aux(__first, __last, _ ITERcategory());
}
//Llamado por el segundo asignar_dispatch arriba
p>Plantilla<typename_InputIterator>
Vacío
_M_assign_aux(_inputoperator__first,_InputIterator__last,
_ p>
Input_Iterator_Label);
//Llamado por el segundo asignar_dispatch anterior
Template & lttypename _ ForwardIterator & gt
Empty
_ M _ asignar _ aux( _ iterador directo _ _ primero, _ForwardIterator __último,
adelante _ iterador _ etiqueta
// Llamado por asignar(n, t), el resultado es
<); p>//convirtiéndose en la misma cosa.Vacío
_M_fill_assign(size_type __n, const value _ type & amp_ _ val);
// Seguido de la función de inserción interna.
//Llamado por inserción de rango para implementar [23.1.1]/9
Plantilla & lttypename _ Integer & gt
Vacío
_ M _ insert _ despacho(iterador _ _ pos, _Integer __n, _Integer __val,
__true_type)
{
_M_fill_insert(__pos, static _ cast & ltsize _ type & gt(__n),
static_cast & ltvalue _ type & gt(_ _ val));
}
// Llamado por inserción de rango para implementar [23.1.1]/9
Plantilla & lttypename _ InputIterator & gt
Vacío
_ M _ insert _ despacho(iterador _ _ pos, _ InputIterator _ _ primero,
_ InputIterator _ _ último, __false_type)
{
typedef typename iterador _ rasgos & lt;_ InputIterator & gt *Iterator_Category
_ IterCategory
_M_range_insert(__pos, _first, _last, _ categoría ITER());
}
// Llamado por el segundo insert_dispatch anterior
Template & lttypename _ InputIterator & gt
Empty
_M_range_insert(iterator __pos ,_InputIterator__first,
_InputIterator __last, input_iterator_tag);
//Llamado por el segundo insert_dispatch anterior
Template& lttypename _ ForwardIterator & gt
Vacío
_M_range_insert( iterador __pos, _ForwardIterator __first,
_ForwardIterator __last, forward _ iterator _ tag);
//Llamado por insert(p, n, x), cuando el resultado es
//Lo mismo.
Vacío
_M_fill_insert(iterador __pos, size_type __n, valor constante _ tipo & amp_ _ x);
//Por llamada insert(p, x).
Vacío
_ M _ insert _ aux(iterador _ _ posición, valor constante _ tipo & amp_ _ x
};);