QtConcurrent命名空间

最新推荐文章于 2024-09-05 13:52:10 发布
最新推荐文章于 2024-09-05 13:52:10 发布
阅读量497 收藏 5
点赞数 1
分类专栏： Qt Concurrent模块 文章标签： qt python 微信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kenfan1647/article/details/118685338
版权

一、类型成员

1、enum QtConcurrent::ReduceOption：此枚举指定将 map 或 filter 函数的结果传递给 reduce 函数的顺序。

  • UnorderedReduce：任意顺序。
  • OrderedReduce：按照原始序列的顺序进行的。
  • SequentialReduce：一次只有一个线程会进入reduce功能。

二、成员函数

2.1、总结

此命名空间的函数可以分成3类：

运行时阻塞的（处理容器中的数据）

  1. blockingFilter：为列表中每个项目调用过滤器函数（返回bool类型），过滤器函数返回false的项目从列表中删除。
  2. blockingFiltered：与1类似，不修改原列表，返回新列表。
  3. blockingFilteredReduced：为列表中每个项目调用过滤器函数（返回bool类型），将过滤器函数返回true的项目传递给 reduceFunction。
  4. blockingMap：按顺序为列表中每个项目调用一次函数。
  5. blockingMapped：按顺序为列表中每个项目调用一次函数（函数必须要有返回值）。
  6. blockingMappedReduced：按顺序为每个项目调用一次函数（函数要有返回值）。每个返回值传递给 reduceFunction。

运行时不阻塞的（处理容器中的数据）

  1. filter：与 blockingFilter 对应相似。
  2. filtered：与 blockingFiltered 对应相似。
  3. filteredReduced：与 blockingFilteredReduced 对应相似。
  4. map：与 blockingMap 对应相似。
  5. mapped：与 blockingMapped 对应相似。
  6. mappedReduced：与 blockingMappedReduced 对应相似。

在另一个线程中运行一个函数

  1. run：在单独的线程中运行函数。

2.2、函数

1、template <typename Sequence, typename KeepFunctor> void blockingFilter(Sequence &sequence, KeepFunctor filterFunction)

按顺序为每个项目调用 filterFunction 一次。filterFunction 返回值为需为 bool 类型。如果 filterFunction 返回 true 项目保持顺序，否则该项目将从序列中删除。

注意：此函数将阻塞，直到序列中的所有项目都已处理完毕。

bool hasA(const QString & str)
{
    qDebug()<<QThread::currentThreadId();
    return str.contains('A');
}

int main(int argc, char *argv[])
{
    QList<QString> list;
    list << "ABC"<<"CDE"<<"GHI";
    QtConcurrent::blockingFilter(list,hasA);
    qDebug()<<list;
}

2、template <typename Sequence, typename KeepFunctor> Sequence blockingFiltered(const Sequence &sequence, KeepFunctor filterFunction)

与上面类似，不过不修改原列表，返回新的列表。

    QList<QString> list;
    list << "ABC"<<"CDE"<<"GHI";
    auto result = QtConcurrent::blockingFiltered(list,hasA);
    qDebug()<<list;
    qDebug()<<result;

3、template <typename OutputSequence, typename Iterator, typename KeepFunctor> OutputSequence blockingFiltered(Iterator begin, Iterator end, KeepFunctor filterFunction)

重载函数。从头到尾为每个项目调用 filterFunction 一次，并返回一个新的保留项目序列。如果 filterFunction 返回 true，则将项目的副本放入新的 Sequence。 否则，该项目将不会出现在新序列中。

注意：此函数将阻塞，直到迭代器到达正在处理的序列的末尾。

    QList<QString> list;
    list << "ABC"<<"CDE"<<"GHI"<<"CBA";
    auto result = QtConcurrent::blockingFiltered<QStringList>(list.begin(),list.end(),hasA);
    qDebug()<<list;
    qDebug()<<result;

    QList<QString> list;
    list << "ABC"<<"CDE"<<"GHI"<<"CBA";
    auto result = QtConcurrent::blockingFiltered<QString>(list.begin(),list.end(),hasA);
    qDebug()<<list;
    qDebug()<<result;

