En esta página

QtConcurrent Namespace

El espacio de nombres QtConcurrent ofrece interfaces de programación de alto nivel que permiten escribir programas multihilo sin necesidad de utilizar primitivas de subprocesos de bajo nivel. Más información...

Encabezado: #include <QtConcurrent>
CMake: find_package(Qt6 REQUIRED COMPONENTS Concurrent)
target_link_libraries(mytarget PRIVATE Qt6::Concurrent)
qmake: QT += concurrent

Clases

(since 6.0) class QTaskBuilder

Tipos

enum class FutureResult { Ignore }
InvokeResultType
enum ReduceOption { UnorderedReduce, OrderedReduce, SequentialReduce }
flags ReduceOptions

Funciones

void blockingFilter(Sequence &sequence, KeepFunctor &&filterFunction)
void blockingFilter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)
std::decay_t<Sequence> blockingFiltered(Sequence &&sequence, KeepFunctor &&filterFunction)
OutputSequence blockingFiltered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)
std::decay_t<Sequence> blockingFiltered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)
OutputSequence blockingFiltered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)
ResultType blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
void blockingMap(Sequence &&sequence, MapFunctor &&function)
void blockingMap(Iterator begin, Iterator end, MapFunctor &&function)
void blockingMap(QThreadPool *pool, Sequence &&sequence, MapFunctor function)
void blockingMap(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)
OutputSequence blockingMapped(InputSequence &&sequence, MapFunctor &&function)
Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor &&function)
OutputSequence blockingMapped(QThreadPool *pool, InputSequence &&sequence, MapFunctor &&function)
Sequence blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)
ResultType blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
ResultType blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<void> filter(Sequence &sequence, KeepFunctor &&filterFunction)
QFuture<void> filter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)
QFuture<typename std::decay_t<Sequence>::value_type> filtered(Sequence &&sequence, KeepFunctor &&filterFunction)
QFuture<typename qValueType<Iterator>::value_type> filtered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)
QFuture<typename std::decay_t<Sequence>::value_type> filtered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)
QFuture<typename qValueType<Iterator>::value_type> filtered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)
QFuture<ResultType> filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<void> map(Sequence &&sequence, MapFunctor &&function)
QFuture<void> map(Iterator begin, Iterator end, MapFunctor &&function)
QFuture<void> map(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)
QFuture<void> map(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)
QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> mapped(Sequence &&sequence, MapFunctor &&function)
QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> mapped(Iterator begin, Iterator end, MapFunctor &&function)
QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> mapped(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)
QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> mapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)
QFuture<ResultType> mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<ResultType> mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))
QFuture<T> run(Function function, ...)
QFuture<T> run(QThreadPool *pool, Function function, ...)
(since 6.0) QtConcurrent::QTaskBuilder<Task> task(Task &&task)

Descripción detallada

Consulta la Qt Concurrent documentación del módulo para obtener una visión general de las funciones disponibles, o consulta a continuación la información detallada sobre cada función.

Optimizar inclusiones

Si se incluye el encabezado « <QtConcurrent> », se incluirá todo el módulo « Qt Concurrent » junto con todo el módulo « Qt Core », lo que puede aumentar los tiempos de compilación y el tamaño de los binarios. Para utilizar funciones individuales del espacio de nombres «QtConcurrent», se pueden incluir encabezados más específicos.

La siguiente tabla enumera las funciones del espacio de nombres QtConcurrent y sus encabezados correspondientes:

FunciónArchivo de cabecera
QtConcurrent::run()<QtConcurrentRun>
QtConcurrent::task()<QtConcurrentTask>
QtConcurrent::filter(), QtConcurrent::filtered(), QtConcurrent::filteredReduced()<QtConcurrentFilter>
QtConcurrent::map(), QtConcurrent::mapped(), QtConcurrent::mappedReduced()<QtConcurrentMap>

Clases

clase QTaskBuilder

La clase QTaskBuilder se utiliza para ajustar los parámetros de las tareas. Más...

Documentación de tipos

enum class QtConcurrent::FutureResult

Este tipo de enumeración se utiliza para invocar una sobrecarga especial de ` QtConcurrent::QTaskBuilder::spawn` (`QtConcurrent::FutureResult`) que no devuelve un objeto «future».

ConstanteValorDescripción
QtConcurrent::FutureResult::Ignore0Una etiqueta auxiliar introducida para mejorar la legibilidad del código.

[alias] InvokeResultType

La definición simplificada de este tipo es la siguiente:

