list (STL/CLR)
La clase de plantilla describe un objeto que controla una secuencia de longitud variable de elementos que tienen acceso bidireccional. El contenedor list se usa para administrar una secuencia de elementos como una lista de vínculo bidireccional de nodos, cada una almacenando un elemento.
En la descripción siguiente, GValue es igual que Value, a menos que este último sea un tipo de referencia, en cuyo caso es Value^.
Sintaxis
template<typename Value>
ref class list
: public
System::ICloneable,
System::Collections::IEnumerable,
System::Collections::ICollection,
System::Collections::Generic::IEnumerable<GValue>,
System::Collections::Generic::ICollection<GValue>,
Microsoft::VisualC::StlClr::IList<GValue>
{ ..... };
Parámetros
Valor
Tipo de un elemento de la secuencia controlada.
Requisitos
Encabezado:<cliext/list>
Espacio de nombres: cliext
Declaraciones
| Definición de tipo | Descripción |
|---|---|
| list::const_iterator (STL/CLR) | El tipo de un iterador constante para la secuencia controlada. |
| list::const_reference (STL/CLR) | El tipo de una referencia constante a un elemento. |
| list::const_reverse_iterator (STL/CLR) | El tipo de un iterador invertido constante para la secuencia controlada. |
| list::difference_type (STL/CLR) | El tipo de una distancia con signo entre dos elementos. |
| list::generic_container (STL/CLR) | Tipo de la interfaz genérica para el contenedor. |
| list::generic_iterator (STL/CLR) | Tipo de iterador de la interfaz genérica del contenedor. |
| list::generic_reverse_iterator (STL/CLR) | Tipo de iterador inverso para la interfaz genérica del contenedor. |
| list::generic_value (STL/CLR) | Tipo de elemento para la interfaz genérica del contenedor. |
| list::iterator (STL/CLR) | El tipo de un iterador para la secuencia controlada. |
| list::reference (STL/CLR) | El tipo de una referencia a un elemento. |
| list::reverse_iterator (STL/CLR) | El tipo de un iterador invertido para la secuencia controlada. |
| list::size_type (STL/CLR) | El tipo de una distancia con signo entre dos elementos. |
| list::value_type (STL/CLR) | El tipo de un elemento. |
| Función miembro | Descripción |
|---|---|
| list::assign (STL/CLR) | Reemplaza todos los elementos. |
| list::back (STL/CLR) | Obtiene acceso al último elemento. |
| list::begin (STL/CLR) | Designa el principio de la secuencia controlada. |
| list::clear (STL/CLR) | Quita todos los elementos. |
| list::empty (STL/CLR) | Comprueba si no hay ningún elemento presente. |
| list::end (STL/CLR) | Designa el final de la secuencia controlada. |
| list::erase (STL/CLR) | Quita los elementos de las posiciones especificadas. |
| list::front (STL/CLR) | Obtiene acceso al primer elemento. |
| list::insert (STL/CLR) | Agrega elementos en una posición especificada. |
| list::list (STL/CLR) | Construye un objeto contenedor. |
| list::merge (STL/CLR) | Combina dos secuencias controladas ordenadas. |
| list::pop_back (STL/CLR) | Quita el último elemento. |
| list::pop_front (STL/CLR) | Quita el primer elemento. |
| list::push_back (STL/CLR) | Agrega un nuevo último elemento. |
| list::push_front (STL/CLR) | Agrega un nuevo primer elemento. |
| list::rbegin (STL/CLR) | Designa el principio de la secuencia controlada inversa. |
| list::remove (STL/CLR) | Quita un elemento con un valor especificado. |
| list::remove_if (STL/CLR) | Quita los elementos que superan una prueba especificada. |
| list::rend (STL/CLR) | Designa el final de la secuencia controlada inversa. |
| list::resize (STL/CLR) | Cambia el número de elementos. |
| list::reverse (STL/CLR) | Invierte la secuencia controlada. |
| list::size (STL/CLR) | Cuenta el número de elementos. |
| list::sort (STL/CLR) | Ordena la secuencia controlada. |
| list::splice (STL/CLR) | Vuelve a unir vínculos entre nodos. |
| list::swap (STL/CLR) | Intercambia el contenido de dos contenedores. |
| list::to_array (STL/CLR) | Copia la secuencia controlada en una nueva matriz. |
| list::unique (STL/CLR) | Quita los elementos adyacentes que superan una prueba especificada. |
| Propiedad | Descripción |
|---|---|
| list::back_item (STL/CLR) | Obtiene acceso al último elemento. |
| list::front_item (STL/CLR) | Obtiene acceso al primer elemento. |
| Operator | Descripción |
|---|---|
| list::operator= (STL/CLR) | Reemplaza la secuencia controlada. |
| operator!= (list) (STL/CLR) | Determina si un objeto list no es igual que otro objeto list. |
| operator (list) (STL/CLR)< | Determina si un objeto list es menor que otro objeto list. |
| operator<= (list) (STL/CLR) | Determina si un objeto list es menor o igual que otro objeto list. |
| operator== (list) (STL/CLR) | Determina si un objeto list es igual que otro objeto list. |
| operator (list) (STL/CLR)> | Determina si un objeto list es mayor que otro objeto list. |
| operator>= (list) (STL/CLR) | Determina si un objeto list es mayor o igual que otro objeto list. |
Interfaces
| Interfaz | Descripción |
|---|---|
| ICloneable | Duplica un objeto. |
| IEnumerable | Moverse en secuencia por los elementos. |
| ICollection | Mantener un grupo de elementos. |
| IEnumerable<T> | Moverse en secuencia por los elementos con tipo. |
| ICollection<T> | Mantiene un grupo de elementos con tipo. |
| Valor<IList> | Mantener el contenedor genérico. |
Comentarios
El objeto asigna y libera almacenamiento para la secuencia que controla como nodos individuales en una lista de vínculo bidireccional. Reorganiza los elementos al modificar los vínculos entre nodos, nunca al copiar el contenido de un nodo a otro. Esto significa que puede insertar y quitar elementos libremente sin alterar los elementos restantes. Por lo tanto, una lista es un buen candidato para el contenedor subyacente para la cola de la clase de plantilla (STL/CLR) o la pila de clases de plantilla (STL/CLR).
Un objeto list admite iteradores bidireccionales, lo que significa que puede ir paso a paso a los elementos adyacentes dado un iterador que designe un elemento de la secuencia controlada. Un nodo principal especial corresponde al iterador devuelto por list::end (STL/CLR)(). Puede reducir este iterador para llegar al último elemento de la secuencia controlada, si está presente. Se puede incrementar un iterador de lista para llegar al nodo principal y entonces se comprará como igual a end(). Pero no se puede desreferenciar el iterador que devuelve end().
Tenga en cuenta que no puede hacer referencia directa a un elemento de lista dada su posición numérica, que requiere un iterador de acceso aleatorio. Por lo tanto, una lista no se puede usar como contenedor subyacente para la clase de plantilla priority_queue (STL/CLR).
Un iterador de lista almacena un manipulador en su nodo de lista asociado, que a su vez almacena un manipulador en su contenedor asociado. Solo puede usar iteradores con sus objetos de contenedor asociados. Un iterador de lista permanece válido siempre que su nodo de lista asociado esté vinculado a alguna lista. Además, un iterador válido se puede desreferenciar; puede usarlo para tener acceso o modificar el valor de elemento que designa, siempre y cuando no sea igual a end().
Borrar o quitar un elemento llama al destructor para su valor almacenado. Al destruir el contenedor, se borran todos los elementos. Por lo tanto, un contenedor cuyo tipo de elemento es una clase de referencia garantiza que ningún elemento sobrevive al contenedor. Sin embargo, tenga en cuenta que un contenedor de manipuladores no destruye sus elementos.
Miembros
list::assign (STL/CLR)
Reemplaza todos los elementos.
Sintaxis
void assign(size_type count, value_type val);
template<typename InIt>
void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);
Parámetros
count
Número de elementos que se van a insertar.
first
Principio del intervalo que se va a insertar.
last
Fin del intervalo que se va a insertar.
right
Enumeración que se va a insertar.
val
Valor del elemento que se va a insertar.
Comentarios
La primera función miembro reemplaza la secuencia controlada por una repetición de count elementos de valor val. Se usa para rellenar el contenedor con elementos que tienen el mismo valor.
Si InIt es un tipo entero, la segunda función miembro se comporta igual que assign((size_type)first, (value_type)last). En caso contrario, reemplaza la secuencia controlada por la secuencia [first, last). Se usa para que la secuencia controlada sea una copia de otra secuencia.
La tercera función miembro reemplaza la secuencia controlada por la secuencia designada por el enumerador derecho. Se usa para convertir la secuencia controlada en una copia de una secuencia descrita por un enumerador.
Ejemplo
// cliext_list_assign.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// assign a repetition of values
cliext::list<wchar_t> c2;
c2.assign(6, L'x');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign an iterator range
cliext::list<wchar_t>::iterator it = c1.end();
c2.assign(c1.begin(), --it);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign an enumeration
c2.assign( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
x x x x x x
a b
a b c
list::back (STL/CLR)
Obtiene acceso al último elemento.
Sintaxis
reference back();
Comentarios
La función miembro devuelve una referencia al último elemento de la secuencia controlada, que no debe estar vacío. Se usa para acceder al último elemento, cuando se sabe que existe.
Ejemplo
// cliext_list_back.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last item
System::Console::WriteLine("back() = {0}", c1.back());
// alter last item and reinspect
c1.back() = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
back() = c
a b x
list::back_item (STL/CLR)
Obtiene acceso al último elemento.
Sintaxis
property value_type back_item;
Comentarios
La propiedad accede al último elemento de la secuencia controlada, que no debe estar vacío. Se usa para leer o escribir el último elemento, cuando se sabe que existe.
Ejemplo
// cliext_list_back_item.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last item
System::Console::WriteLine("back_item = {0}", c1.back_item);
// alter last item and reinspect
c1.back_item = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
back_item = c
a b x
list::begin (STL/CLR)
Designa el principio de la secuencia controlada.
Sintaxis
iterator begin();
Comentarios
La función miembro devuelve un iterador de acceso aleatorio que designa el primer elemento de la secuencia controlada o apunta inmediatamente después del final de una secuencia vacía. Se usa para obtener un iterador que designe el current principio de la secuencia controlada, pero su estado puede cambiar si cambia la longitud de la secuencia controlada.
Ejemplo
// cliext_list_begin.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
cliext::list<wchar_t>::iterator it = c1.begin();
System::Console::WriteLine("*begin() = {0}", *it);
System::Console::WriteLine("*++begin() = {0}", *++it);
// alter first two items and reinspect
*--it = L'x';
*++it = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*begin() = a
*++begin() = b
x y c
list::clear (STL/CLR)
Quita todos los elementos.
Sintaxis
void clear();
Comentarios
La función miembro llama eficazmente a list::erase (STL/CLR)(list::begin (STL/CLR)(),list::end (STL/CLR)()). Se usa para garantizar que la secuencia controlada está vacía.
Ejemplo
// cliext_list_clear.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
// add elements and clear again
c1.push_back(L'a');
c1.push_back(L'b');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
a b c
size() = 0
a b
size() = 0
list::const_iterator (STL/CLR)
El tipo de un iterador constante para la secuencia controlada.
Sintaxis
typedef T2 const_iterator;
Comentarios
El tipo describe un objeto de tipo sin especificar T2 que puede actuar como un iterador constante de acceso aleatorio para la secuencia controlada.
Ejemplo
// cliext_list_const_iterator.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
cliext::list<wchar_t>::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
System::Console::Write("{0} ", *cit);
System::Console::WriteLine();
return (0);
}
a b c
list::const_reference (STL/CLR)
El tipo de una referencia constante a un elemento.
Sintaxis
typedef value_type% const_reference;
Comentarios
El tipo describe una referencia constante a un elemento.
Ejemplo
// cliext_list_const_reference.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
cliext::list<wchar_t>::const_iterator cit = c1.begin();
for (; cit != c1.end(); ++cit)
{ // get a const reference to an element
cliext::list<wchar_t>::const_reference cref = *cit;
System::Console::Write("{0} ", cref);
}
System::Console::WriteLine();
return (0);
}
a b c
list::const_reverse_iterator (STL/CLR)
El tipo de un iterador invertido constante de la secuencia controlada.
Sintaxis
typedef T4 const_reverse_iterator;
Comentarios
El tipo describe un objeto de tipo sin especificar T4 que puede actuar como un iterador inverso constante de la secuencia controlada.
Ejemplo
// cliext_list_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" reversed
cliext::list<wchar_t>::const_reverse_iterator crit = c1.rbegin();
cliext::list<wchar_t>::const_reverse_iterator crend = c1.rend();
for (; crit != crend; ++crit)
System::Console::Write("{0} ", *crit);
System::Console::WriteLine();
return (0);
}
c b a
list::difference_type (STL/CLR)
Tipos de una distancia con signo entre dos elementos.
Sintaxis
typedef int difference_type;
Comentarios
El tipo describe un recuento de elementos con signo.
Ejemplo
// cliext_list_difference_type.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
cliext::list<wchar_t>::difference_type diff = 0;
for (cliext::list<wchar_t>::iterator it = c1.begin();
it != c1.end(); ++it) ++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
// compute negative difference
diff = 0;
for (cliext::list<wchar_t>::iterator it = c1.end();
it != c1.begin(); --it) --diff;
System::Console::WriteLine("begin()-end() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
begin()-end() = -3
list::empty (STL/CLR)
Comprueba si no hay ningún elemento presente.
Sintaxis
bool empty();
Comentarios
La función miembro devuelve true para una secuencia controlada vacía. Es equivalente a list::size (STL/CLR)() == 0. Se usa para comprobar si la lista está vacía.
Ejemplo
// cliext_list_empty.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0}", c1.size());
System::Console::WriteLine("empty() = {0}", c1.empty());
return (0);
}
a b c
size() = 3
empty() = False
size() = 0
empty() = True
list::end (STL/CLR)
Designa el final de la secuencia controlada.
Sintaxis
iterator end();
Comentarios
La función miembro devuelve un iterador de acceso aleatorio que apunta inmediatamente después del final de la secuencia controlada. Se usa para obtener un iterador que designe el final de la secuencia controlada; sin embargo, su estado no cambia si cambia la longitud de la secuencia controlada.
Ejemplo
// cliext_list_end.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect last two items
cliext::list<wchar_t>::iterator it = c1.end();
--it;
System::Console::WriteLine("*-- --end() = {0}", *--it);
System::Console::WriteLine("*--end() = {0}", *++it);
// alter first two items and reinspect
*--it = L'x';
*++it = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*-- --end() = b
*--end() = c
a x y
list::erase (STL/CLR)
Quita los elementos de las posiciones especificadas.
Sintaxis
iterator erase(iterator where);
iterator erase(iterator first, iterator last);
Parámetros
first
Principio del intervalo que se va a borrar.
last
Fin del intervalo que se va a borrar.
where
Elemento que se va a borrar.
Comentarios
La primera función miembro quita el elemento de la secuencia controlada a la que apunta where. Se usa para quitar un único elemento.
La segunda función miembro quita los elementos de la secuencia controlada en el intervalo [first, last). Se usa para quitar cero o más elementos contiguos.
Ambas funciones miembro devuelven un iterador que designa el primer elemento que permanece más allá de los elementos quitados o list::end (STL/CLR)() si no existe ese elemento.
Al borrar elementos, el número de copias de elementos es lineal en el número de elementos entre el final de la eliminación y el extremo más cercano de la secuencia. (Al borrar uno o varios elementos al final de la secuencia, no se produce ninguna copia de elementos).
Ejemplo
// cliext_list_erase.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// erase an element and reinspect
System::Console::WriteLine("erase(begin()) = {0}",
*c1.erase(c1.begin()));
// add elements and display " b c d e"
c1.push_back(L'd');
c1.push_back(L'e');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// erase all but end
cliext::list<wchar_t>::iterator it = c1.end();
System::Console::WriteLine("erase(begin(), end()-1) = {0}",
*c1.erase(c1.begin(), --it));
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1
list::front (STL/CLR)
Obtiene acceso al primer elemento.
Sintaxis
reference front();
Comentarios
La función miembro devuelve una referencia al primer elemento de la secuencia controlada, que no debe estar vacío. Se usa para leer o escribir el primer elemento, cuando se sabe que existe.
Ejemplo
// cliext_list_front.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first item
System::Console::WriteLine("front() = {0}", c1.front());
// alter first item and reinspect
c1.front() = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
front() = a
x b c
list::front_item (STL/CLR)
Obtiene acceso al primer elemento.
Sintaxis
property value_type front_item;
Comentarios
La propiedad accede al primer elemento de la secuencia controlada, que no debe estar vacío. Se usa para leer o escribir el primer elemento, cuando se sabe que existe.
Ejemplo
// cliext_list_front_item.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first item
System::Console::WriteLine("front_item = {0}", c1.front_item);
// alter first item and reinspect
c1.front_item = L'x';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
front_item = a
x b c
list::generic_container (STL/CLR)
Tipo de la interfaz genérica para el contenedor.
Sintaxis
typedef Microsoft::VisualC::StlClr::
IList<generic_value>
generic_container;
Comentarios
El tipo describe la interfaz genérica de esta clase contenedora de plantilla.
Ejemplo
// cliext_list_generic_container.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::list<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
gc1->insert(gc1->end(), L'd');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify original and display generic
c1.push_back(L'e');
System::Collections::IEnumerator^ enum1 =
gc1->GetEnumerator();
while (enum1->MoveNext())
System::Console::Write("{0} ", enum1->Current);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a b c d
a b c d e
list::generic_iterator (STL/CLR)
Tipo de iterador para usarlo con la interfaz genérica del contenedor.
Sintaxis
typedef Microsoft::VisualC::StlClr::Generic::
ContainerBidirectionalIterator<generic_value>
generic_iterator;
Comentarios
El tipo describe un iterador genérico que se puede usar con la interfaz genérica de esta clase de contenedor de plantilla.
Ejemplo
// cliext_list_generic_iterator.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::list<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::list<wchar_t>::generic_iterator gcit = gc1->begin();
cliext::list<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a a c
list::generic_reverse_iterator (STL/CLR)
Tipo de iterador inverso que se usa con la interfaz genérica del contenedor.
Sintaxis
typedef Microsoft::VisualC::StlClr::Generic::
ReverseBidirectionalIterator<generic_value> generic_reverse_iterator;
Comentarios
El tipo describe un iterador inverso genérico que se puede usar con la interfaz genérica de esta clase de contenedor de plantilla.
Ejemplo
// cliext_list_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::list<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::list<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
cliext::list<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a c c
list::generic_value (STL/CLR)
Tipo de elemento para usarlo con la interfaz genérica del contenedor.
Sintaxis
typedef GValue generic_value;
Comentarios
El tipo describe un objeto de tipo GValue que describe el valor del elemento almacenado que se debe usar con la interfaz genérica de esta clase contenedora de plantilla.
Ejemplo
// cliext_list_generic_value.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct a generic container
cliext::list<wchar_t>::generic_container^ gc1 = %c1;
for each (wchar_t elem in gc1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// modify generic and display original
cliext::list<wchar_t>::generic_iterator gcit = gc1->begin();
cliext::list<wchar_t>::generic_value gcval = *gcit;
*++gcit = gcval;
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a a c
list::insert (STL/CLR)
Agrega elementos en una posición especificada.
Sintaxis
iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
System::Collections::Generic::IEnumerable<Value>^ right);
Parámetros
count
Número de elementos que se van a insertar.
first
Principio del intervalo que se va a insertar.
last
Fin del intervalo que se va a insertar.
right
Enumeración que se va a insertar.
val
Valor del elemento que se va a insertar.
where
Lugar del contenedor antes del cual se va a insertar.
Comentarios
Cada una de las funciones miembro inserta, antes del elemento al que apunta where en la secuencia controlada, una secuencia especificada por los operandos restantes.
La primera función miembro inserta un elemento con valor val y devuelve un iterador que designa el elemento recién insertado. Se usa para insertar un único elemento antes de un lugar designado por un iterador.
La segunda función miembro inserta una repetición de count elementos de valor val. Se usa para insertar cero o más elementos contiguos que son todos copias del mismo valor.
Si InIt es un tipo entero, la tercera función miembro se comporta igual que insert(where, (size_type)first, (value_type)last). De lo contrario, inserta la secuencia [first, last). Se usa para insertar cero o más elementos contiguos copiados de otra secuencia.
La cuarta función miembro inserta la secuencia que designa el elemento de la derecha. Se usa para insertar una secuencia descrita por un enumerador.
Al insertar un único elemento, el número de copias de elementos es lineal en el número de elementos entre el punto de inserción y el extremo más cercano de la secuencia. (Al insertar uno o varios elementos al final de la secuencia, no se produce ninguna copia de elementos). Si InIt es un iterador de entrada, la tercera función miembro realiza eficazmente una única inserción para cada elemento de la secuencia. De lo contrario, al insertar N elementos, el número de copias de elementos es lineal en N más el número de elementos entre el punto de inserción y el extremo más cercano de la secuencia.
Ejemplo
// cliext_list_insert.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a single value using iterator
cliext::list<wchar_t>::iterator it = c1.begin();
System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
*c1.insert(++it, L'x'));
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a repetition of values
cliext::list<wchar_t> c2;
c2.insert(c2.begin(), 2, L'y');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert an iterator range
it = c1.end();
c2.insert(c2.end(), c1.begin(), --it);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert an enumeration
c2.insert(c2.begin(), // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// insert a single value using index
it = c2.begin();
++it, ++it, ++it;
c2.insert(it, L'z');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b
list::iterator (STL/CLR)
El tipo de un iterador para la secuencia controlada.
Sintaxis
typedef T1 iterator;
Comentarios
El tipo describe un objeto de tipo sin especificar T1 que puede actuar como un iterador de acceso aleatorio para la secuencia controlada.
Ejemplo
// cliext_list_iterator.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
cliext::list<wchar_t>::iterator it = c1.begin();
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
// alter first element and redisplay
it = c1.begin();
*it = L'x';
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
return (0);
}
a b c
x b c
list::list (STL/CLR)
Construye un objeto contenedor.
Sintaxis
list();
list(list<Value>% right);
list(list<Value>^ right);
explicit list(size_type count);
list(size_type count, value_type val);
template<typename InIt>
list(InIt first, InIt last);
list(System::Collections::Generic::IEnumerable<Value>^ right);
Parámetros
count
Número de elementos que se van a insertar.
first
Principio del intervalo que se va a insertar.
last
Fin del intervalo que se va a insertar.
right
Objeto o intervalo que se va a insertar.
val
Valor del elemento que se va a insertar.
Comentarios
El constructor:
list();
inicializa la secuencia controlada sin elementos. Se usa para especificar una secuencia controlada inicial vacía.
El constructor:
list(list<Value>% right);
inicializa la secuencia controlada por la secuencia [right.begin(), right.end()). Se usa para especificar una secuencia controlada inicial que es una copia de la secuencia controlada por el objeto de lista right.
El constructor:
list(list<Value>^ right);
inicializa la secuencia controlada por la secuencia [right->begin(), right->end()). Se usa para especificar una secuencia controlada inicial que es una copia de la secuencia controlada por el objeto de lista cuyo manipulador es right.
El constructor:
explicit list(size_type count);
inicializa la secuencia controlada con count elementos, cada uno con el valor value_type(). Se usa para rellenar el contenedor con elementos que tienen el mismo valor predeterminado.
El constructor:
list(size_type count, value_type val);
inicializa la secuencia controlada con count elementos, cada uno con el valor val. Se usa para rellenar el contenedor con elementos que tienen el mismo valor.
El constructor:
template<typename InIt>
list(InIt first, InIt last);
inicializa la secuencia controlada por la secuencia [first, last). Se usa para que la secuencia controlada sea una copia de otra secuencia.
El constructor:
list(System::Collections::Generic::IEnumerable<Value>^ right);
inicializa la secuencia controlada con la secuencia designada por el enumerador derecho. Se usa para convertir la secuencia controlada en una copia de otra secuencia descrita por un enumerador.
Ejemplo
// cliext_list_construct.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
// construct an empty container
cliext::list<wchar_t> c1;
System::Console::WriteLine("size() = {0}", c1.size());
// construct with a repetition of default values
cliext::list<wchar_t> c2(3);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", (int)elem);
System::Console::WriteLine();
// construct with a repetition of values
cliext::list<wchar_t> c3(6, L'x');
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an iterator range
cliext::list<wchar_t>::iterator it = c3.end();
cliext::list<wchar_t> c4(c3.begin(), --it);
for each (wchar_t elem in c4)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct with an enumeration
cliext::list<wchar_t> c5( // NOTE: cast is not needed
(System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
for each (wchar_t elem in c5)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying another container
cliext::list<wchar_t> c7(c3);
for each (wchar_t elem in c7)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying a container handle
cliext::list<wchar_t> c8(%c3);
for each (wchar_t elem in c8)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x
list::merge (STL/CLR)
Combina dos secuencias controladas ordenadas.
Sintaxis
void merge(list<Value>% right);
template<typename Pred2>
void merge(list<Value>% right, Pred2 pred);
Parámetros
pred
Comparador para pares de elementos.
right
Contenedor en el que se va a combinar.
Comentarios
La primera función miembro quita todos los elementos de la secuencia controlada por right y los inserta en la secuencia controlada. Ambas secuencias deben ordenarse previamente por operator<: los elementos no deben disminuir en el valor a medida que avanza a través de ninguna secuencia. La secuencia resultante también se ordena mediante operator<. Esta función miembro se usa para combinar dos secuencias que aumentan de valor en una secuencia que igualmente aumenta en el valor.
La segunda función miembro se comporta igual que la primera, salvo que las secuencias están ordenadas por pred -- pred(X, Y) deben ser false para cualquier elemento X que siga el elemento Y de la secuencia. Se usa para combinar dos secuencias ordenadas por una función de predicado o delegado que se especifique.
Ambas funciones realizan una combinación estable: ningún par de elementos se invierte en ninguna de las secuencias controladas originales en la secuencia controlada resultante. Además, si un par de elementos X y Y de la secuencia controlada resultante equivale a (!(X < Y) && !(X < Y)), un elemento de la secuencia controlada original aparece antes de un elemento de la secuencia controlada por right.
Ejemplo
// cliext_list_merge.cpp
// compile with: /clr
#include <cliext/list>
typedef cliext::list<wchar_t> Mylist;
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'c');
c1.push_back(L'e');
// display initial contents " a c e"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
cliext::list<wchar_t> c2;
c2.push_back(L'b');
c2.push_back(L'd');
c2.push_back(L'f');
// display initial contents " b d f"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// merge and display
cliext::list<wchar_t> c3(c1);
c3.merge(c2);
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("c2.size() = {0}", c2.size());
// sort descending, merge descending, and redisplay
c1.sort(cliext::greater<wchar_t>());
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
c3.sort(cliext::greater<wchar_t>());
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
c3.merge(c1, cliext::greater<wchar_t>());
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("c1.size() = {0}", c1.size());
return (0);
}
a c e
b d f
a b c d e f
c2.size() = 0
e c a
f e d c b a
f e e d c c b a a
c1.size() = 0
list::operator= (STL/CLR)
Reemplaza la secuencia controlada.
Sintaxis
list<Value>% operator=(list<Value>% right);
Parámetros
right
Contenedor que se va a copiar.
Comentarios
El operador miembro copia right en el objeto y, a continuación, devuelve *this. Se usa para reemplazar la secuencia controlada por una copia de la secuencia controlada del elemento right.
Ejemplo
// cliext_list_operator_as.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::list<wchar_t> c2;
c2 = c1;
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
list::pop_back (STL/CLR)
Quita el último elemento.
Sintaxis
void pop_back();
Comentarios
La función miembro elimina el último elemento de la secuencia controlada, que no debe estar vacío. Se usa para acortar la lista por un elemento en la parte posterior.
Ejemplo
// cliext_list_pop_back.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// pop an element and redisplay
c1.pop_back();
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b
list::pop_front (STL/CLR)
Quita el primer elemento.
Sintaxis
void pop_front();
Comentarios
La función miembro elimina el primer elemento de la secuencia controlada, que no debe estar vacío. Se usa para acortar la lista por un elemento en la parte frontal.
Ejemplo
// cliext_list_pop_front.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// pop an element and redisplay
c1.pop_front();
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
b c
list::push_back (STL/CLR)
Agrega un nuevo último elemento.
Sintaxis
void push_back(value_type val);
Comentarios
La función miembro inserta un elemento con valor val al final de la secuencia controlada. Se usa para anexar otro elemento a la lista.
Ejemplo
// cliext_list_push_back.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
list::push_front (STL/CLR)
Agrega un nuevo primer elemento.
Sintaxis
void push_front(value_type val);
Comentarios
La función miembro inserta un elemento con valor val al inicio de la secuencia controlada. Se usa para anteponer otro elemento a la lista.
Ejemplo
// cliext_list_push_front.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_front(L'a');
c1.push_front(L'b');
c1.push_front(L'c');
// display contents " c b a"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
c b a
list::rbegin (STL/CLR)
Designa el principio de la secuencia controlada inversa.
Sintaxis
reverse_iterator rbegin();
Comentarios
La función miembro devuelve un iterador inverso que designa el último elemento de la secuencia controlada o apunta inmediatamente después del principio de una secuencia vacía. Por lo tanto, designa el beginning de la secuencia inversa. Se usa para obtener un iterador que designe el current principio de la secuencia controlada vista en orden inverso, pero su estado puede cambiar si cambia la longitud de la secuencia controlada.
Ejemplo
// cliext_list_rbegin.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items in reversed sequence
cliext::list<wchar_t>::reverse_iterator rit = c1.rbegin();
System::Console::WriteLine("*rbegin() = {0}", *rit);
System::Console::WriteLine("*++rbegin() = {0}", *++rit);
// alter first two items and reinspect
*--rit = L'x';
*++rit = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*rbegin() = c
*++rbegin() = b
a y x
list::reference (STL/CLR)
El tipo de una referencia a un elemento.
Sintaxis
typedef value_type% reference;
Comentarios
El tipo describe una referencia a un elemento.
Ejemplo
// cliext_list_reference.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
cliext::list<wchar_t>::iterator it = c1.begin();
for (; it != c1.end(); ++it)
{ // get a reference to an element
cliext::list<wchar_t>::reference ref = *it;
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
// modify contents " a b c"
for (it = c1.begin(); it != c1.end(); ++it)
{ // get a reference to an element
cliext::list<wchar_t>::reference ref = *it;
ref += (wchar_t)(L'A' - L'a');
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
return (0);
}
a b c
A B C
list::remove (STL/CLR)
Quita un elemento con un valor especificado.
Sintaxis
void remove(value_type val);
Parámetros
val
Valor del elemento que se va a quitar.
Comentarios
La función miembro quita un elemento de la secuencia controlada por la cual ((System::Object^)val)->Equals((System::Object^)x) es true (si existe). Se usa para borrar un elemento arbitrario con el valor especificado.
Ejemplo
// cliext_list_remove.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// fail to remove and redisplay
c1.remove(L'A');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// remove and redisplay
c1.remove(L'b');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a c
list::remove_if (STL/CLR)
Quita los elementos que superan una prueba especificada.
Sintaxis
template<typename Pred1>
void remove_if(Pred1 pred);
Parámetros
pred
Prueba de los elementos que se van a quitar.
Comentarios
La función miembro quita de la secuencia controlada (borra) cada elemento X por el cual pred(X) es true. Se usa para quitar todos los elementos que cumplan una condición que especifique como función o delegado.
Ejemplo
// cliext_list_remove_if.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'b');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b b b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// fail to remove and redisplay
c1.remove_if(cliext::binder2nd<cliext::equal_to<wchar_t> >(
cliext::equal_to<wchar_t>(), L'd'));
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// remove and redisplay
c1.remove_if(cliext::binder2nd<cliext::not_equal_to<wchar_t> >(
cliext::not_equal_to<wchar_t>(), L'b'));
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b b b c
a b b b c
b b b
list::rend (STL/CLR)
Designa el final de la secuencia controlada inversa.
Sintaxis
reverse_iterator rend();
Comentarios
La función miembro devuelve un iterador inverso que apunta inmediatamente después del principio de la secuencia controlada. Por lo tanto, designa el end de la secuencia inversa. Se usa para obtener un iterador que designe el current final de la secuencia controlada vista en orden inverso, pero su estado puede cambiar si cambia la longitud de la secuencia controlada.
Ejemplo
// cliext_list_rend.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
cliext::list<wchar_t>::reverse_iterator rit = c1.rend();
--rit;
System::Console::WriteLine("*-- --rend() = {0}", *--rit);
System::Console::WriteLine("*--rend() = {0}", *++rit);
// alter first two items and reinspect
*--rit = L'x';
*++rit = L'y';
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
*-- --rend() = b
*--rend() = a
y x c
list::resize (STL/CLR)
Cambia el número de elementos.
Sintaxis
void resize(size_type new_size);
void resize(size_type new_size, value_type val);
Parámetros
new_size
Nuevo tamaño de la secuencia controlada.
val
Valor del elemento de relleno.
Comentarios
Las funciones miembro garantizan que list::size (STL/CLR)() devuelve en lo sucesivo new_size. Si la secuencia controlada tiene que ser más larga, la primera función miembro anexa elementos con el valor value_type(), mientras que la segunda función miembro anexa elementos con el valor val. Para que la secuencia controlada sea más corta, ambas funciones miembro borran eficazmente el elemento list::size (STL/CLR)() -new_size veces. Se usa para asegurarse de que la secuencia controlada tiene el tamaño new_size, ya sea recortando o rellenando la secuencia controlada actual.
Ejemplo
// cliext_list_resize.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
// construct an empty container and pad with default values
cliext::list<wchar_t> c1;
System::Console::WriteLine("size() = {0}", c1.size());
c1.resize(4);
for each (wchar_t elem in c1)
System::Console::Write("{0} ", (int)elem);
System::Console::WriteLine();
// resize to empty
c1.resize(0);
System::Console::WriteLine("size() = {0}", c1.size());
// resize and pad
c1.resize(5, L'x');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
size() = 0
0 0 0 0
size() = 0
x x x x x
list::reverse (STL/CLR)
Invierte la secuencia controlada.
Sintaxis
void reverse();
Comentarios
La función miembro invierte el orden de todos los elementos de la secuencia controlada. Se usa para reflejar una lista de elementos.
Ejemplo
// cliext_list_reverse.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// reverse and redisplay
c1.reverse();
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
c b a
list::reverse_iterator (STL/CLR)
El tipo de un iterador invertido para la secuencia controlada.
Sintaxis
typedef T3 reverse_iterator;
Comentarios
El tipo describe un objeto de tipo sin especificar T3 que puede actuar como un iterador inverso de la secuencia controlada.
Ejemplo
// cliext_list_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" reversed
cliext::list<wchar_t>::reverse_iterator rit = c1.rbegin();
for (; rit != c1.rend(); ++rit)
System::Console::Write("{0} ", *rit);
System::Console::WriteLine();
// alter first element and redisplay
rit = c1.rbegin();
*rit = L'x';
for (; rit != c1.rend(); ++rit)
System::Console::Write("{0} ", *rit);
System::Console::WriteLine();
return (0);
}
c b a
x b a
list::size (STL/CLR)
Cuenta el número de elementos.
Sintaxis
size_type size();
Comentarios
La función miembro devuelve la longitud de la secuencia controlada. Se usa para determinar el número de elementos que están actualmente en la secuencia controlada. Si todo lo que le interesa es si la secuencia tiene un tamaño distinto de cero, consulte list::empty (STL/CLR)().
Ejemplo
// cliext_list_size.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0} starting with 3", c1.size());
// clear the container and reinspect
c1.clear();
System::Console::WriteLine("size() = {0} after clearing", c1.size());
// add elements and clear again
c1.push_back(L'a');
c1.push_back(L'b');
System::Console::WriteLine("size() = {0} after adding 2", c1.size());
return (0);
}
a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2
list::size_type (STL/CLR)
El tipo de una distancia con signo entre dos elementos.
Sintaxis
typedef int size_type;
Comentarios
El tipo describe un recuento de elementos no negativo.
Ejemplo
// cliext_list_size_type.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
cliext::list<wchar_t>::size_type diff = 0;
for (cliext::list<wchar_t>::iterator it = c1.begin();
it != c1.end(); ++it)
++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
list::sort (STL/CLR)
Ordena la secuencia controlada.
Sintaxis
void sort();
template<typename Pred2>
void sort(Pred2 pred);
Parámetros
pred
Comparador para pares de elementos.
Comentarios
La primera función miembro reorganiza los elementos de la secuencia controlada para que se ordenen por operator<: los elementos no disminuyen su valor a medida que se avanza la secuencia. Esta función miembro se usa para ordenar la secuencia en orden creciente.
La segunda función miembro se comporta igual que la primera, salvo que la secuencia se ordenada por pred -- pred(X, Y) es false para cualquier elemento X que siga el elemento Y de la secuencia resultante. Se usa para ordenar la secuencia en un orden especificado por una función de predicado o delegado.
Ambas funciones realizan un orden estable: ningún par de elementos se invierte en la secuencia controlada original en la secuencia controlada resultante.
Ejemplo
// cliext_list_sort.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// sort descending and redisplay
c1.sort(cliext::greater<wchar_t>());
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// sort ascending and redisplay
c1.sort();
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
c b a
a b c
list::splice (STL/CLR)
Unir nuevamente los vínculos entre nodos.
Sintaxis
void splice(iterator where, list<Value>% right);
void splice(iterator where, list<Value>% right,
iterator first);
void splice(iterator where, list<Value>% right,
iterator first, iterator last);
Parámetros
first
Principio del rango que se va a empalmar.
last
Fin del rango que se va a empalmar.
right
Contenedor desde el que se va a empalmar.
where
Lugar del contenedor donde se va a empalmar antes.
Comentarios
La primera función miembro inserta la secuencia controlada por right antes del elemento de la secuencia controlada señalada por where. También quita todos los elementos de right. (%right no debe ser igual athis). Se usa para unir una lista a otra.
La segunda función miembro quita el elemento señalado por first en la secuencia controlada por right y lo inserta antes del elemento de la secuencia controlada señalada por where. (Si where==first||where== ++first, no sucede ningún cambio). Se usa para insertar un único elemento de una lista en otra.
La tercera función miembro inserta el subrango designado por [first, last) de la secuencia controlada por right antes del elemento de la secuencia controlada señalada por where. También quita el subrango original de la secuencia controlada por right. (Si es right == this, el intervalo [first, last) no debe incluir el elemento señalado por where.) Se usa para empalmar una subsecuencia de cero o más elementos de una lista a otra.
Ejemplo
// cliext_list_splice.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// splice to a new list
cliext::list<wchar_t> c2;
c2.splice(c2.begin(), c1);
System::Console::WriteLine("c1.size() = {0}", c1.size());
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// return one element
c1.splice(c1.end(), c2, c2.begin());
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// return remaining elements
c1.splice(c1.begin(), c2, c2.begin(), c2.end());
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("c2.size() = {0}", c2.size());
return (0);
}
a b c
c1.size() = 0
a b c
a
b c
b c a
c2.size() = 0
list::swap (STL/CLR)
Intercambia el contenido de dos contenedores.
Sintaxis
void swap(list<Value>% right);
Parámetros
right
Contenedor con el que se va a intercambiar el contenido.
Comentarios
La función miembro intercambia las secuencias controladas entre *this y right. Lo hace en tiempo constante y no inicia ninguna excepción. Se usa como una manera rápida de intercambiar el contenido de dos contenedores.
Ejemplo
// cliext_list_swap.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct another container with repetition of values
cliext::list<wchar_t> c2(5, L'x');
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// swap and redisplay
c1.swap(c2);
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
x x x x x
x x x x x
a b c
list::to_array (STL/CLR)
Copia la secuencia controlada en una nueva matriz.
Sintaxis
cli::array<Value>^ to_array();
Comentarios
La función miembro devuelve una matriz que contiene la secuencia controlada. Se usa para obtener una copia de la secuencia controlada en forma de matriz.
Ejemplo
// cliext_list_to_array.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// copy the container and modify it
cli::array<wchar_t>^ a1 = c1.to_array();
c1.push_back(L'd');
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// display the earlier array copy
for each (wchar_t elem in a1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c d
a b c
list::unique (STL/CLR)
Quita los elementos adyacentes que superan una prueba especificada.
Sintaxis
void unique();
template<typename Pred2>
void unique(Pred2 pred);
Parámetros
pred
Comparador para pares de elementos.
Comentarios
La primera función miembro quita de la secuencia controlada (borra) todo elemento que se compare con su elemento precedente; si el elemento X precede al elemento Y y X == Y, la función miembro quita Y. Se usa para quitar todas las copias menos una de cada subsecuencia de los elementos adyacentes que se comparan iguale. Tenga en cuenta que si la secuencia controlada está ordenada, por ejemplo, al llamar a list::sort (STL/CLR)(), la función miembro deja solo elementos con valores únicos. (Por lo tanto, el nombre).
La segunda función miembro se comporta igual que la primera, salvo que quita cada elemento Y que sigue a un elemento X para cada pred(X, Y). Se usa para quitar todas las copias menos una de cada subsecuencia de elementos adyacentes que satisfacen una función de predicado o delegado que se especifique. Tenga en cuenta que si la secuencia controlada está ordenada, por ejemplo, al llamar a sort(pred), la función miembro deja solo los elementos que no tienen una ordenación equivalente con ningún otro elemento.
Ejemplo
// cliext_list_unique.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display initial contents " a a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// display contents after unique
cliext::list<wchar_t> c2(c1);
c2.unique();
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// display contents after unique(not_equal_to)
c2 = c1;
c2.unique(cliext::not_equal_to<wchar_t>());
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a a b c
a b c
a a
list::value_type (STL/CLR)
El tipo de un elemento.
Sintaxis
typedef Value value_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Value.
Ejemplo
// cliext_list_value_type.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c" using value_type
for (cliext::list<wchar_t>::iterator it = c1.begin();
it != c1.end(); ++it)
{ // store element in value_type object
cliext::list<wchar_t>::value_type val = *it;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c
operator!= (list) (STL/CLR)
La lista no es igual a la comparación.
Sintaxis
template<typename Value>
bool operator!=(list<Value>% left,
list<Value>% right);
Parámetros
left
Contenedor izquierdo que se va a comparar.
right
Contenedor derecho que se va a comparar.
Comentarios
La función de operador devuelve !(left == right). Se usa para comprobar si left no está ordenada igual que right cuando se comparan las dos listas elemento por elemento.
Ejemplo
// cliext_list_operator_ne.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::list<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] != [a b c] is {0}",
c1 != c1);
System::Console::WriteLine("[a b c] != [a b d] is {0}",
c1 != c2);
return (0);
}
a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True
operator< (list) (STL/CLR)
La lista es menor que la comparación.
Sintaxis
template<typename Value>
bool operator<(list<Value>% left,
list<Value>% right);
Parámetros
left
Contenedor izquierdo que se va a comparar.
right
Contenedor derecho que se va a comparar.
Comentarios
La función del operador devuelve true si, en la posición más baja i para la que !(right[i] < left[i]), también es true que left[i] < right[i]. De lo contrario, devuelve left->size() < right->size() se usa para comprobar si left está ordenada antes que right cuando se comparan las dos listas elemento por elemento.
Ejemplo
// cliext_list_operator_lt.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::list<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] < [a b c] is {0}",
c1 < c1);
System::Console::WriteLine("[a b c] < [a b d] is {0}",
c1 < c2);
return (0);
}
a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True
operator<= (list) (STL/CLR)
Lista menor o igual a la comparación.
Sintaxis
template<typename Value>
bool operator<=(list<Value>% left,
list<Value>% right);
Parámetros
left
Contenedor izquierdo que se va a comparar.
right
Contenedor derecho que se va a comparar.
Comentarios
La función de operador devuelve !(right < left). Se usa para comprobar si left no está ordenada después de right cuando se comparan las dos listas elemento por elemento.
Ejemplo
// cliext_list_operator_le.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::list<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] <= [a b c] is {0}",
c1 <= c1);
System::Console::WriteLine("[a b d] <= [a b c] is {0}",
c2 <= c1);
return (0);
}
a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False
operator== (list) (STL/CLR)
La lista es igual a la comparación.
Sintaxis
template<typename Value>
bool operator==(list<Value>% left,
list<Value>% right);
Parámetros
left
Contenedor izquierdo que se va a comparar.
right
Contenedor derecho que se va a comparar.
Comentarios
La función de operador devuelve true solo si las secuencias controladas por left y right tienen la misma longitud y para cada posición i, left[i] ==right[i]. Se usa para comprobar si left está ordenada igual que right cuando se comparan las dos listas elemento por elemento.
Ejemplo
// cliext_list_operator_eq.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::list<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] == [a b c] is {0}",
c1 == c1);
System::Console::WriteLine("[a b c] == [a b d] is {0}",
c1 == c2);
return (0);
}
a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False
operator> (list) (STL/CLR)
La lista es mayor que la comparación.
Sintaxis
template<typename Value>
bool operator>(list<Value>% left,
list<Value>% right);
Parámetros
left
Contenedor izquierdo que se va a comparar.
right
Contenedor derecho que se va a comparar.
Comentarios
La función de operador devuelve right<left. Se usa para comprobar si left está ordenada después de right cuando se comparan las dos listas elemento por elemento.
Ejemplo
// cliext_list_operator_gt.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::list<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] > [a b c] is {0}",
c1 > c1);
System::Console::WriteLine("[a b d] > [a b c] is {0}",
c2 > c1);
return (0);
}
a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True
operator>= (list) (STL/CLR)
La lista es mayor o igual que la comparación.
Sintaxis
template<typename Value>
bool operator>=(list<Value>% left,
list<Value>% right);
Parámetros
left
Contenedor izquierdo que se va a comparar.
right
Contenedor derecho que se va a comparar.
Comentarios
La función de operador devuelve !(left<right). Se usa para comprobar si left no está ordenada antes de right cuando se comparan las dos listas elemento por elemento.
Ejemplo
// cliext_list_operator_ge.cpp
// compile with: /clr
#include <cliext/list>
int main()
{
cliext::list<wchar_t> c1;
c1.push_back(L'a');
c1.push_back(L'b');
c1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
cliext::list<wchar_t> c2;
c2.push_back(L'a');
c2.push_back(L'b');
c2.push_back(L'd');
// display contents " a b d"
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("[a b c] >= [a b c] is {0}",
c1 >= c1);
System::Console::WriteLine("[a b c] >= [a b d] is {0}",
c1 >= c2);
return (0);
}
a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de