自定义存放结果的对象类型。

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

按顺序为每个项目调用 filterFunction 一次。如果 filterFunction 为某个项目返回 true，则该项目将被传递给 reduceFunction。

请注意，虽然 filterFunction 是并发调用的，但 reduceFunction 会在同一个线程调用。如果 reduceOptions 是 UnorderedReduce，则调用 reduceFunction 的顺序是未定义的。 如果reduceOptions 为 OrderedReduce，则reduceFunction 将按照原始序列的顺序调用。

注意：此函数将阻塞，直到序列中的所有项目都已处理完毕。

bool IsEvenNumber(int i)
{
    qDebug()<<"IsEvenNumber()函数线程Id："<<QThread::currentThreadId();
    return i % 2 == 0;
}

void sum(int& result ,int i)
{
    qDebug()<<"result = "<<result <<"i = "<<i<<"线程Id："<<QThread::currentThreadId();
    result = i*100;
}

int main(int argc, char *argv[])
{
    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    auto result = QtConcurrent::blockingFilteredReduced(list,IsEvenNumber,sum,QtConcurrent::UnorderedReduce);

    qDebug()<<"list中双数和为："<<result;
}

auto result = QtConcurrent::blockingFilteredReduced(list,IsEvenNumber,sum,QtConcurrent::OrderedReduce);

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

重载函数。

    auto result = QtConcurrent::blockingFilteredReduced(list.begin(),list.end(),IsEvenNumber,sum,QtConcurrent::UnorderedReduce);

6、template <typename Sequence, typename MapFunctor> void blockingMap(Sequence &sequence, MapFunctor function)

按顺序为每个项目调用一次function。该函数传递的是项目的引用，因此对项目所做的任何修改都将按顺序的。

注意：此函数将阻塞，直到序列中的所有项目都已处理完毕。

void add(int & i)
{
    ++i;
}

int main(int argc, char *argv[])
{
    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    QtConcurrent::blockingMap(list,add);
    qDebug()<<list;
}

7、template <typename Iterator, typename MapFunctor> void blockingMap(Iterator begin, Iterator end, MapFunctor function)

重载函数。

8、template <typename OutputSequence, typename InputSequence, typename MapFunctor> OutputSequence blockingMapped(const InputSequence &sequence, MapFunctor function)

按顺序为每个项目调用一次函数，并返回一个包含结果的 OutputSequence。结果的类型将与 MapFunctor 返回的类型相匹配。（注意：函数要有返回值）

注意：此函数将阻塞，直到序列中的所有项目都已处理完毕。

int add2(int i)
{
    return ++i;
}

int main(int argc, char *argv[])
{
    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    auto result = QtConcurrent::blockingMapped(list,add2);
    qDebug()<<list;
    qDebug()<<result;
}

9、template <typename Sequence, typename Iterator, typename MapFunctor> Sequence blockingMapped(Iterator begin, Iterator end, MapFunctor function)

重载函数。

    auto result = QtConcurrent::blockingMapped<QList<int>>(list.begin(),list.end(),add2);
    qDebug()<<list;
    qDebug()<<result;

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

按顺序为每个项目调用一次 mapFunction。 每个 mapFunction 的返回值传递给 reduceFunction。

请注意，虽然 mapFunction 是并发调用的，但一次只有一个线程会调用 reduceFunction。调用reduceFunction 的顺序由reduceOptions 决定。

注意：此函数将阻塞，直到序列中的所有项目都已处理完毕。

int multiplication(int i)
{
    qDebug()<<"multiplication()函数线程Id："<<QThread::currentThreadId();
    return i * 10;
}

void sum(int& result ,int i)
{
    qDebug()<<"result = "<<result <<"i = "<<i<<"线程Id："<<QThread::currentThreadId();
    result += i;
}

