En esta página

<QtAlgorithms> - Generic Algorithms

El archivo de cabecera <QtAlgorithms> incluye los algoritmos genéricos basados en plantillas. Más información...

Header: #include <QtAlgorithms>

Funciones

uint qCountLeadingZeroBits(quint16 v)
uint qCountLeadingZeroBits(quint32 v)
uint qCountLeadingZeroBits(quint64 v)
uint qCountLeadingZeroBits(quint8 v)
uint qCountTrailingZeroBits(quint8 v)
uint qCountTrailingZeroBits(quint16 v)
uint qCountTrailingZeroBits(quint32 v)
uint qCountTrailingZeroBits(quint64 v)
void qDeleteAll(ForwardIterator begin, ForwardIterator end)
void qDeleteAll(const Container &c)
(since 6.10) Result qJoin(InputIterator first, InputIterator last, Result init, const Separator &separator = {}, Projection p = {})
uint qPopulationCount(quint8 v)
uint qPopulationCount(quint16 v)
uint qPopulationCount(quint32 v)
uint qPopulationCount(quint64 v)

Descripción detallada

Qt proporciona una serie de funciones de plantilla globales en <QtAlgorithms> que operan sobre contenedores y realizan pequeñas tareas para facilitar el trabajo, como qDeleteAll(), que invoca operator delete sobre todos los elementos de un contenedor determinado o de un rango determinado. Puedes utilizar estos algoritmos con cualquier clase de contenedor que proporcione iteradores al estilo STL, incluidas las clases de Qt QList, QMap y QHash.

La mayoría de los algoritmos admiten iteradores de estilo STL como parámetros. Los algoritmos son genéricos en el sentido de que no están vinculados a una clase de iterador específica; se pueden utilizar con cualquier iterador que cumpla un determinado conjunto de requisitos.

Los distintos algoritmos pueden tener requisitos diferentes respecto a los iteradores que aceptan. Los tipos de iterador requeridos se especifican para cada algoritmo. Si se pasa un iterador de tipo incorrecto (por ejemplo, si se pasa ` QList::ConstIterator ` como ` output iterator`), siempre se obtendrá un error de compilación, aunque no necesariamente uno muy informativo.

Algunos algoritmos tienen requisitos especiales respecto al tipo de valor almacenado en los contenedores. Por ejemplo, ` qDeleteAll()` requiere que el tipo de valor sea un tipo de puntero no constante (por ejemplo, ` QWidget *`). Los requisitos del tipo de valor se especifican para cada algoritmo, y el compilador generará un error si no se cumple alguno de ellos.

Los algoritmos genéricos pueden utilizarse con otras clases de contenedores además de las proporcionadas por Qt y STL. La sintaxis de los iteradores al estilo STL se basa en los punteros de C++, por lo que es posible utilizar matrices simples como contenedores y punteros simples como iteradores.

Tipos de iteradores

Los algoritmos tienen ciertos requisitos respecto a los tipos de iteradores que aceptan, y estos se especifican individualmente para cada función. El compilador generará un error si no se cumple algún requisito.

Iteradores de entrada

Un iterador de entrada es aquel que se puede utilizar para leer datos de forma secuencial desde un contenedor. Debe proporcionar los siguientes operadores: « == » y « != » para comparar dos iteradores, el operador unario « * » para recuperar el valor almacenado en el elemento, y el operador prefijo « ++ » para avanzar al siguiente elemento.

Los tipos de iteradores de los contenedores de Qt (const y no const) son todos iteradores de entrada.

Iteradores de salida

Un iterador de salida es un iterador que puede utilizarse para escribir datos de forma secuencial en un contenedor o en algún flujo de salida. Debe proporcionar los siguientes operadores: el unario * para escribir un valor (es decir, *it = val) y el prefijo ++ para avanzar al elemento siguiente.

Todos los tipos de iteradores no const de los contenedores de Qt son iteradores de salida.

Iteradores de avance

Un iterador hacia adelante es un iterador que cumple los requisitos tanto de los iteradores de entrada como de los de salida.

Los tipos de iteradores no const de los contenedores de Qt son todos iteradores hacia adelante.

Iteradores bidireccionales

Un iterador bidireccional es un iterador que cumple los requisitos de los iteradores hacia adelante, pero que, además, admite el prefijo -- para iterar hacia atrás.

Todos los tipos de iteradores no const de los contenedores de Qt son iteradores bidireccionales.

Iteradores de acceso aleatorio

La última categoría, los iteradores de acceso aleatorio, es el tipo de iterador más potente. Cumple todos los requisitos de un iterador bidireccional y admite las siguientes operaciones:

i += navanza el iterador i en n posiciones
i -= ndesplaza el iterador i hacia atrás n posiciones
i + n o n + idevuelve el iterador del elemento situado n posiciones por delante del iterador i
i - ndevuelve el iterador del elemento situado n posiciones más atrás del iterador i
i - jdevuelve el número de elementos entre los iteradores « i » y j
i[n]igual que *(i + n)
i < jdevuelve true si el iterador j viene después del iterador i

