QLinkedList::iterator Class

class QLinkedList::iterator

La clase QLinkedList::iterator proporciona un iterador no-const de estilo STL para QLinkedList. Más...

Lista de todos los miembros, incluyendo los heredados

Funciones públicas

	iterator()
bool	operator!=(const QLinkedList<T>::const_iterator &other) const
bool	operator!=(const QLinkedList<T>::iterator &other) const
T &	operator*() const
QLinkedList<T>::iterator	operator+(int j) const
QLinkedList<T>::iterator &	operator++()
QLinkedList<T>::iterator	operator++(int)
QLinkedList<T>::iterator &	operator+=(int j)
QLinkedList<T>::iterator	operator-(int j) const
QLinkedList<T>::iterator &	operator--()
QLinkedList<T>::iterator	operator--(int)
QLinkedList<T>::iterator &	operator-=(int j)
T *	operator->() const
bool	operator==(const QLinkedList<T>::const_iterator &other) const
bool	operator==(const QLinkedList<T>::iterator &other) const

Descripción detallada

QLinkedList incluye iteradores de estilo STL e iteradores de estilo Java. Los iteradores estilo STL son de más bajo nivel y más engorrosos de usar; por otro lado, son ligeramente más rápidos y, para los desarrolladores que ya conocen STL, tienen la ventaja de la familiaridad.

QLinkedList<T>::iterator permite iterar sobre un QLinkedList<T> y modificar el elemento de lista asociado al iterador. Si desea iterar sobre una const QLinkedList, utilice QLinkedList::const_iterator en su lugar. Generalmente es una buena práctica usar QLinkedList::const_iterator sobre un QLinkedList no-const también, a menos que necesites cambiar el QLinkedList a través del iterador. Los iteradores const son ligeramente más rápidos y pueden mejorar la legibilidad del código.

El constructor por defecto QLinkedList::iterator crea un iterador no inicializado. Debes inicializarlo usando una función como QLinkedList::begin(), QLinkedList::end(), o QLinkedList::insert() antes de que puedas empezar a iterar. Este es un bucle típico que imprime todos los elementos almacenados en una lista:

QLinkedList<QString> list;
list.append("January");
list.append("February");
...
list.append("December");

QLinkedList<QString>::iterator i;
for (i = list.begin(); i != list.end(); ++i)
    cout << *i << Qt::endl;

Los iteradores de estilo STL pueden utilizarse como argumentos de generic algorithms. Por ejemplo, así es como se encuentra un elemento en la lista:

QLinkedList<QString> list;
...
QLinkedList<QString>::iterator it = std::find(list.begin(),
                                              list.end(), "Joel");
if (it != list.end())
    cout << "Found Joel" << Qt::endl;

Veamos algunos ejemplos de cosas que podemos hacer con un QLinkedList::iterator que no podemos hacer con un QLinkedList::const_iterator. He aquí un ejemplo que incrementa en 2 cada valor almacenado en un QLinkedList<int>:

QLinkedList<int>::iterator i;
for (i = list.begin(); i != list.end(); ++i)
    *i += 2;

He aquí un ejemplo que elimina todos los elementos que comienzan con un carácter de subrayado en un QLinkedList<QString>:

QLinkedList<QString> list;
...
QLinkedList<QString>::iterator i = list.begin();
while (i != list.end()) {
    if ((*i).startsWith('_'))
        i = list.erase(i);
    else
        ++i;
}

La llamada a QLinkedList::erase() elimina de la lista el elemento apuntado por el iterador y devuelve un iterador al siguiente elemento. He aquí otra forma de eliminar un elemento mientras se itera:

QLinkedList<QString>::iterator i = list.begin();
while (i != list.end()) {
    QLinkedList<QString>::iterator previous = i;
    ++i;
    if ((*previous).startsWith('_'))
        list.erase(previous);
}

Puede ser tentador escribir código como este:

// WRONG
while (i != list.end()) {
    if ((*i).startsWith('_'))
        list.erase(i);
    ++i;
}

