このページでは

QPromise Class

template <typename T> class QPromise

QPromise クラスは、QFuture からアクセスされる計算結果を保存する手段を提供します。詳細...

ヘッダー: #include <QPromise>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
以下のように: Qt 6.0以降

注:このクラスのすべての関数はスレッドセーフです。

パブリック関数

QPromise()
QPromise(const QPromise<T> &)
QPromise(QPromise<T> &&other)
~QPromise()
bool addResult(T &&result, int index = -1)
bool addResult(const T &result, int index = -1)
(since 6.6) bool addResults(const QList<T> &results)
(since 6.6) bool emplaceResult(Args &&... args)
(since 6.6) bool emplaceResultAt(int index, Args &&... args)
void finish()
QFuture<T> future() const
bool isCanceled() const
void setException(const QException &e)
void setException(std::__exception_ptr::exception_ptr e)
void setProgressRange(int minimum, int maximum)
void setProgressValue(int progressValue)
void setProgressValueAndText(int progressValue, const QString &progressText)
void start()
void suspendIfRequested()
void swap(QPromise<T> &other)
QPromise<T> &operator=(QPromise<T> &&other)
QPromise<T> &operator=(const QPromise<T> &)

詳細な説明

QPromise はテンプレートクラスであり、テンプレートパラメータT によって、QFuture を通じて保存および後でアクセスできる結果の型が指定されます。

QPromise は、ユーザー定義の計算の進行状況や結果を、非同期的にQFuture に伝達する簡単な方法を提供します。この通信を機能させるには、QFuture を QPromise によって構築する必要があります。

QPromise ベースのワークロードは、 Qt Concurrent フレームワークの代替として、きめ細かな制御が必要な場合や、QFuture に付随する高レベルの通信プリミティブで十分な場合に、QPromise ベースのワークロードを使用できます。

Promise と Future の連携の最も単純な例は、単一の結果の通信です:

    QPromise<int> promise;
    QFuture<int> future = promise.future();

    const std::unique_ptr<QThread> thread(QThread::create([] (QPromise<int> promise) {
        promise.start();   // notifies QFuture that the computation is started
        promise.addResult(42);
        promise.finish();  // notifies QFuture that the computation is finished
    }, std::move(promise)));
    thread->start();

    future.waitForFinished();  // blocks until QPromise::finish is called
    future.result();  // returns 42

設計上、QPromise は移動専用(move-only)のオブジェクトです。この挙動により、プロミスが破棄されるたびに、関連付けられたフューチャーオブジェクトに通知が行われ、結果が利用可能になるのを無限に待ち続けることがなくなります。しかし、異なるスレッドからの結果を報告するために同じプロミスを使用したい場合、これは不便です。 現時点ではこれを行うための特定の方法はありませんが、スマートポインタや生ポインタ/参照の使用など、既知のメカニズムが存在します。QSharedPointer は、プロミスをコピーして複数の場所で同時に使用したい場合の、優れたデフォルトの選択肢です。 生ポインタや参照は、ある意味ではより簡単で、おそらくパフォーマンスも優れています(リソース管理を行う必要がないため)が、ダングリングを引き起こす可能性があります。

以下に、複数のスレッドでプロミスを使用する方法の例を示します:

    const auto sharedPromise = std::make_shared<QPromise<int>>();
    QFuture<int> future = sharedPromise->future();

    // ...

    sharedPromise->start();

    // here, QPromise is shared between threads via a smart pointer
    const std::unique_ptr<QThread> threads[] = {
        std::unique_ptr<QThread>(QThread::create([] (auto sharedPromise) {
            sharedPromise->addResult(0, 0);  // adds value 0 by index 0
        }, sharedPromise)),
        std::unique_ptr<QThread>(QThread::create([] (auto sharedPromise) {
            sharedPromise->addResult(-1, 1);  // adds value -1 by index 1
        }, sharedPromise)),
        std::unique_ptr<QThread>(QThread::create([] (auto sharedPromise) {
            sharedPromise->addResult(-2, 2);  // adds value -2 by index 2
        }, sharedPromise)),
        // ...
    };
    // start all threads
    for (auto& t : threads)
        t->start();

    // ...

    future.resultAt(0);  // waits until result at index 0 becomes available. returns value  0
    future.resultAt(1);  // waits until result at index 1 becomes available. returns value -1
    future.resultAt(2);  // waits until result at index 2 becomes available. returns value -2

    sharedPromise->finish();