QListel tipo de iterador no constante de «``» es un iterador de acceso aleatorio.

Véase también «clases de contenedores » y « <QtGlobal> ».

Documentación de la función

[constexpr noexcept] uint qCountLeadingZeroBits(quint16 v)

Devuelve el número de bits cero consecutivos en ` v`, contando a partir del bit más significativo (MSB). Por ejemplo, `qCountLeadingZeroBits(quint16(1))` devuelve 15 y `qCountLeadingZeroBits(quint16(8))` devuelve 12.

[constexpr noexcept] uint qCountLeadingZeroBits(quint32 v)

Devuelve el número de bits cero consecutivos en ` v`, buscando a partir del bit más significativo (MSB). Por ejemplo, `qCountLeadingZeroBits(quint32(1))` devuelve 31 y `qCountLeadingZeroBits(quint32(8))` devuelve 28.

[constexpr noexcept] uint qCountLeadingZeroBits(quint64 v)

Devuelve el número de bits cero consecutivos en ` v`, al realizar la búsqueda a partir del bit más significativo (MSB). Por ejemplo, `qCountLeadingZeroBits(quint64(1))` devuelve 63 y `qCountLeadingZeroBits(quint64(8))` devuelve 60.

[constexpr noexcept] uint qCountLeadingZeroBits(quint8 v)

Devuelve el número de bits cero consecutivos en ` v`, al realizar la búsqueda a partir del bit más significativo (MSB). Por ejemplo, `qCountLeadingZeroBits(quint8(1))` devuelve 7 y `qCountLeadingZeroBits(quint8(8))` devuelve 4.

[constexpr noexcept] uint qCountTrailingZeroBits(quint8 v)

Devuelve el número de bits cero consecutivos en ` v`, empezando por el bit menos significativo (LSB). Por ejemplo, `qCountTrailingZeroBits(1)` devuelve 0 y `qCountTrailingZeroBits(8)` devuelve 3.

[constexpr noexcept] uint qCountTrailingZeroBits(quint16 v)

Esta es una función sobrecargada.

[constexpr noexcept] uint qCountTrailingZeroBits(quint32 v)

Esta es una función sobrecargada.

[constexpr noexcept] uint qCountTrailingZeroBits(quint64 v)

Esta es una función sobrecargada.

template <typename ForwardIterator> void qDeleteAll(ForwardIterator begin, ForwardIterator end)

Elimina todos los elementos del intervalo [begin, end) utilizando el operador « delete » de C++. El tipo de elemento debe ser un tipo de puntero (por ejemplo, QWidget *).

Ejemplo:

QList<QColor *> list;
list.append(new QColor(Qt::blue));
list.append(new QColor(Qt::yellow));

qDeleteAll(list.begin(), list.end());
list.clear();

Ten en cuenta que qDeleteAll() no elimina los elementos del contenedor; simplemente aplica la función delete a dichos elementos. En el ejemplo anterior, llamamos a clear() sobre el contenedor para eliminar los elementos.

Esta función también se puede utilizar para eliminar elementos almacenados en contenedores asociativos, como QMap y QHash. Esta función solo eliminará los objetos almacenados en cada contenedor; los objetos utilizados como claves no se eliminarán.

Véase también forward iterators.

template <typename Container> void qDeleteAll(const Container &c)

Esto equivale a qDeleteAll(c.begin(), c.end()).

Se trata de una función sobrecargada.

[since 6.10] template < typename InputIterator, typename Result, typename Separator = Result, typename Projection = std::identity > Result qJoin(InputIterator first, InputIterator last, Result init, const Separator &separator = {}, Projection p = {})

Comienza con el valor inicial init y le va sumando de forma acumulativa cada entrada del intervalo comprendido entre first y last. Antes de sumarse, cada entrada se mapea mediante la proyección p (cuya proyección por defecto es la identidad). Entre cada entrada y la siguiente, se añade un separator opcional. Por ejemplo:

QList<int> l = {1, 2, 3};
QString res = qJoin(l.cbegin(), l.cend(), QString(), u" / ",
                    [](int n) { return QString::number(2 * n);});
// res == "2 / 4 / 6"

Nota: q20::identity es una adaptación a C++17 de la función de C++20 std::identity.

Esta función se introdujo en Qt 6.10.

[constexpr noexcept] uint qPopulationCount(quint8 v)

Devuelve el número de bits a v. Este número también se conoce como «peso de Hamming» de v.

[constexpr noexcept] uint qPopulationCount(quint16 v)

Esta es una función sobrecargada.

[constexpr noexcept] uint qPopulationCount(quint32 v)

Esta es una función sobrecargada.

[constexpr noexcept] uint qPopulationCount(quint64 v)

Esta es una función sobrecargada.

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