Sin embargo, esto potencialmente fallará en ++i, porque i es un iterador colgando después de la llamada a erase().

Se pueden usar múltiples iteradores en la misma lista. Si añades elementos a la lista, los iteradores existentes seguirán siendo válidos. Si eliminas elementos de la lista, los iteradores que apunten a los elementos eliminados se convertirán en iteradores colgantes.

Advertencia: Los iteradores en contenedores implícitamente compartidos no funcionan exactamente como los iteradores STL. Debes evitar copiar un contenedor mientras los iteradores estén activos en ese contenedor. Para más información, lee Problema de los iteradores compartidos implícitamente.

Véase también QLinkedList::const_iterator y QMutableLinkedListIterator.

Documentación de funciones miembro

iterator::iterator()

Construye un iterador no inicializado.

Funciones como operator*() y operator++() no deben ser llamadas en un iterador no inicializado. Utilice operator=() para asignarle un valor antes de utilizarlo.

Véase también QLinkedList::begin() y QLinkedList::end().

bool iterator::operator!=(const QLinkedList<T>::iterator &other) const

bool iterator::operator!=(const QLinkedList<T>::const_iterator &other) const

Devuelve true si other apunta a un elemento distinto de este iterador; en caso contrario devuelve false.

Véase también operator==().

T &iterator::operator*() const

Devuelve una referencia modificable al elemento actual.

Puede cambiar el valor de un elemento utilizando operator*() en el lado izquierdo de una asignación, por ejemplo:

if (*it == "Hello")
    *it = "Bonjour";

Véase también operator->().

QLinkedList<T>::iterator iterator::operator+(int j) const

Devuelve un iterador al elemento en j posiciones hacia adelante desde este iterador. (Si j es negativo, el iterador va hacia atrás).

Esta operación puede ser lenta para valores grandes de j.

Véase también operator-().

QLinkedList<T>::iterator &iterator::operator++()

El operador prefijo ++ (++it) avanza el iterador al siguiente elemento de la lista y devuelve un iterador al nuevo elemento actual.

Llamar a esta función en QLinkedList::end() conduce a resultados indefinidos.

Véase también operator--().

QLinkedList<T>::iterator iterator::operator++(int)

El operador postfijo ++ (it++) avanza el iterador al siguiente elemento de la lista y devuelve un iterador al elemento previamente actual.

Se trata de una función sobrecargada.

QLinkedList<T>::iterator &iterator::operator+=(int j)

Avanza el iterador en j elementos. (Si j es negativo, el iterador retrocede).

Véase también operator-=() y operator+().

QLinkedList<T>::iterator iterator::operator-(int j) const

Devuelve un iterador al elemento en j posiciones hacia atrás desde este iterador. (Si j es negativo, el iterador va hacia adelante).

Esta operación puede ser lenta para valores grandes de j.

Véase también operator+().

QLinkedList<T>::iterator &iterator::operator--()

El operador prefijo - (--it) hace actual el elemento precedente y devuelve un iterador al nuevo elemento actual.

Llamar a esta función en QLinkedList::begin() conduce a resultados indefinidos.

Véase también operator++().

QLinkedList<T>::iterator iterator::operator--(int)

El operador postfijo - (it--) hace actual el elemento precedente y devuelve un iterador al elemento previamente actual.

Se trata de una función sobrecargada.

QLinkedList<T>::iterator &iterator::operator-=(int j)

Hace que el iterador retroceda en j elementos. (Si j es negativo, el iterador va hacia adelante).

Véase también operator+=() y operator-().

T *iterator::operator->() const

Devuelve un puntero al elemento actual.

Véase también operator*().

bool iterator::operator==(const QLinkedList<T>::iterator &other) const

bool iterator::operator==(const QLinkedList<T>::const_iterator &other) const

Devuelve true si other apunta al mismo elemento que este iterador; en caso contrario devuelve false.

Véase también operator!=().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.