En esta página

QMutableMultiMapIterator Class

template <typename Key, typename T> class QMutableMultiMapIterator

La clase `QMutableMultiMapIterator` proporciona un iterador no constante, al estilo de Java, para ` QMultiMap`. Más información...

Encabezado: #include <QMutableMultiMapIterator>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Funciones públicas

QMutableMultiMapIterator(QMultiMap<Key, T> &map)
bool findNext(const T &value)
bool findPrevious(const T &value)
bool hasNext() const
bool hasPrevious() const
const Key &key() const
QMutableMultiMapIterator<Key, T>::Item next()
QMutableMultiMapIterator<Key, T>::Item peekNext() const
QMutableMultiMapIterator<Key, T>::Item peekPrevious() const
QMutableMultiMapIterator<Key, T>::Item previous()
void remove()
void setValue(const T &value)
void toBack()
void toFront()
const T &value() const
T &value()
QMutableMultiMapIterator<Key, T> &operator=(QMultiMap<Key, T> &map)

Descripción detallada

QMultiMap dispone tanto de iteradores al estilo Java como de iteradores al estilo STL. Los iteradores al estilo STL son más eficientes y son los recomendables. El parámetro de plantilla Key especifica el tipo de clave del mapa, y T especifica el tipo de valor.

QMutableMultiMapIterator<Key, T> permite recorrer un QMultiMap y modificar el mapa. Si no deseas modificar el mapa (o tienes un QMultiMap de tipo const), utiliza en su lugar el QMultiMapIterator, que es ligeramente más rápido.

El constructor de QMutableMultiMapIterator toma un ` QMultiMap ` como argumento. Tras la construcción, el iterador se sitúa al principio del mapa (antes del primer elemento). A continuación se explica cómo recorrer todos los elementos de forma secuencial:

QMultiMap<int, QWidget*> multimap;
//...
QMutableMultiMapIterator<int, QWidget*> i(multimap);
while (i.hasNext()) {
    i.next();
    qDebug() << i.key() << ": " << i.value();
}

La función ` next()` devuelve el siguiente elemento del mapa y avanza el iterador. Las funciones ` key()` y ` value()` devuelven la clave y el valor del último elemento que se ha saltado.

A diferencia de los iteradores de estilo STL, los iteradores de estilo Java apuntan entre elementos en lugar de directamente a ellos. La primera llamada a next() hace avanzar el iterador hasta la posición entre el primer y el segundo elemento, y devuelve el primer elemento; la segunda llamada a next() hace avanzar el iterador hasta la posición entre el segundo y el tercer elemento; y así sucesivamente.

Posiciones del iterador entre los elementos A, B, C y D

A continuación se explica cómo recorrer los elementos en orden inverso:

QMutableMultiMapIterator<int, QWidget*> i(multimap);
i.toBack();
while (i.hasPrevious()) {
    i.previous();
    qDebug() << i.key() << ": " << i.value();
}

Si quieres encontrar todas las apariciones de un valor concreto, utiliza findNext() o findPrevious() en un bucle. Por ejemplo:

QMutableMultiMapIterator<int, QWidget*> i(multimap);
while (i.findNext(widget)) {
    qDebug() << "Found widget " << widget << " under key "
           << i.key();
}

Si quieres eliminar elementos mientras recorres el mapa, utiliza remove(). Si quieres modificar el valor de un elemento, utiliza setValue().

Ejemplo:

QMutableMultiMapIterator<QString, QString> i(multimap);
while (i.hasNext()) {
    i.next();
    if (i.key() == i.value())
        i.remove();
}

El ejemplo elimina todos los pares (clave, valor) en los que la clave y el valor son iguales.

Solo puede haber un iterador mutable activo en un mapa determinado en un momento dado. Además, no se deben realizar cambios directamente en el mapa mientras el iterador esté activo (a diferencia de lo que ocurre al hacerlo a través del iterador), ya que esto podría invalidar el iterador y dar lugar a un comportamiento indefinido.

Véase también QMultiMapIterator y QMultiMap::iterator.

Documentación de las funciones miembro

QMutableMultiMapIterator::QMutableMultiMapIterator(QMultiMap<Key, T> &map)

Crea un iterador para recorrer map. El iterador se sitúa al principio del mapa (antes del primer elemento).

Véase también operator=().

bool QMutableMultiMapIterator::findNext(const T &value)

Busca « value » a partir de la posición actual del iterador y hacia adelante. Devuelve « true » si se encuentra un par (clave, valor) cuyo valor sea « value »; en caso contrario, devuelve « false ».

Tras la llamada, si se ha encontrado value, el iterador se sitúa justo después del elemento coincidente; en caso contrario, el iterador se sitúa al final del contenedor.

Véase también findPrevious().

