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 opération asynchrone (créée via std::async, std::packaged_task ou std::promise) peut fournir un objet std::future au créateur de cette opération 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 créateur de l'opération asynchrone peut alors utiliser plusieurs méthodes pour demander une valeur, l'attendre, ou l'extraire de la std::future. Ces méthodes peuvent bloquer si l'opération 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'opération asynchrone est prête à envoyer un résultat au créateur, il peut utiliser l'état partagé (par exemple std::promise::set_value) qui est liée au std::future du créateur .

  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.

[modifier] Fonctions membres

[modifier] 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 résultats sont: 7 8 9

[modifier] Voir aussi