std::future

[]

This page has been machine-translated from the English version of the wiki using Google Translate. The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here. Click here for the English version of this page

• Une opration asynchrone (cre via std::async, std::packaged_task ou std::promise) peut fournir un objet std::future au crateur de cette opration asynchrone .

  Original:

  An asynchronous operation (created via std::async, std::packaged_task, or std::promise) can provide a std::future object to the creator of that asynchronous operation.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Le crateur de l'opration asynchrone peut alors utiliser plusieurs mthodes pour demander une valeur, l'attendre, ou l'extraire de la std::future. Ces mthodes peuvent bloquer si l'opration asynchrone n'a pas encore fourni une valeur .

  Original:

  The creator of the asynchronous operation can then use a variety of methods to query, wait for, or extract a value from the std::future. These methods may block if the asynchronous operation has not yet provided a value.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

• Lorsque l'opration asynchrone est prte envoyer un rsultat au crateur, il peut utiliser l'tat partag (par exemple std::promise::set_value) qui est lie au std::future du crateur .

  Original:

  When the asynchronous operation is ready to send a result to the creator, it can do so by modifying shared state (e.g. std::promise::set_value) that is linked to the creator's std::future.

  The text has been machine-translated via Google Translate.
  You can help to correct and verify the translation. Click here for instructions.

Fonctions membres

Exemple

#include <iostream>
#include <future>
#include <thread>

int main()
{
    // future depuis un packaged_task
    std::packaged_task<int()> task([](){ return 7; }); // wrap the function
    std::future<int> f1 = task.get_future();  // get a future
    std::thread(std::move(task)).detach(); // launch on a thread

    // future depuis un async()
    std::future<int> f2 = std::async(std::launch::async, [](){ return 8; });

    // future depuis un promise
    std::promise<int> p;
    std::future<int> f3 = p.get_future();
    std::thread( [](std::promise<int>& p){ p.set_value(9); }, 
                 std::ref(p) ).detach();

    std::cout << "En attente...";
    f1.wait();
    f2.wait();
    f3.wait();
    std::cout << "Fait!\nLes resultats sont: "
              << f1.get() << ' ' << f2.get() << ' ' << f3.get() << '\n';
}

En attente...Fait!
Les rsultats sont: 7 8 9

Voir aussi