bool QMutableMultiMapIterator::findPrevious(const T &value)

Busca « value » desde la posición actual del iterador hacia atrás. Devuelve « true » si se encuentra un par (clave, valor) cuyo valor sea « value »; en caso contrario, devuelve « false ».

Tras la llamada, si se ha encontrado value, el iterador se sitúa justo antes del elemento coincidente; de lo contrario, el iterador se sitúa al principio del contenedor.

Véase también findNext().

bool QMutableMultiMapIterator::hasNext() const

Devuelve ` true ` si hay al menos un elemento por delante del iterador, es decir, si el iterador no se encuentra al final del contenedor; en caso contrario, devuelve ` false`.

Véanse también hasPrevious() y next().

bool QMutableMultiMapIterator::hasPrevious() const

Devuelve ` true ` si hay al menos un elemento detrás del iterador, es decir, si el iterador no se encuentra al principio del contenedor; en caso contrario, devuelve ` false`.

Véanse también hasNext() y previous().

const Key &QMutableMultiMapIterator::key() const

Devuelve la clave del último elemento que se ha saltado utilizando una de las funciones de recorrido (next(), previous(), findNext(), findPrevious()).

Tras una llamada a next() o findNext(), key() es equivalente a peekPrevious().key(). Tras una llamada a previous() o findPrevious(), key() es equivalente a peekNext().key().

Véase también value().

QMutableMultiMapIterator<Key, T>::Item QMutableMultiMapIterator::next()

Devuelve el siguiente elemento y hace avanzar el iterador una posición.

Llama a ` key()` sobre el valor devuelto para obtener la clave del elemento, y a ` value()` para obtener el valor.

La llamada a esta función sobre un iterador situado al final del contenedor da lugar a resultados indefinidos.

Véanse también hasNext(), peekNext() y previous().

QMutableMultiMapIterator<Key, T>::Item QMutableMultiMapIterator::peekNext() const

Devuelve una referencia al siguiente elemento sin desplazar el iterador.

Llama a ` key()` sobre el valor devuelto para obtener la clave del elemento, y a ` value()` para obtener el valor.

La llamada a esta función sobre un iterador situado al final del contenedor da lugar a resultados indefinidos.

Véanse también hasNext(), next() y peekPrevious().

QMutableMultiMapIterator<Key, T>::Item QMutableMultiMapIterator::peekPrevious() const

Devuelve el elemento anterior sin desplazar el iterador.

Llama a ` key()` sobre el valor devuelto para obtener la clave del elemento, y a ` value()` para obtener el valor.

La llamada a esta función sobre un iterador situado al principio del contenedor da lugar a resultados indefinidos.

Véanse también hasPrevious(), previous() y peekNext().

QMutableMultiMapIterator<Key, T>::Item QMutableMultiMapIterator::previous()

Devuelve el elemento anterior y desplaza el iterador una posición hacia atrás.

Llama a ` key()` sobre el valor devuelto para obtener la clave del elemento, y a ` value()` para obtener el valor.

La llamada a esta función sobre un iterador situado al principio del contenedor da lugar a resultados indefinidos.

Véanse también hasPrevious(), peekPrevious() y next().

void QMutableMultiMapIterator::remove()

Elimina el último elemento que se ha saltado utilizando una de las funciones de recorrido (next(), previous(), findNext(), findPrevious()).

Véase también setValue().

void QMutableMultiMapIterator::setValue(const T &value)

Sustituye el valor del último elemento que se ha saltado al utilizar una de las funciones de recorrido por « value ».

Las funciones de recorrido son next(), previous(), findNext() y findPrevious().

Véanse también key(), value() y remove().

void QMutableMultiMapIterator::toBack()

Desplaza el iterador hasta el final del contenedor (después del último elemento).

Véase también toFront() y previous().

void QMutableMultiMapIterator::toFront()

Desplaza el iterador al principio del contenedor (antes del primer elemento).

Véase también toBack() y next().

const T &QMutableMultiMapIterator::value() const

Devuelve el valor del último elemento que se ha omitido utilizando una de las funciones de recorrido (next(), previous(), findNext(), findPrevious()).

Tras una llamada a next() o findNext(), value() es equivalente a peekPrevious().value(). Tras una llamada a previous() o findPrevious(), value() es equivalente a peekNext().value().

Véase también key() y setValue().

T &QMutableMultiMapIterator::value()

Devuelve una referencia no constante al valor del último elemento que se ha omitido al utilizar una de las funciones de recorrido.

QMutableMultiMapIterator<Key, T> &QMutableMultiMapIterator::operator=(QMultiMap<Key, T> &map)

Hace que el iterador opere sobre map. El iterador se sitúa al principio del mapa (antes del primer elemento).

Véase también toFront() y toBack().

© 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.