allocator Clase
La plantilla de clase describe un objeto que administra la asignación de almacenamiento y la liberación de las matrices de objetos de tipo Type
. Un objeto de clase allocator
es el objeto de asignador predeterminado especificado en los constructores de varias clases de plantilla de contenedor en la biblioteca estándar de C++.
Sintaxis
template <class Type>
class allocator
Parámetros
Tipo
Tipo de objeto al que se va a asignar o desasignar almacenamiento.
Comentarios
Todos los contenedores de la biblioteca estándar de C++ tienen un parámetro de plantilla establecido de forma predeterminada en allocator
. La creación de un contenedor con un asignador personalizado confiere control sobre la asignación y la liberación de los elementos de ese contenedor.
Así, por ejemplo, un objeto de asignador puede asignar almacenamiento en un montón privado o en la memoria compartida, o puede optimizar los tamaños de objetos pequeños o grandes. También puede especificar, a través de las definiciones de tipo que proporciona, que el acceso a los elementos tiene que realizarse a través de objetos de descriptor de acceso especiales que administran la memoria compartida, o realizar una recolección automática de elementos no utilizados. Por lo tanto, una clase que asigna almacenamiento con un objeto de asignador debe usar estos tipos para declarar los objetos de puntero y referencia, tal como hacen los contenedores de la biblioteca estándar de C++.
(C++98/03 solo) Si se deriva de la clase allocator, se tendrá que proporcionar un struct rebind cuyo typedef _Other
haga referencia a la clase recién derivada.
Por lo tanto, un asignador define los siguientes tipos:
pointer se comporta como un puntero a
Type
.const_pointer se comporta como un puntero constante a
Type
.reference se comporta como una referencia a
Type
.const_reference se comporta como una referencia constante a
Type
.
Estos Type
especifican el formato de los punteros y las referencias para los elementos asignados. (allocator::pointer no es necesariamente el mismo que Type*
para todos los objetos asignador, aun cuando tenga esta definición obvia para la clase allocator
).
C++11 y versiones posteriores: para permitir las operaciones de movimiento en el asignador, use la interfaz de asignador mínima e implemente el constructor de copias, así como los operadores == y! = y allocate y deallocate. Para obtener más información y ver un ejemplo, vea Asignadores
Miembros
Constructores
Nombre | Descripción |
---|---|
allocator | Constructores usados para crear objetos allocator . |
Typedefs
Nombre | Descripción |
---|---|
const_pointer | Tipo que proporciona un puntero constante al tipo de objeto administrado por el asignador. |
const_reference | Tipo que proporciona una referencia constante al tipo de objeto administrado por el asignador. |
difference_type | Tipo entero con signo que puede representar la diferencia entre valores de punteros que señalan al tipo de objeto administrado por el asignador. |
pointer | Tipo que proporciona un puntero al tipo de objeto administrado por el asignador. |
referencia | Tipo que proporciona una referencia al tipo de objeto administrado por el asignador. |
size_type | Tipo entero sin signo que puede representar la longitud de cualquier secuencia que un objeto de tipo allocator puede asignar. |
value_type | Tipo administrado por el asignador. |
Funciones
Nombre | Descripción |
---|---|
address | Encuentra la dirección de un objeto cuyo valor se especifica. |
allocate | Asigna un bloque de memoria lo suficientemente grande como para almacenar al menos un número especificado de elementos. |
construct | Crea un tipo concreto de objeto en una dirección especificada que se inicializa con un valor especificado. |
deallocate | Libera un número especificado de objetos del almacenamiento, a partir de la posición especificada. |
destroy | Llama a un destructor de objetos sin desasignar la memoria donde el objeto se almacena. |
max_size | Devuelve el número de elementos de tipo Type que podrían ser asignados por un objeto de clase allocator antes de que la memoria libre se agote. |
rebind | Estructura que permite que un asignador de objetos de un tipo asigne almacenamiento para objetos de otro tipo. |
Operadores
Nombre | Descripción |
---|---|
operator= | Asigna un objeto allocator a otro objeto allocator . |
address
Encuentra la dirección de un objeto cuyo valor se especifica.
pointer address(reference val) const;
const_pointer address(const_reference val) const;
Parámetros
val
Valor const o nonconst del objeto cuya dirección se busca.
Valor devuelto
Puntero const o nonconst al objeto encontrado de valor const o nonconst respectivamente.
Comentarios
Las funciones miembro devuelven la dirección de val en el formato que deben tener los punteros para los elementos asignados.
Ejemplo
// allocator_address.cpp
// compile with: /EHsc
#include <memory>
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <int> v1;
vector <int>::iterator v1Iter;
vector <int>:: allocator_type v1Alloc;
int i;
for ( i = 1 ; i <= 7 ; i++ )
{
v1.push_back( 2 * i );
}
cout << "The original vector v1 is:\n ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
allocator<int>::const_pointer v1Ptr;
const int k = 8;
v1Ptr = v1Alloc.address( *find(v1.begin( ), v1.end( ), k) );
// v1Ptr = v1Alloc.address( k );
cout << "The integer addressed by v1Ptr has a value of: "
<< "*v1Ptr = " << *v1Ptr << "." << endl;
}
The original vector v1 is:
( 2 4 6 8 10 12 14 ).
The integer addressed by v1Ptr has a value of: *v1Ptr = 8.
allocate
Asigna un bloque de memoria lo suficientemente grande como para almacenar al menos un número especificado de elementos.
pointer allocate(size_type count, const void* _Hint);
Parámetros
count
Número de elementos para los que se va a asignar suficiente espacio de almacenamiento.
_Hint
Puntero const que puede ayudar al objeto de asignador a satisfacer la solicitud de almacenamiento al buscar la dirección de un objeto asignado antes de la solicitud.
Valor devuelto
Puntero al objeto asignado o nulo si no se ha asignado memoria.
Comentarios
La función miembro asigna almacenamiento para una matriz de elementos count de tipo Type
al llamar al operador new(count). Devuelve un puntero al objeto asignado. El argumento de sugerencia ayuda a algunos asignadores a mejorar la localidad de referencia; una opción válida es la dirección de un objeto anteriormente asignado por el mismo objeto de asignador y que aún no se ha desasignado. Para no proporcionar ningún argumento de sugerencia, use un argumento de puntero nulo.
Ejemplo
// allocator_allocate.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
allocator<int> v1Alloc;
allocator<int>::pointer v1aPtr;
v1aPtr = v1Alloc.allocate ( 10 );
int i;
for ( i = 0 ; i < 10 ; i++ )
{
v1aPtr[ i ] = i;
}
for ( i = 0 ; i < 10 ; i++ )
{
cout << v1aPtr[ i ] << " ";
}
cout << endl;
v1Alloc.deallocate( v1aPtr, 10 );
}
0 1 2 3 4 5 6 7 8 9
allocator
Constructores usados para crear objetos de asignador.
allocator();
allocator(const allocator<Type>& right);
template <class Other>
allocator(const allocator<Other>& right);
Parámetros
right
Objeto de asignador que se va a copiar.
Comentarios
El constructor no hace nada. Pero, en general, un objeto de asignador creado a partir de otro objeto de asignador debe ser igual a él y permitir la mezcla de asignación de objetos y liberación entre los dos objetos de asignador.
Ejemplo
// allocator_allocator.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
class Int {
public:
Int( int i )
{
cout << "Constructing " << ( void* )this << endl;
x = i;
bIsConstructed = true;
};
~Int( )
{
cout << "Destructing " << ( void* )this << endl;
bIsConstructed = false;
};
Int &operator++( )
{
x++;
return *this;
};
int x;
private:
bool bIsConstructed;
};
int main( )
{
allocator<double> Alloc;
vector <Int>:: allocator_type v1Alloc;
allocator<double> cAlloc(Alloc);
allocator<Int> cv1Alloc(v1Alloc);
if ( cv1Alloc == v1Alloc )
cout << "The allocator objects cv1Alloc & v1Alloc are equal."
<< endl;
else
cout << "The allocator objects cv1Alloc & v1Alloc are not equal."
<< endl;
if ( cAlloc == Alloc )
cout << "The allocator objects cAlloc & Alloc are equal."
<< endl;
else
cout << "The allocator objects cAlloc & Alloc are not equal."
<< endl;
}
The allocator objects cv1Alloc & v1Alloc are equal.
The allocator objects cAlloc & Alloc are equal.
const_pointer
Tipo que proporciona un puntero constante al tipo de objeto administrado por el asignador.
typedef const value_type *const_pointer;
Comentarios
El tipo de puntero describe un objeto ptr
que puede designar, a través de la expresión *ptr
, cualquier objeto const que un objeto tipo allocator
puede asignar.
Ejemplo
// allocator_const_ptr.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <int> v1;
vector <int>::iterator v1Iter;
vector <int>:: allocator_type v1Alloc;
int i;
for ( i = 1 ; i <= 7 ; i++ )
{
v1.push_back( i * 2 );
}
cout << "The original vector v1 is:\n ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
allocator<int>::const_pointer v1Ptr;
const int k = 10;
v1Ptr = v1Alloc.address( k );
cout << "The integer's address found has a value of: "
<< *v1Ptr << "." << endl;
}
The original vector v1 is:
( 2 4 6 8 10 12 14 ).
The integer's address found has a value of: 10.
const_reference
Tipo que proporciona una referencia constante al tipo de objeto administrado por el asignador.
typedef const value_type& const_reference;
Comentarios
El tipo de referencia describe un objeto que puede designar cualquier objeto const que un tipo allocator
puede asignar.
Ejemplo
// allocator_const_ref.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <double> v;
vector <double> ::iterator vIter, vfIter;
vector <double> :: allocator_type vAlloc;
int j;
for ( j = 1 ; j <= 7 ; j++ )
{
v.push_back( 100.0 * j );
}
cout << "The original vector v is:\n ( " ;
for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
cout << *vIter << " ";
cout << ")." << endl;
vfIter = v.begin( );
allocator<double>::const_reference vcref =*vfIter;
cout << "The value of the element referred to by vref is: "
<< vcref << ",\n the first element in the vector." << endl;
// const references can have their elements modified,
// so the following would generate an error:
// vcref = 150;
// but the value of the first element could be modified through
// its nonconst iterator and the const reference would remain valid
*vfIter = 175;
cout << "The value of the element referred to by vcref,"
<<"\n after nofication through its nonconst iterator, is: "
<< vcref << "." << endl;
}
The original vector v is:
( 100 200 300 400 500 600 700 ).
The value of the element referred to by vref is: 100,
the first element in the vector.
The value of the element referred to by vcref,
after nofication through its nonconst iterator, is: 175.
construct
Crea un tipo concreto de objeto en una dirección especificada que se inicializa con un valor especificado.
void construct(pointer ptr, const Type& val);
void construct(pointer ptr, Type&& val);
template <class _Other>
void construct(pointer ptr, _Other&&... val);
Parámetros
ptr
Puntero a la ubicación donde se va a crear el objeto.
val
Valor con el que se va a inicializar el objeto que se está creando.
Comentarios
La primera función miembro es equivalente a new ((void *) ptr) Type(val)
.
Ejemplo
// allocator_construct.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main( )
{
vector <int> v1;
vector <int>::iterator v1Iter;
vector <int>:: allocator_type v1Alloc;
int i;
for ( i = 1 ; i <= 7 ; i++ )
{
v1.push_back( 3 * i );
}
cout << "The original vector v1 is:\n ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
allocator<int>::pointer v1PtrA;
int kA = 6, kB = 7;
v1PtrA = v1Alloc.address( *find( v1.begin( ), v1.end( ), kA ) );
v1Alloc.destroy ( v1PtrA );
v1Alloc.construct ( v1PtrA , kB );
cout << "The modified vector v1 is:\n ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
}
The original vector v1 is:
( 3 6 9 12 15 18 21 ).
The modified vector v1 is:
( 3 7 9 12 15 18 21 ).
deallocate
Libera un número especificado de objetos del almacenamiento, a partir de la posición especificada.
void deallocate(pointer ptr, size_type count);
Parámetros
ptr
Un puntero al primer objeto que se va a desasignar del almacenamiento.
count
El número de objetos que se van a desasignar del almacenamiento.
Comentarios
La función miembro libera almacenamiento para la matriz de objetos count de tipo Type
comenzando en ptr, al llamar a operator delete(ptr)
. El puntero ptr debió haber sido devuelto antes por una llamada a allocate mediante un objeto asignador que compara con *this, asignando un objeto de matriz del mismo tamaño y tipo. deallocate
nunca inicia una excepción.
Ejemplo
Para ver un ejemplo de uso de la función miembro, vea allocator::allocate.
destroy
Llama a un destructor de objetos sin desasignar la memoria donde el objeto se almacena.
void destroy(pointer ptr);
Parámetros
ptr
Puntero que designa la dirección del objeto que se va a destruir.
Comentarios
La función miembro destruye el objeto designado por ptr, al llamar al destructor ptr->Type::~Type
.
Ejemplo
// allocator_destroy.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main( )
{
vector <int> v1;
vector <int>::iterator v1Iter;
vector <int>:: allocator_type v1Alloc;
int i;
for ( i = 1 ; i <= 7 ; i++ )
{
v1.push_back( 2 * i );
}
cout << "The original vector v1 is:\n ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
allocator<int>::pointer v1PtrA;
int kA = 12, kB = -99;
v1PtrA = v1Alloc.address( *find(v1.begin( ), v1.end( ), kA) );
v1Alloc.destroy ( v1PtrA );
v1Alloc.construct ( v1PtrA , kB );
cout << "The modified vector v1 is:\n ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
}
The original vector v1 is:
( 2 4 6 8 10 12 14 ).
The modified vector v1 is:
( 2 4 6 8 10 -99 14 ).
difference_type
Tipo entero con signo que puede representar la diferencia entre valores de punteros que señalan al tipo de objeto administrado por el asignador.
typedef ptrdiff_t difference_type;
Comentarios
El tipo de entero con signo describe un objeto que puede representar la diferencia entre las direcciones de dos elementos de una secuencia que un objeto de tipo allocator
puede asignar.
Ejemplo
// allocator_diff_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <int> v1;
vector <int>::iterator v1Iter;
vector <int>:: allocator_type v1Alloc;
int i;
for ( i = 0 ; i <= 7 ; i++ )
{
v1.push_back( i * 2 );
}
cout << "The original vector v1 is:\n ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
allocator<int>::const_pointer v1PtrA, v1PtrB;
const int kA = 4, kB =12;
v1PtrA = v1Alloc.address( kA );
v1PtrB = v1Alloc.address( kB );
allocator<int>::difference_type v1diff = *v1PtrB - *v1PtrA;
cout << "Pointer v1PtrA addresses " << *v1PtrA << "." << endl;
cout << "Pointer v1PtrB addresses " << *v1PtrB << "." << endl;
cout << "The difference between the integer's addresses is: "
<< v1diff << "." << endl;
}
The original vector v1 is:
( 0 2 4 6 8 10 12 14 ).
Pointer v1PtrA addresses 4.
Pointer v1PtrB addresses 12.
The difference between the integer's addresses is: 8.
max_size
Devuelve el número de elementos de tipo Type
que podría asignar un objeto de clase allocator antes de que la memoria libre se agote.
size_type max_size() const;
Valor devuelto
Número de elementos que se pueden asignar.
Ejemplo
// allocator_max_size.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <int> v1;
vector <int>::iterator v1Iter;
vector <int>:: allocator_type v1Alloc;
int i;
for ( i = 1 ; i <= 7 ; i++ )
{
v1.push_back( i );
}
cout << "The original vector v1 is:\n ( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
vector <double> v2;
vector <double> ::iterator v2Iter;
vector <double> :: allocator_type v2Alloc;
allocator<int>::size_type v1size;
v1size = v1Alloc.max_size( );
cout << "The number of integers that can be allocated before\n"
<< " the free memory in the vector v1 is used up is: "
<< v1size << "." << endl;
int ii;
for ( ii = 1 ; ii <= 7 ; ii++ )
{
v2.push_back( ii * 10.0 );
}
cout << "The original vector v2 is:\n ( " ;
for ( v2Iter = v2.begin( ) ; v2Iter != v2.end( ) ; v2Iter++ )
cout << *v2Iter << " ";
cout << ")." << endl;
allocator<double>::size_type v2size;
v2size = v2Alloc.max_size( );
cout << "The number of doubles that can be allocated before\n"
<< " the free memory in the vector v2 is used up is: "
<< v2size << "." << endl;
}
operator=
Asigna un objeto de asignador a otro objeto de asignador.
template <class Other>
allocator<Type>& operator=(const allocator<Other>& right);
Parámetros
right
Un objeto de asignador que se va a asignar a otro de esos objetos.
Valor devuelto
Referencia al objeto de asignador
Comentarios
El operador de asignaciones de plantilla no hace nada. Pero, en general, un objeto de asignador asignado a otro objeto de asignador debe ser igual a él y permitir la mezcla de asignación de objetos y liberación entre los dos objetos de asignador.
Ejemplo
// allocator_op_assign.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
class Int {
public:
Int(int i)
{
cout << "Constructing " << ( void* )this << endl;
x = i;
bIsConstructed = true;
};
~Int( ) {
cout << "Destructing " << ( void* )this << endl;
bIsConstructed = false;
};
Int &operator++( )
{
x++;
return *this;
};
int x;
private:
bool bIsConstructed;
};
int main( )
{
allocator<Int> Alloc;
allocator<Int> cAlloc ;
cAlloc = Alloc;
}
pointer
Tipo que proporciona un puntero al tipo de objeto administrado por el asignador.
typedef value_type *pointer;
Comentarios
El tipo de puntero describe un objeto ptr
que puede designar, a través de la expresión *ptr, cualquier objeto que uno de tipo allocator
pueda asignar.
Ejemplo
// allocator_ptr.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <int> v1;
vector <int>::iterator v1Iter;
vector <int>:: allocator_type v1Alloc;
int i;
for ( i = 1 ; i <= 7 ; i++ )
{
v1.push_back( 3 * i );
}
cout << "The original vector v1 is:\n( " ;
for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
cout << *v1Iter << " ";
cout << ")." << endl;
allocator<int>::const_pointer v1Ptr;
const int k = 12;
v1Ptr = v1Alloc.address( k );
cout << "The integer addressed by v1Ptr has a value of: "
<< "*v1Ptr = " << *v1Ptr << "." << endl;
}
The original vector v1 is:
( 3 6 9 12 15 18 21 ).
The integer addressed by v1Ptr has a value of: *v1Ptr = 12.
rebind
Estructura que permite que un asignador de objetos de un tipo asigne almacenamiento para objetos de otro tipo.
struct rebind { typedef allocator<_Other> other; };
Parámetros
other
Tipo de elemento para el que se está asignando memoria.
Comentarios
Esta estructura es útil para asignar memoria para el tipo que difiere del tipo de elemento del contenedor que se va a implementar.
La plantilla de clase miembro define el tipo other. Su única finalidad es proporcionar el nombre de tipo allocator<_Other>
, dado el nombre de tipo allocator<Type>
.
Por ejemplo, dado un objeto de asignador al
de tipo A
, se puede asignar un objeto de tipo _Other
con la expresión:
A::rebind<Other>::other(al).allocate(1, (Other *)0)
O bien, puede asignar el nombre de su tipo de puntero si escribe el tipo:
A::rebind<Other>::other::pointer
Ejemplo
// allocator_rebind.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef vector<int>::allocator_type IntAlloc;
int main( )
{
IntAlloc v1Iter;
vector<int> v1;
IntAlloc::rebind<char>::other::pointer pszC =
IntAlloc::rebind<char>::other(v1.get_allocator()).allocate(1, (void *)0);
int * pInt = v1Iter.allocate(10);
}
reference
Tipo que proporciona una referencia al tipo de objeto administrado por el asignador.
typedef value_type& reference;
Comentarios
El tipo de referencia describe un objeto que puede designar cualquier objeto que un tipo allocator
puede asignar.
Ejemplo
// allocator_reference.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <double> v;
vector <double> ::iterator vIter, vfIter;
vector <double> :: allocator_type vAlloc;
int j;
for ( j = 1 ; j <= 7 ; j++ )
{
v.push_back( 100.0 * j );
}
cout << "The original vector v is:\n ( " ;
for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
cout << *vIter << " ";
cout << ")." << endl;
vfIter = v.begin( );
allocator<double>::reference vref =*vfIter;
cout << "The value of the element referred to by vref is: "
<< vref << ",\n the first element in the vector." << endl;
// nonconst references can have their elements modified
vref = 150;
cout << "The element referred to by vref after being modified is: "
<< vref << "." << endl;
}
The original vector v is:
( 100 200 300 400 500 600 700 ).
The value of the element referred to by vref is: 100,
the first element in the vector.
The element referred to by vref after being modified is: 150.
size_type
Tipo entero sin signo que puede representar la longitud de cualquier secuencia que un objeto de tipo allocator
puede asignar.
typedef size_t size_type;
Ejemplo
// allocator_size_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <double> v;
vector <double> ::iterator vIter;
vector <double> :: allocator_type vAlloc;
int j;
for ( j = 1 ; j <= 7 ; j++ )
{
v.push_back( 100.0 * j );
}
cout << "The original vector v is:\n ( " ;
for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
cout << *vIter << " ";
cout << ")." << endl;
allocator<double>::size_type vsize;
vsize = vAlloc.max_size( );
cout << "The number of doubles that can be allocated before\n"
<< " the free memory in the vector v is used up is: "
<< vsize << "." << endl;
}
value_type
Tipo administrado por el asignador.
typedef Type value_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Type
.
Ejemplo
// allocator_value_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
#include <vector>
using namespace std;
int main( )
{
vector <double> v;
vector <double> ::iterator vIter, vfIter;
vector <double> :: allocator_type vAlloc;
int j;
for ( j = 1 ; j <= 7 ; j++ )
{
v.push_back( 100.0 * j );
}
cout << "The original vector v is:\n ( " ;
for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
cout << *vIter << " ";
cout << ")." << endl;
vfIter = v.begin( );
allocator<double>::value_type vecVal = 150.0;
*vfIter = vecVal;
cout << "The value of the element addressed by vfIter is: "
<< *vfIter << ",\n the first element in the vector." << endl;
cout << "The modified vector v is:\n ( " ;
for ( vIter = v.begin( ) ; vIter != v.end( ) ; vIter++ )
cout << *vIter << " ";
cout << ")." << endl;
}
The original vector v is:
( 100 200 300 400 500 600 700 ).
The value of the element addressed by vfIter is: 150,
the first element in the vector.
The modified vector v is:
( 150 200 300 400 500 600 700 ).
Asistentes
allocator_arg_t
struct allocator_arg_t { explicit allocator_arg_t() = default; };
inline constexpr allocator_arg_t allocator_arg{};
uses_allocator
template <class T, class Alloc> struct uses_allocator;
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente las Cuestiones de GitHub como mecanismo de retroalimentación para el contenido y lo sustituiremos por un nuevo sistema de retroalimentación. Para más información, consulta:Enviar y ver comentarios de