int main(int argc, char *argv[])
{
    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    auto result = QtConcurrent::blockingMappedReduced(list,multiplication,sum,QtConcurrent::SequentialReduce);
    qDebug()<<list;
    qDebug()<<result;
}

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

重载函数。

12、template <typename Sequence, typename KeepFunctor> QFuture<void> filter(Sequence &sequence, KeepFunctor filterFunction)

按顺序为每个项目调用一次 filterFunction 。如果 filterFunction 返回 true，则项目保持顺序；否则，该项目将从序列中删除。

int main(int argc, char *argv[])
{
    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    QtConcurrent::filter(list,[](const int & i)
    {
        qDebug()<<QThread::currentThreadId();
        return i % 3 == 0;
    });

    QThread::msleep(1000);
    qDebug()<<list;
}

13、template <typename Sequence, typename KeepFunctor> QFuture<typename Sequence::value_type> filtered(const Sequence &sequence, KeepFunctor filterFunction)

与上面类似，但返回一个新的保留项目序列。

    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    auto result = QtConcurrent::filtered<QList<int>>(list,[](const int & i)
    {
        return i % 3 == 0;
    });

    QThread::msleep(1000);
    qDebug()<<list;
    qDebug()<<result.results();

 

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

重载函数。

    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    auto result = QtConcurrent::filtered(list.begin(),list.end(),[](const int & i)
    {
        return i % 3 == 0;
    });

    QThread::msleep(1000);
    qDebug()<<list;
    qDebug()<<result.results();

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

按顺序为每个项目调用 filterFunction 一次。 如果 filterFunction 为某个项目返回 true，则该项目将被传递给 reduceFunction。

请注意，虽然 filterFunction 是并发调用的，但一次只有一个线程会调用 reduceFunction。

如果 reduceOptions 是 UnorderedReduce，则调用 reduceFunction 的顺序是未定义的。 如果reduceOptions 为OrderedReduce，则reduceFunction 将按照原始序列的顺序调用。

void sum(int& result ,int i)
{
    qDebug()<<"result = "<<result <<"i = "<<i<<"线程Id："<<QThread::currentThreadId();
    result += i;
}

bool divisibleBy3(const int & i)
{
    qDebug()<<QThread::currentThreadId();
    return i % 3 == 0;
}

int main(int argc, char *argv[])
{
    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    QFuture<int> result = QtConcurrent::filteredReduced(list,divisibleBy3,sum,QtConcurrent::SequentialReduce);

    QThread::msleep(1000);
    qDebug()<<list;
    qDebug()<<"列表中能被3整除的数加起来："<<result;
}

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

重载函数。

    QFuture<int> result = QtConcurrent::filteredReduced(list.begin(),list.end(),divisibleBy3,sum,QtConcurrent::SequentialReduce);

17、template <typename Sequence, typename MapFunctor> QFuture<void> map(Sequence &sequence, MapFunctor function)

按顺序为每个项目调用一次 function。该函数传递了对项目的引用，因此对项目所做的任何修改都将按顺序显示。

    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    QtConcurrent::map(list,[](int & i)
    {
        ++i;
    });

    QThread::msleep(1000);
    qDebug()<<list;

 

18、template <typename Iterator, typename MapFunctor> QFuture<void> map(Iterator begin, Iterator end, MapFunctor function)

重载函数。

19、template <typename Sequence, typename MapFunctor> QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(const Sequence &sequence, MapFunctor function)

按顺序为每个项目调用一次 function ，并作为结果返回到QFuture。可以使用 QFuture::const_iterator 或 QFutureIterator 来迭代结果。

function 的参数类型必须是常引用。

QString run1(const int & i)
{
    return QString("we get %1").arg(i);
}

int main(int argc, char *argv[])
{
    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    QFuture<QString> result = QtConcurrent::mapped(list,run1);
    result.waitForFinished();

    qDebug()<<result.results();
    for (auto it = result.constBegin();it != result.constEnd();++it)
    {
        qDebug()<<*it;
    }

    QFutureIterator<QString> it(result);
    while (it.hasNext())
    {
        qDebug()<<it.peekNext()<<it.next();
    }
}