QFutureも参照してください 。

メンバ関数のドキュメント

[default] QPromise::QPromise()

デフォルトの状態を持つQPromiseを生成します。

[delete] QPromise::QPromise(const QPromise<T> &)

QPromise のインスタンスをコピーして生成します。この関数は削除されています。

[default] QPromise::QPromise(QPromise<T> &&other)

Moveは、other から新しいQPromiseを生成します。

operator=()も参照してください 。

QPromise::~QPromise()

プロミスを破棄します。

注: ユーザーが事前に `finish()` を呼び出さない限り、プロミスはその 破棄時に暗黙的にキャンセルされた状態に移行します。

bool QPromise::addResult(T &&result, int index = -1)

bool QPromise::addResult(const T &result, int index = -1)

以下と同じ

emplaceResultAt(index, result);            // first overload
emplaceResultAt(index, std::move(result)); // second overload

あるいは、index == -1 (デフォルト)の場合

emplaceResult(result);            // first overload
emplaceResult(std::move(result)); // second overload

emplaceResultAt()、emplaceResult()、およびaddResults()も参照してください 。

[since 6.6] bool QPromise::addResults(const QList<T> &results)

内部の結果コレクションの末尾にresults を追加します。

results がコレクションに追加された場合、true を返します。

このプロミスが「canceled」または「finished」の状態にある場合、false を返します。

これは、addResult() をループ処理するよりも効率的です。なぜなら、個別のaddResult() を呼び出す場合のようにresults に含まれる要素ごとに通知されるのではなく、addResults() の呼び出しごとに 1 回だけ関連付けられたフューチャーに通知されるからです。 ただし、各要素の計算に時間がかかる場合、受信側(フューチャー)のコードはすべての結果が報告されるまで処理を進めることができないため、連続する要素の計算が比較的高速な場合にのみ、この関数を使用してください。

この関数は Qt 6.6 で導入されました。

addResult()も参照してください 。

[since 6.6] template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args...>, bool> = true> bool QPromise::emplaceResult(Args &&... args)

[since 6.6] template <typename... Args, std::enable_if_t<std::is_constructible_v<T, Args...>, bool> = true> bool QPromise::emplaceResultAt(int index, Args &&... args)

args... から構築された結果を、index の位置 (emplaceResultAt()) またはコレクションの末尾 (emplaceResult()) に追加します。

結果がコレクションに追加された場合、true を返します。

このプロミスがキャンセルまたは完了状態にある場合、または結果が拒否された場合、false を返します。addResult() は、コレクション内の同じインデックスにすでに別の結果が格納されている場合、結果の追加を拒否します。

これらの関数は、T が以下から構築可能な場合にのみ、オーバーロードの解決に関与します。args....

QFuture::resultAt() を呼び出すことで、特定のインデックスにある結果を取得できます。

注: 任意のインデックスを指定し、そのインデックスの結果を要求することは可能です 。ただし、一部の `QFuture ` メソッドは連続した結果を扱うように設計されています。例えば、QFuture::resultCount() やQFuture::const_iterator を使用する反復処理などが挙げられます。インデックスのギャップの有無を気にすることなく、利用可能なすべての結果を取得するには、QFuture::results() を使用してください。

これらの関数は Qt 6.6 で導入されました。

addResult() およびaddResults()も参照してください 。

void QPromise::finish()

計算が完了したことを報告します。完了後は、addResult() を呼び出しても新しい結果は追加されません。このメソッドは、start() と組み合わせて使用されます。

QFuture::isFinished()、QFuture::waitForFinished()、およびstart()も参照してください 。

QFuture<T> QPromise::future() const

このプロミスに関連付けられたフューチャーを返します。

bool QPromise::isCanceled() const

QFuture::cancel() 関数によって計算がキャンセルされたかどうかを返します。戻り値がtrue の場合、計算を完了させ、finish()を呼び出す必要があることを示します。

注:キャンセル後も 、現在利用可能な結果には引き続きアクセスできますが、addResult() を呼び出した際に新しい結果が追加されることはありません。

void QPromise::setException(const QException &e)

e 例外を計算結果として設定します。

注: 計算の実行全体を通じて、設定できる例外は最大1つまでです 。

注:この メソッドは 、QFuture::cancel() またはfinish() の実行後は効果を持ちません。

関連項目: isCanceled()。