template <class Task, class ...Args>
using InvokeResultType = std::invoke_result_t<std::decay_t<Task>, std::decay_t<Args>...>;

La implementación real también incluye una comprobación en tiempo de compilación para determinar si la tarea puede invocarse con los argumentos especificados o no.

enum QtConcurrent::ReduceOption
flags QtConcurrent::ReduceOptions

Esta enumeración especifica el orden en el que los resultados de la función «map» o «filter» se pasan a la función «reduce».

ConstanteValorDescripción
QtConcurrent::UnorderedReduce0x1La reducción se realiza en un orden arbitrario.
QtConcurrent::OrderedReduce0x2La reducción se realiza en el orden de la secuencia original.
QtConcurrent::SequentialReduce0x4La reducción se realiza de forma secuencial: solo un hilo entrará en la función de reducción a la vez. (Es posible que se admita la reducción paralela en una futura versión de Qt Concurrent.)

El tipo `ReduceOptions` es una definición de tipo para ` QFlags<ReduceOption>`. Almacena una combinación OR de valores de `ReduceOption`.

Documentación de la función

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(Sequence &sequence, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Si ` filterFunction ` devuelve ` true`, el elemento se mantiene en ` sequence`; en caso contrario, el elemento se elimina de ` sequence`.

Ten en cuenta que este método no tiene una sobrecarga que funcione con iteradores, ya que invalida los iteradores de la secuencia sobre la que opera.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template <typename Sequence, typename KeepFunctor> void QtConcurrent::blockingFilter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` filterFunction ` se realizan desde los hilos extraídos de ` QThreadPool ` ` pool`. Si ` filterFunction ` devuelve ` true`, el elemento se mantiene en ` sequence`; de lo contrario, el elemento se elimina de ` sequence`.

Ten en cuenta que este método no tiene una sobrecarga que funcione con iteradores, ya que invalida los iteradores de la secuencia sobre la que opera.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(Sequence &&sequence, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` sequence ` y devuelve una nueva secuencia con los elementos conservados. Si ` filterFunction ` devuelve ` true`, se añade una copia del elemento a la nueva secuencia. En caso contrario, el elemento no aparecerá en la nueva secuencia.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también filtered() y «Filtro concurrente» y «Filtro-Reducción».

template < typename OutputSequence, typename Iterator, typename KeepFunctor > OutputSequence QtConcurrent::blockingFiltered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` begin ` a ` end ` y devuelve una nueva secuencia con los elementos conservados. Si ` filterFunction ` devuelve ` true`, se añade una copia del elemento a la nueva secuencia. De lo contrario, el elemento no aparecerá en la nueva secuencia.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también « filtered()» y «Filtro concurrente» y «Filtro-Reducción».

template <typename Sequence, typename KeepFunctor> std::decay_t<Sequence> QtConcurrent::blockingFiltered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` sequence ` y devuelve una nueva secuencia con los elementos conservados. Todas las llamadas a ` filterFunction ` se realizan desde los hilos obtenidos de ` QThreadPool ` pool. Si ` filterFunction ` devuelve ` true`, se añade una copia del elemento a la nueva secuencia. De lo contrario, el elemento no aparecerá en la nueva secuencia.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también « filtered()» y «Filtro concurrente» y «Filtro-Reducción».

template < typename OutputSequence, typename Iterator, typename KeepFunctor > OutputSequence QtConcurrent::blockingFiltered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento, desde ` begin ` hasta ` end `, y devuelve una nueva secuencia con los elementos conservados. Todas las llamadas a ` filterFunction ` se realizan desde los hilos obtenidos de ` QThreadPool ` y ` pool`. Si ` filterFunction ` devuelve ` true`, se introduce una copia del elemento en la nueva secuencia. De lo contrario, el elemento no aparecerá en la nueva secuencia.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también filtered() y «Filtro concurrente» y «Filtro-Reducción».

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa a ` reduceFunction`. En otras palabras, el valor devuelto es el resultado de ` reduceFunction ` para cada elemento para el que ` filterFunction ` devuelva ` true`.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca en el orden de la secuencia original.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` begin ` a ` end`. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor devuelto es el resultado de ` reduceFunction ` para cada elemento para el que ` filterFunction ` devuelva ` true`.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, se invoca reduceFunction en el orden de la secuencia original.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también ` filteredReduced()` y «Filtro concurrente» y «Filtro-Reducción».

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` filterFunction ` se invocan desde los hilos tomados de ` QThreadPool ` pool. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor de retorno es el resultado de ` reduceFunction ` para cada elemento en el que ` filterFunction ` devuelva ` true`.

Tenga en cuenta que, aunque se llama a ` filterFunction ` de forma concurrente, solo un hilo a la vez llamará a ` reduceFunction`. El orden en el que se llama a ` reduceFunction ` no está definido si ` reduceOptions ` es ` QtConcurrent::UnorderedReduce`. Si ` reduceOptions ` es ` QtConcurrent::OrderedReduce`, ` reduceFunction ` se llama en el orden de la secuencia original.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también « filteredReduced()», «Filtro concurrente» y «Filtro-Reducción».

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingFilteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor de retorno es el resultado de ` reduceFunction ` para cada elemento para el que ` filterFunction ` devuelva ` true`. El valor de resultado se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` actuará sobre este valor.

Ten en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca siguiendo el orden de la secuencia original.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también filteredReduced() y Filtro concurrente y Filtro-Reducción.

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingFilteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento, desde ` begin ` hasta ` end`. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor devuelto es el resultado de ` reduceFunction ` para cada elemento para el que ` filterFunction ` devuelva ` true`. El valor resultante se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` actuará sobre este valor.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca siguiendo el orden de la secuencia original.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también ` filteredReduced()` y «Filtro concurrente» y «Filtro-Reducción».

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a filterFunction una vez por cada elemento de begin a end. Todas las llamadas a filterFunction se invocan desde los hilos obtenidos de QThreadPool pool . Si filterFunction devuelve true para un elemento, dicho elemento se pasa entonces a reduceFunction. En otras palabras, el valor devuelto es el resultado de reduceFunction para cada elemento en el que filterFunction devuelve true.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, la reduceFunction se invoca en el orden de la secuencia original.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también ` filteredReduced()` y «Filtro concurrente» y «Filtro-Reducción».

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingFilteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` filterFunction ` se invocan desde los hilos obtenidos de ` QThreadPool ` pool. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor de retorno es el resultado de ` reduceFunction ` para cada elemento para el que ` filterFunction ` devuelva ` true`. El valor de resultado se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` operará sobre este valor.

Ten en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca siguiendo el orden de la secuencia original.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también filteredReduced() y «Filtro concurrente» y «Filtro-Reducción».

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingFilteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a filterFunction una vez por cada elemento, desde begin hasta end. Todas las llamadas a filterFunction se realizan desde los hilos obtenidos de QThreadPool pool . Si filterFunction devuelve true para un elemento, dicho elemento se pasa entonces a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento para el que filterFunction devuelva true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Ten en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction es indefinido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, la reduceFunction se invoca en el orden de la secuencia original.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también ` filteredReduced()` y «Filtro concurrente» y «Filtro-Reducción».

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(Sequence &&sequence, MapFunctor &&function)

Llama a « function » una vez por cada elemento de « sequence ». La función « function » toma una referencia al elemento, de modo que cualquier modificación que se realice en él aparecerá en « sequence ».

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también map() y «Map» y «Map-Reduce» concurrentes.

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(Iterator begin, Iterator end, MapFunctor &&function)

Llama a « function » una vez por cada elemento de « begin » a « end ». La función « function » toma una referencia al elemento, de modo que cualquier modificación que se realice en él aparecerá en la secuencia a la que pertenecen los iteradores.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también « map()» y «Map y Map-Reduce concurrentes».

template <typename Sequence, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool *pool, Sequence &&sequence, MapFunctor function)

Llama a ` function ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` function ` se invocan desde los hilos extraídos de ` QThreadPool ` pool. La función ` function ` toma una referencia al elemento, de modo que cualquier modificación realizada en el elemento aparecerá en ` sequence`.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también map() y «Map» y «Map-Reduce» concurrentes.

template <typename Iterator, typename MapFunctor> void QtConcurrent::blockingMap(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

Llama a ` function ` una vez por cada elemento de ` begin ` a ` end`. Todas las llamadas a ` function ` se invocan desde los hilos obtenidos de ` QThreadPool ` ` pool`. La función ` function ` toma una referencia al elemento, de modo que cualquier modificación que se realice en él aparecerá en la secuencia a la que pertenecen los iteradores.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también map() y «Map y Map-Reduce concurrentes».

template < typename OutputSequence, typename InputSequence, typename MapFunctor > OutputSequence QtConcurrent::blockingMapped(InputSequence &&sequence, MapFunctor &&function)

Llama a « function » una vez por cada elemento de « sequence » y devuelve una «OutputSequence» que contiene los resultados. El tipo de los resultados coincidirá con el tipo devuelto por «MapFunctor».

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también mapped() y Map y Map-Reduce concurrentes.

template < typename Sequence, typename Iterator, typename MapFunctor > Sequence QtConcurrent::blockingMapped(Iterator begin, Iterator end, MapFunctor &&function)

Llama a « function » una vez por cada elemento de « begin » a « end » y devuelve un contenedor con los resultados. Puedes especificar el tipo de contenedor como argumento de plantilla, de esta manera:

QList<int> ints = QtConcurrent::blockingMapped<QList<int> >(beginIterator, endIterator, fn);

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también mapped() y «Map y Map-Reduce concurrentes».

template < typename OutputSequence, typename InputSequence, typename MapFunctor > OutputSequence QtConcurrent::blockingMapped(QThreadPool *pool, InputSequence &&sequence, MapFunctor &&function)

Llama a « function » una vez por cada elemento de « sequence » y devuelve una «OutputSequence» que contiene los resultados. Todas las llamadas a « function » se invocan desde los hilos obtenidos de « QThreadPool » pool. El tipo de los resultados coincidirá con el tipo devuelto por «MapFunctor».

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también mapped() y «Map» y «Map-Reduce» concurrentes.

template < typename Sequence, typename Iterator, typename MapFunctor > Sequence QtConcurrent::blockingMapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

Llama a ` function ` una vez por cada elemento de ` begin ` a ` end ` y devuelve un contenedor con los resultados. Todas las llamadas a ` function ` se invocan desde los hilos extraídos de ` QThreadPool ` pool. Puedes especificar el tipo de contenedor como argumento de plantilla, de esta forma:

QList<int> ints = QtConcurrent::blockingMapped<QList<int> >(beginIterator, endIterator, fn);

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también « mapped()» y «Map y Map-Reduce concurrentes».

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` sequence`. El valor devuelto por cada ` mapFunction ` se pasa a ` reduceFunction`.

Ten en cuenta que, aunque se llama a ` mapFunction ` de forma concurrente, solo un hilo a la vez llamará a ` reduceFunction`. El orden en el que se llama a ` reduceFunction ` viene determinado por ` reduceOptions`.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también mapped() y «Map y Map-Reduce concurrentes».

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento, desde ` begin ` hasta ` end`. El valor devuelto por cada ` mapFunction ` se pasa a ` reduceFunction`.

Ten en cuenta que, aunque mapFunction se llama de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction no está definido.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también blockingMappedReduced() y «Map y Map-Reduce concurrentes».

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` mapFunction ` se invocan desde los hilos obtenidos de ` QThreadPool ` y ` pool`. El valor de retorno de cada ` mapFunction ` se pasa a ` reduceFunction`.

Ten en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction viene determinado por reduceOptions.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también mapped() y «Map y Map-Reduce concurrentes».

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingMappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` sequence`. El valor devuelto por cada ` mapFunction ` se pasa a ` reduceFunction`. El valor resultante se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` actuará sobre este valor.

Tenga en cuenta que, aunque se llama a mapFunction de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction viene determinado por reduceOptions.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también ` mapped()` y «Map y Map-Reduce concurrentes».

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingMappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` begin ` a ` end`. El valor devuelto por cada ` mapFunction ` se pasa a ` reduceFunction`. El valor resultante se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` operará sobre este valor.

Tenga en cuenta que, aunque se invoca mapFunction de forma concurrente, solo un hilo a la vez invocará reduceFunction. El orden en el que se invoca reduceFunction no está definido.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también blockingMappedReduced() y «Map y Map-Reduce concurrentes».

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor > ResultType QtConcurrent::blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a mapFunction una vez por cada elemento de begin a end. Todas las llamadas a mapFunction se invocan desde los hilos obtenidos de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction.

Tenga en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también blockingMappedReduced() y «Map y Map-Reduce concurrentes».

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingMappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` mapFunction ` se invocan desde los hilos extraídos de ` QThreadPool ` pool. El valor de retorno de cada ` mapFunction ` se pasa a ` reduceFunction`. El valor resultante se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` operará sobre este valor.

Tenga en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca a reduceFunction viene determinado por reduceOptions.

Nota: Esta función se bloqueará hasta que se hayan procesado todos los elementos de la secuencia.

Véase también ` mapped()` y «Map y Map-Reduce concurrentes».

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > ResultType QtConcurrent::blockingMappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a mapFunction una vez por cada elemento de begin a end. Todas las llamadas a mapFunction se invocan desde los hilos obtenidos de QThreadPool pool . El valor de retorno de cada mapFunction se pasa a reduceFunction. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que, aunque se llama a mapFunction de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se llama a reduceFunction no está definido.

Nota: Esta función se bloqueará hasta que el iterador llegue al final de la secuencia que se está procesando.

Véase también blockingMappedReduced() y «Map y Map-Reduce concurrentes».

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(Sequence &sequence, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Si ` filterFunction ` devuelve ` true`, el elemento se conserva en ` sequence`; en caso contrario, el elemento se elimina de ` sequence`.

Tenga en cuenta que este método no tiene una sobrecarga que funcione con iteradores, ya que invalida los iteradores de la secuencia sobre la que opera.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template <typename Sequence, typename KeepFunctor> QFuture<void> QtConcurrent::filter(QThreadPool *pool, Sequence &sequence, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` filterFunction ` se realizan desde los hilos obtenidos de ` QThreadPool ` ` pool`. Si ` filterFunction ` devuelve ` true`, el elemento se mantiene en ` sequence`; en caso contrario, el elemento se elimina de ` sequence`.

Tenga en cuenta que este método no tiene una sobrecarga que funcione con iteradores, ya que invalida los iteradores de la secuencia sobre la que opera.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(Sequence &&sequence, KeepFunctor &&filterFunction)

Llama a « filterFunction » una vez por cada elemento de « sequence » y devuelve una nueva secuencia con los elementos conservados. Si « filterFunction » devuelve « true », se añade una copia del elemento a la nueva secuencia. De lo contrario, el elemento no aparecerá en la nueva secuencia.

Véase también «Concurrent Filter» y «Filter-Reduce».

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(Iterator begin, Iterator end, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` begin ` a ` end ` y devuelve una nueva secuencia con los elementos conservados. Si ` filterFunction ` devuelve ` true`, se añade una copia del elemento a la nueva secuencia. De lo contrario, el elemento no aparecerá en la nueva secuencia.

Véase también «Concurrent Filter» y «Filter-Reduce».

template <typename Sequence, typename KeepFunctor> QFuture<typename std::decay_t<Sequence>::value_type> QtConcurrent::filtered(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` sequence ` y devuelve una nueva secuencia con los elementos conservados. Todas las llamadas a ` filterFunction ` se realizan desde los hilos obtenidos de ` QThreadPool ` pool. Si ` filterFunction ` devuelve ` true`, se añade una copia del elemento a la nueva secuencia. De lo contrario, el elemento no aparecerá en la nueva secuencia.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template <typename Iterator, typename KeepFunctor> QFuture<typename qValueType<Iterator>::value_type> QtConcurrent::filtered(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction)

Llama a ` filterFunction ` una vez por cada elemento de ` begin ` a ` end ` y devuelve una nueva secuencia con los elementos conservados. Todas las llamadas a ` filterFunction ` se invocan desde los hilos obtenidos de ` QThreadPool ` pool. Si ` filterFunction ` devuelve ` true`, se coloca una copia del elemento en la nueva secuencia. De lo contrario, el elemento no aparecerá en la nueva secuencia.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa a ` reduceFunction`. En otras palabras, el valor devuelto es el resultado de ` reduceFunction ` para cada elemento en el que ` filterFunction ` devuelva ` true`.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca en el orden de la secuencia original.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` begin ` a ` end`. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor devuelto es el resultado de ` reduceFunction ` para cada elemento para el que ` filterFunction ` devuelva ` true`.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca en el orden de la secuencia original.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` filterFunction ` se invocan desde los hilos obtenidos de ` QThreadPool ` pool. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa a ` reduceFunction`. En otras palabras, el valor devuelto es el resultado de ` reduceFunction ` para cada elemento para el que ` filterFunction ` devuelva ` true`.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca en el orden de la secuencia original.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::filteredReduced(Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor devuelto es el resultado de ` reduceFunction ` para cada elemento en el que ` filterFunction ` devuelva ` true`. El valor resultante se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` operará sobre este valor.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca en el orden de la secuencia original.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::filteredReduced(Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a filterFunction una vez por cada elemento, desde begin hasta end. Si filterFunction devuelve true para un elemento, dicho elemento se pasa entonces a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento en el que filterFunction devuelva true. El valor de resultado se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction actuará sobre este valor.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca siguiendo el orden de la secuencia original.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento desde ` begin ` hasta ` end`. Todas las llamadas a ` filterFunction ` se invocan desde los hilos extraídos de ` QThreadPool ` y ` pool`. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor devuelto es el resultado de ` reduceFunction ` para cada elemento en el que ` filterFunction ` devuelva ` true`.

Tenga en cuenta que, aunque se invoca « filterFunction » de forma concurrente, solo un hilo a la vez invocará « reduceFunction ». El orden en el que se invoca « reduceFunction » no está definido si « reduceOptions » es « QtConcurrent::UnorderedReduce ». Si « reduceOptions » es « QtConcurrent::OrderedReduce », se invoca « reduceFunction » en el orden de la secuencia original.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template < typename ResultType, typename Sequence, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool *pool, Sequence &&sequence, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` filterFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` filterFunction ` se invocan desde los hilos extraídos de ` QThreadPool ` pool. Si ` filterFunction ` devuelve ` true ` para un elemento, dicho elemento se pasa entonces a ` reduceFunction`. En otras palabras, el valor de retorno es el resultado de ` reduceFunction ` para cada elemento para el que ` filterFunction ` devuelva ` true`. El valor de resultado se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` operará sobre este valor.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez invocará reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, reduceFunction se invoca en el orden de la secuencia original.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template < typename ResultType, typename Iterator, typename KeepFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::filteredReduced(QThreadPool *pool, Iterator begin, Iterator end, KeepFunctor &&filterFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a filterFunction una vez por cada elemento, desde begin hasta end. Todas las llamadas a filterFunction se realizan desde los hilos obtenidos de QThreadPool pool . Si filterFunction devuelve true para un elemento, dicho elemento se pasa entonces a reduceFunction. En otras palabras, el valor de retorno es el resultado de reduceFunction para cada elemento para el que filterFunction devuelva true. El valor resultante se inicializa en initialValue cuando se llama a la función, y la primera llamada a reduceFunction operará sobre este valor.

Tenga en cuenta que, aunque filterFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction no está definido si reduceOptions es QtConcurrent::UnorderedReduce. Si reduceOptions es QtConcurrent::OrderedReduce, el reduceFunction se invoca en el orden de la secuencia original.

Véase también «Filtro concurrente»y «Filtro-Reducción».

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(Sequence &&sequence, MapFunctor &&function)

Llama a ` function ` una vez por cada elemento de ` sequence`. La función ` function ` toma una referencia al elemento, de modo que cualquier modificación que se realice en él aparecerá en ` sequence`.

Véase también «Mapa concurrente»y «Mapa-Reducción».

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(Iterator begin, Iterator end, MapFunctor &&function)

Llama a ` function ` una vez por cada elemento de ` begin ` a ` end`. La función ` function ` toma una referencia al elemento, de modo que cualquier modificación que se realice en el elemento aparecerá en la secuencia a la que pertenecen los iteradores.

Véase también «Mapa concurrente»y «Map-Reduce».

template <typename Sequence, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)

Llama a « function » una vez por cada elemento de « sequence ». Todas las llamadas a « function » se invocan desde los hilos obtenidos de « QThreadPool » pool. « function » toma una referencia al elemento, de modo que cualquier modificación realizada en él aparecerá en « sequence ».

Véase también «Mapa concurrente»y «Mapa-Reducción».

template <typename Iterator, typename MapFunctor> QFuture<void> QtConcurrent::map(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

Llama a ` function ` una vez por cada elemento, desde ` begin ` hasta ` end`. Todas las llamadas a ` function ` se invocan desde los hilos obtenidos de ` QThreadPool ` y ` pool`. La función ` function ` toma una referencia al elemento, de modo que cualquier modificación que se realice en él aparecerá en la secuencia a la que pertenecen los iteradores.

Véase también «Mapa concurrente»y «Map-Reduce».

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(Sequence &&sequence, MapFunctor &&function)

Llama a ` function ` una vez por cada elemento de ` sequence ` y devuelve un «future» con cada elemento mapeado como resultado. Puedes utilizar ` QFuture::const_iterator ` o ` QFutureIterator ` para recorrer los resultados.

Véase también «Concurrent Map» y «Map-Reduce».

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(Iterator begin, Iterator end, MapFunctor &&function)

Llama a « function » una vez por cada elemento, desde « begin » hasta « end », y devuelve un «future» con cada elemento mapeado como resultado. Puedes utilizar « QFuture::const_iterator » o « QFutureIterator » para recorrer los resultados.

Véase también «Map concurrente»y «Map-Reduce».

template <typename Sequence, typename MapFunctor> QFuture<QtPrivate::MapResultType<Sequence, MapFunctor>> QtConcurrent::mapped(QThreadPool *pool, Sequence &&sequence, MapFunctor &&function)

Llama a ` function ` una vez por cada elemento de ` sequence ` y devuelve un «future» con cada elemento mapeado como resultado. Todas las llamadas a ` function ` se invocan desde los hilos obtenidos de ` QThreadPool ` pool. Puedes utilizar ` QFuture::const_iterator ` o ` QFutureIterator ` para iterar por los resultados.

Véase también «Concurrent Map» y «Map-Reduce».

template <typename Iterator, typename MapFunctor> QFuture<QtPrivate::MapResultType<Iterator, MapFunctor>> QtConcurrent::mapped(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&function)

Llama a « function » una vez por cada elemento de « begin » a « end » y devuelve un «future» con cada elemento mapeado como resultado. Todas las llamadas a « function » se invocan desde los hilos obtenidos de « QThreadPool » pool. Puedes utilizar « QFuture::const_iterator » o « QFutureIterator » para recorrer los resultados.

Véase también «Concurrent Map» y «Map-Reduce».

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` sequence`. El valor devuelto por cada ` mapFunction ` se pasa a ` reduceFunction`.

Ten en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca reduceFunction viene determinado por reduceOptions.

Véase también «Map concurrente»y «Map-Reduce».

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento, desde ` begin ` hasta ` end`. El valor devuelto por cada ` mapFunction ` se pasa a ` reduceFunction`.

Ten en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. Por defecto, el orden en el que se invoca a reduceFunction no está definido.

Nota: QtConcurrent::OrderedReduce da como resultado la reducción ordenada.

Véase también «Map concurrente»y «Map-Reduce».

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` mapFunction ` se invocan desde los hilos obtenidos de ` QThreadPool ` pool. El valor de retorno de cada ` mapFunction ` se pasa a ` reduceFunction`.

Tenga en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. El orden en el que se invoca a reduceFunction viene determinado por reduceOptions.

Véase también «Map concurrente»y «Map-Reduce».

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::mappedReduced(Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` sequence`. El valor devuelto por cada ` mapFunction ` se pasa a ` reduceFunction`. El valor resultante se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` actuará sobre este valor.

Tenga en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez invocará reduceFunction. El orden en el que se invoca reduceFunction viene determinado por reduceOptions.

Véase también «Mapa concurrente»y «Mapa-Reducción».

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::mappedReduced(Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento desde ` begin ` hasta ` end`. El valor devuelto por cada ` mapFunction ` se pasa a ` reduceFunction`. El valor resultante se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` operará sobre este valor.

Tenga en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. Por defecto, el orden en el que se invoca a reduceFunction no está definido.

Nota: QtConcurrent::OrderedReduce da como resultado la reducción ordenada.

Véase también «Map concurrente»y «Map-Reduce».

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor > QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` begin ` a ` end`. Todas las llamadas a ` mapFunction ` se invocan desde los hilos obtenidos de ` QThreadPool ` y ` pool`. El valor de retorno de cada ` mapFunction ` se pasa a ` reduceFunction`.

Ten en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez llamará a reduceFunction. Por defecto, el orden en el que se invoca reduceFunction no está definido.

Nota: QtConcurrent::OrderedReduce da como resultado la reducción ordenada.

Véase también «Map concurrente»y «Map-Reduce».

template < typename ResultType, typename Sequence, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool *pool, Sequence &&sequence, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` sequence`. Todas las llamadas a ` mapFunction ` se invocan desde los hilos obtenidos de ` QThreadPool ` pool. El valor de retorno de cada ` mapFunction ` se pasa a ` reduceFunction`. El valor resultante se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` operará sobre este valor.

Tenga en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez invocará reduceFunction. El orden en el que se invoca reduceFunction viene determinado por reduceOptions.

Véase también «Mapa concurrente»y «Map-Reduce».

template < typename ResultType, typename Iterator, typename MapFunctor, typename ReduceFunctor, typename InitialValueType > QFuture<ResultType> QtConcurrent::mappedReduced(QThreadPool *pool, Iterator begin, Iterator end, MapFunctor &&mapFunction, ReduceFunctor &&reduceFunction, InitialValueType &&initialValue, QtConcurrent::ReduceOptions reduceOptions = ReduceOptions(UnorderedReduce | SequentialReduce))

Llama a ` mapFunction ` una vez por cada elemento de ` begin ` a ` end`. Todas las llamadas a ` mapFunction ` se invocan desde los hilos obtenidos de ` QThreadPool ` y ` pool`. El valor de retorno de cada ` mapFunction ` se pasa a ` reduceFunction`. El valor del resultado se inicializa en ` initialValue ` cuando se llama a la función, y la primera llamada a ` reduceFunction ` operará sobre este valor.

Tenga en cuenta que, aunque mapFunction se invoca de forma concurrente, solo un hilo a la vez invocará reduceFunction. Por defecto, el orden en el que se invoca reduceFunction no está definido.

Nota: QtConcurrent::OrderedReduce da como resultado la reducción ordenada.

Véase también «Map concurrente»y «Map-Reduce».

template <typename T> QFuture<T> QtConcurrent::run(Function function, ...)

Equivalente a

QtConcurrent::run(QThreadPool::globalInstance(), function, ...);

Ejecuta ` function ` en un hilo independiente. El hilo se toma de la variable global ` QThreadPool`. Ten en cuenta que ` function ` puede que no se ejecute inmediatamente; ` function ` solo se ejecutará cuando haya un hilo disponible.

En modo básico, T es del mismo tipo que el valor de retorno de function. Se puede acceder a los valores de retorno que no sean de tipo void mediante la función QFuture::result().

En el modo básico, el ` QFuture ` devuelto solo puede utilizarse para consultar el estado de ejecución (en curso o finalizado) y el valor de retorno de la función. En concreto, solo se puede emitir una orden de cancelación o pausa si aún no se han iniciado los cálculos subyacentes al `future`.

En el modo «ejecutar con promesa», se espera que el ` function ` devuelva `void` y debe tomar un argumento adicional de tipo ` QPromise<T> & `, situado como primer argumento en la lista de argumentos de la función. `T` es el tipo de resultado y es el mismo para el ` QFuture<T>` devuelto.

En el modo «ejecución con promesa», al igual que en el modo básico, el objeto ` QFuture ` devuelto puede utilizarse para consultar el estado de ejecución (en curso o finalizada) y el valor devuelto por la función. Además, puede utilizarse para suspender o cancelar la tarea en ejecución, obtener múltiples resultados de la función ` function ` llamada o supervisar el progreso informado por el objeto ` function`.

Véase también «Ejecución simultánea (modo básico)», «Ejecución simultánea con promesa» y « QThreadPool::start()».

template <typename T> QFuture<T> QtConcurrent::run(QThreadPool *pool, Function function, ...)

Programa function en pool. Ten en cuenta que es posible que function no se ejecute inmediatamente; function solo se ejecutará cuando haya un hilo disponible.

En el modo básico, T es del mismo tipo que el valor de retorno de function. Se puede acceder a los valores de retorno que no sean de tipo void mediante la función QFuture::result().

En el modo básico, el ` QFuture ` devuelto solo puede utilizarse para consultar el estado de ejecución (en curso o finalizado) y el valor de retorno de la función. En concreto, solo se puede emitir una orden de cancelación o pausa si aún no se han iniciado los cálculos subyacentes al `future`.

En el modo «run with promise», se espera que el ` function ` devuelva `void` y debe tomar un argumento adicional de tipo ` QPromise<T> & `, situado como primer argumento en la lista de argumentos de la función. `T` es el tipo de resultado y es el mismo que el del ` QFuture<T>` devuelto.

En el modo de ejecución con promesa, al igual que en el modo básico, el objeto ` QFuture ` devuelto se puede utilizar para consultar el estado de ejecución (en curso o finalizada) y el valor devuelto por la función. Además, puede utilizarse para suspender o cancelar la tarea en ejecución, obtener múltiples resultados del ` function ` invocado o supervisar el progreso informado por el ` function`.

Véase también «Ejecución simultánea (modo básico)», «Ejecución simultánea con Promise» y « QThreadPool::start()».

[since 6.0] template <typename Task> QtConcurrent::QTaskBuilder<Task> QtConcurrent::task(Task &&task)

Crea una instancia de ` QtConcurrent::QTaskBuilder`. Este objeto se puede utilizar para ajustar algunos parámetros y ejecutar ` task ` en un hilo independiente.

Esta función se introdujo en Qt 6.0.

Véase también «Tarea concurrente » y « QtConcurrent::QTaskBuilder ».

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