20、template <typename Iterator, typename MapFunctor> QFuture<typename QtPrivate::MapResultType<void, MapFunctor>::ResultType> mapped(Iterator begin, Iterator end, MapFunctor function)

重载函数。

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

按顺序为每个项目调用一次 mapFunction。 每个 mapFunction 的返回值传递给 reduceFunction。

请注意，虽然 mapFunction 是并发调用的，但一次只有一个线程会调用 reduceFunction。

调用reduceFunction 的顺序由reduceOptions 决定。

void sum(int& result ,int i)
{
    qDebug()<<"result = "<<result <<"i = "<<i<<"线程Id："<<QThread::currentThreadId();
    result += i;
}

int plus(const int & i)
{
    qDebug()<<"plus() 线程Id："<<QThread::currentThreadId();

    return i + 10;
}

int main(int argc, char *argv[])
{
    QList<int> list;
    for (int i = 1;i < 12;++i)
    {
        list << i;
    }

    QFuture<int> result = QtConcurrent::mappedReduced(list,plus,sum,QtConcurrent::SequentialReduce);
    qDebug()<<result;
}

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

重载函数。

23、template <typename T> QFuture<T> run(Function function, ...)

等同于：

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

在单独的线程中运行函数。该线程取自全局 QThreadPool。请注意，该函数可能不会立即运行，函数只会在线程可用时运行。

T 与函数的返回值类型相同。

void debug(const QString & str)
{
    qDebug()<<"string = "<<str;
}

int main(int argc, char *argv[])
{
    QFuture<void> result = QtConcurrent::run(debug,QString("xx"));
    result.waitForFinished();

    result = QtConcurrent::run(QThreadPool::globalInstance(),debug,QString("xx"));
    result.waitForFinished();

    result = QtConcurrent::run([](const QString & str)
    {
        qDebug()<<"string = "<<str;
    },QString("xx"));
    result.waitForFinished();
}

如果是重载函数不能直接运行。

 void foo(int arg);
 void foo(int arg1, int arg2);
 ...
 QFuture<void> future = QtConcurrent::run(foo, 42);

以上代码会报错。运行重载函数有三种方法：

QFuture<void> future = QtConcurrent::run([] { foo(42); });  //1

QFuture<void> future = QtConcurrent::run(static_cast<void(*)(int)>(foo), 42);  //2

QFuture<void> future = QtConcurrent::run(qOverload<int>(foo), 42);  //3

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

在单独的线程中运行函数。该线程取自 QThreadPool 池。 请注意，该函数可能不会立即运行，函数只会在线程可用时运行。

T 与函数的返回值类型相同。

友善啊，朋友
关注
专栏目录
QT所有命名空间
希望我的博客，能帮上你解决学习中工作中所遇到的问题
11-30 923
这是Qt中主要名称空间的列表。 ABI :: Windows :: Media :: Capture org :: freedesktop :: DBus ABI :: Windows :: Media :: Devices ABI :: Windows :: Devices :: Enumeration ABI :: Windows :: Foundation QV4 :: JIT :: Helpers Qt3DLogic :: Logic ABI :: Windows :: Media QAudio
Qt 之 Concurrent Run
小米的修行之路
10-30 3349
 我觉得QtConcurrent有个很霸气的介绍。用谷歌翻译如下：“QtConcurrent命名空间提供了高级API，可以在不使用低级线程原语的情况下编写多线程程序”。不知道什么叫高级，我觉得应该是指使用时不关心底层多线程的实现而显得高层次吧。本想概括一下QtConcurrent的使用步骤，奈何发现QtConcurrent根本就不是个东西啊，它只不过是个命名空间。真正发挥作用的是该命名空间下定义的...