void QPromise::setException(std::__exception_ptr::exception_ptr e)

これはオーバーロードされた関数です。

void QPromise::setProgressRange(int minimum, int maximum)

計算の進行範囲をminimum からmaximum の間に設定します。

maximum がminimum より小さい場合、minimum が唯一の有効な値となります。

進行状況の値はminimum にリセットされます。

setProgressRange(0, 0) を使用することで、進行状況範囲の使用を無効にできます。この場合、進行状況の値も 0 にリセットされます。

QFuture::progressMinimum()、QFuture::progressMaximum()、およびQFuture::progressValue()も参照してください 。

void QPromise::setProgressValue(int progressValue)

計算の進行状況をprogressValue に設定します。進行状況の値は増加させることのみ可能です。これは、setProgressValueAndText(progressValue, QString())を呼び出すための便宜的なメソッドです。

progressValue が進行範囲外になった場合、このメソッドは効果を発揮しません。

QFuture::progressValue() およびsetProgressRange()も参照してください 。

void QPromise::setProgressValueAndText(int progressValue, const QString &progressText)

計算の進行状況値と進行状況テキストを、それぞれ `progressValue ` および `progressText ` に設定します。進行状況値のみをインクリメントすることも可能です。

注:この関数は 、プロミスが「canceled」または「finished」の状態にある場合は効果を発揮しません。

関連項目: QFuture::progressValue()、QFuture::progressText()、QFuture::cancel()、およびfinish()。

void QPromise::start()

計算が開始されたことを報告します。QFuture メソッドはこの情報に依存しているため、計算の開始を明示するには、このメソッドを呼び出すことが重要です。

注: 新しく作成されたスレッドから start() を呼び出す場合は、特に 注意が必要です。そのような場合、スレッドスケジューリングの実装の詳細により、呼び出しが自然に遅延する可能性があります。

関連項目: QFuture::isStarted()、QFuture::waitForFinished()、およびfinish()。

void QPromise::suspendIfRequested()

現在の実行スレッドを条件付きで一時停止し、QFuture の対応するメソッドによって再開またはキャンセルされるまで待機します。このメソッドは、QFuture::suspend() またはその他の関連メソッドによって計算の一時停止が要求されない限り、ブロックしません。実行が一時停止されたことを確認したい場合は、QFuture::isSuspended() を使用してください。

注: 同じプロミスを複数のスレッドで使用している場合 、プロミスを保持するスレッドのうち少なくとも1つが中断すると、QFuture::isSuspended() は直ちにtrue になります。

以下のコードスニペットは、一時停止メカニズムの使用例を示しています:

    // Create promise and future
    QPromise<int> promise;
    QFuture<int> future = promise.future();

    promise.start();
    // Start a computation thread that supports suspension and cancellation
    const std::unique_ptr<QThread> thread(QThread::create([] (QPromise<int> promise) {
        for (int i = 0; i < 100; ++i) {
            promise.addResult(i);
            promise.suspendIfRequested();   // support suspension
            if (promise.isCanceled())       // support cancellation
                break;
        }
        promise.finish();
    }, std::move(promise)));
    thread->start();

QFuture::suspend() は、関連付けられたプロミスの実行を一時停止するよう要求します:

    future.suspend();

QFuture::isSuspended() がtrue になると、中間結果を取得できるようになります:

    future.resultCount();  // returns some number between 0 and 100
    for (int i = 0; i < future.resultCount(); ++i) {
        // process results available before suspension
    }

一時停止中は、待機中の計算を再開またはキャンセルできます:

    future.resume();  // resumes computation, this call will unblock the promise
    // alternatively, call future.cancel() to stop the computation

    future.waitForFinished();
    future.results();  // returns all computation results - array of values from 0 to 99

QFuture::resume()、QFuture::cancel()、QFuture::setSuspended()、およびQFuture::toggleSuspended()も参照してください 。

[noexcept] void QPromise::swap(QPromise<T> &other)

このプロミスを `other` に置き換えます。この操作は非常に高速で、失敗することはありません。

[noexcept] QPromise<T> &QPromise::operator=(QPromise<T> &&other)

Moveは、other をこのプロミスに割り当て、このプロミスへの参照を返します。

[delete] QPromise<T> &QPromise::operator=(const QPromise<T> &)

other をこのQPromise インスタンスにコピー・代入します。この関数は削除されます。

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