Qt命名空间 Qt namespace
01-18
讲述Qt命名空间怎么用，文章地址：https://lizhifun.blog.csdn.net/article/details/112584777
Qt之Concurrent框架
weixin_34309543的博客
07-29 1129
简述 QtConcurrent 命名空间提供了高级 API，使得可以在不使用低级线程原语（例如：互斥、读写锁、等待条件或信号量）的情况下编写多线程程序，使用 QtConcurrent 编写的程序根据可用的处理器核心数自动调整所使用的线程数。这意味着，当在未来部署多核系统时，现在编写的应用程序将继续适应。 简述 用法 Qt C...
Qt 多线程 事件同步 QtConcurrent
最新发布
qq_40094716的博客
09-05 1011
之前使用的Qthread，通过继承Qthrad 再重写run函数实现。 但是使用时不是很方便设计，经过了解Qt推荐使用QtConcurrent。 下面就简单的介绍一下，注意本文均个人的理解并非官方，内容仅供参考。 同时欢迎指正和补充。
QT命名空间详解
m0_47037246的博客
08-31 623
QT是一个跨平台的C++应用程序框架，它使用了大量的命名空间以及库函数。在编写QT程序时，理解QT的命名空间是非常重要的，因为它可以帮助我们正确使用QT的功能。QtWidgets命名空间拥有许多高级的UI组件，如QMainWindow、QMessageBox，以及一些常用的模态框。Qt命名空间是所有Qt类和函数的根命名空间。QtGui命名空间包含了和窗口系统相关的类，如QWidget、QPainter，以及其他的一些UI部件。正确使用QT的命名空间可以帮助我们更好地编写高效、可靠的程序。
Qt基础之十六：QtConcurrent和QThreadPool
草上爬的博客
01-02 5726
QtCurrent模块能处理一些常见的并行计算：map、filter和reduce。它们返回一个QFuture对象，该对象可用于获取函数执行的结果。QFuture还可用于查询计算进度和暂停/恢复/取消计算。为了方便起见，QFutureWatcher可以通过信号和插槽与QFuture进行交互。QtCurrent的map、filter和reduce算法自动将计算分布到所有可用的处理器核上，因此，当QtCurrent在多核系统上更有优势。
【Qt】Qt再学习（九）：并发 QtConcurrent、QFuture、QFutureWatcher
郭老二
12-07 1804
1、QtConcurrent 该QtConcurrent命名空间提供高层次的API，使人们有可能不写使用低级线程原语的多线程程序，如互斥，读写锁，等待条件或信号。用QtConcurrent编写的程序会根据可用处理器内核的数量自动调整使用的线程数。这意味着，当将来在多核系统上部署时，今天编写的应用程序将继续扩展。 1.1 并发映射 1.1.1 QtConcurrent::map()将函数应用于容器中的每个项目，批量修改每个项目本身。 例如，批量对图片进行缩放： void scale(QImage &i
使用QtConcurrent编写多线程程序
03-26 4452
Qt在其QtConcurrent命名空间中为我们提供了编写多线程程序的高级API，使用这个API可以使我们在不使用低级的线程元素，如互斥锁，读写锁，条件变量或者信号量的情况下编写出搞笑的多线程程序。并且，使用QtConcurrent编写的程序能够自动地根据当前可以使用的处理器核心数调整实际使用的线程数目。这就意味着我们目前所写的程序即使将来的多核心机器上也能正常运行，并有很好的伸缩性。 QtCo
Qt多线程之QtConcurrent
fearlazy
06-25 1303
文章可能被更新，最新地址：http://www.fearlazy.com/index.php/post/94.html 我觉得QtConcurrent有个很霸气的介绍。用谷歌翻译如下：“QtConcurrent命名空间提供了高级API，可以在不使用低级线程原语的情况下编写多线程程序”。不知道什么叫高级，我觉得应该是指使用时不关心底层多线程的实现而显得高层次吧。本想概括一下QtC...
Qt Concurrent
lsz441的博客
12-06 264
QtConcurrent命名空间提供了高级api，使编写多线程程序成为可能，而无需使用低级线程原语，如互斥锁、读写锁、等待条件或信号量。用QtConcurrent编写的程序会根据可用处理器内核的数量自动调整所使用的线程数。这意味着今天编写的应用程序在未来部署到多核系统时将继续可扩展。QtConcurrent包括用于并行列表处理的函数式编程风格api，包括用于共享内存(非分布式)系统的MapReduce和FilterReduce实现，以及在GUI应用程序中管理异步计算的类:map函数将函数应用到容器中的每个项
QtConcurrent
program is a art
05-26 239
当我们想在一个或多个辅助线程执行的同时做一些后台处理且无须使用QThread所提供的全部功能和灵活性时,就可以使用QRunnable和QtConcurrent::run()方法. QtConcurrent::run()函数的参数包含一个函数,一个或多个传递给函数的可选参数,它会在Qt全局线程池中的一个辅助线程中执行该函数 使用无阻塞QtConcurrent函数涉及到一些建立辅助线程的开...
c++/qt命名空间分析
biao2488890051的博客
03-15 2033
c语言防止标识符同名冲突： 函数写在不同.c文件内 c++用命名空间来进一步防止同名冲突： 函数写在不同.c文件内 不同的类里 写在不同的命名空间namespace里 命名空间定义： namespace Ui { class MainWindow; //命名空间内可以放变量，函数，结构体，类等等 } 外部使用MainWindow类： Ui：：MainWindow方式。 在使用者源码文件开头，using namespace Ui；，这样就可以直接使用该命名空间 Ui 中的内容了，M
Qt知识点梳理 —— NameSpace命名空间
2301_78399805的博客
04-16 1243
C++中，命名空间使用namespace来声明，并使用{ }来界定命名空间的作用域，例如：int age=18;标准命名空间C++中标准命名空间std，std 是 standard 的缩写，意思是“标准命名空间”；C++标准库中的函数或者对象都是在命名空间std中定义的；Qt中有自带namespace：新建一个带窗体的项目都可以看到；使用命名空间1、在程序头部引用命名空间，如：2、在引用变量或方法时加上命名空间，如：Qt自定义命名空间。
Qt之QtConcurrent
热门推荐
weixin_41504987的博客
04-27 1万+
一 什么是QtConcurrent？ Concurrent是并发的意思，而QtConcurrent同std一样，是一个命名空间（namespace）。提供了一些高级的 API，使得在编写多线程的时候，无需使用低级线程原语，如读写锁，等待条件或信号。使用QtConcurrent编写的程序会根据可用的处理器内核数自动调整使用的线程数。 对于QtConcurrent真正要学习的是该命名空间下定义的函数。下面要讲的就是QtConcurrent::run函数的使用方法。 二 QtConcurrent::run(
Qt 之 QtConcurrent
hu的博客
03-30 1113
本文以 Qt 中的 QtConcurrent::run() 函数为例，介绍如何将函数运行在单独的某一个线程中。1  QtConcurrent::run()  QtConcurrent 是一个命名空间，它提供了高层次的函数接口 (APIs)，使得编写的程序，可根据当前计算机中实际的 CPU 核数，自动调整运行的线程数目。  下面是 Qt 中的自带例程 runfunction，对应于安装目录为  D:...
qtconcurrent
04-03
QtConcurrent是Qt框架中的一个并发编程模块，它提供了一种简单的方式来实现并行计算和多线程操作。使用QtConcurrent模块可以方便地在Qt应用程序中进行并发编程。 以下是两种使用QtConcurrent模块的例子： 1. 运行外部函数[^1] ```cpp #include <QtConcurrent/QtConcurrent> void aFunction() { // 在这里编写你的函数逻辑 } int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); // 运行外部函数 QtConcurrent::run(aFunction); return a.exec(); } ``` 2. 运行成员函数 ```cpp #include <QtConcurrent/QtConcurrent> class MyClass : public QObject { Q_OBJECT public slots: void myFunction() { // 在这里编写你的函数逻辑 } }; int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); MyClass myObject; // 运行成员函数 QtConcurrent::run(&myObject, &MyClass::myFunction); return a.exec(); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值