Bibliothèque standard C++<future>

Introduit en C++11<future>Le fichier d'en-tête fournit un mécanisme de programmation asynchrone, permettant au programme de continuer à exécuter d'autres tâches pendant qu'il attend la fin d'une opération.<future>La bibliothèque fait partie de la programmation concurrente dans la bibliothèque standard C++, permettant aux programmeurs de gérer les opérations asynchrones de manière plus concise et plus sûre.

<future>La bibliothèque définit plusieurs types clés :

  • std::future: Représente le résultat d'une opération asynchrone, permettant d'interroger l'état de l'opération, de récupérer le résultat ou d'attendre la fin de l'opération.
  • std::promise: utilisé avecstd::futureassocié, utilisé pour définir le résultat des opérations asynchrones.
  • std::packaged_task: encapsule une fonction ou un objet appelable afin qu'il puisse être exécuté comme une tâche asynchrone.

std::promise

std::promiseUtilisé pour définir le résultat des opérations asynchrones. Il est associé àstd::futureutilisés par paires.

Exemple

#include <iostream>
#include <future>

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    // Définir le résultat dans un autre thread
    std::thread t([prom]() {
        prom.set_value(10);
    });

    // Attendre le résultat
    std::cout << "Valeur future : " << fut.get() << std::endl;

    t.join();
    return 0;
}

Résultat de sortie :

Future value: 10

std::packaged_task

std::packaged_taskEncapsule une fonction ou un objet appelable afin qu'il puisse être exécuté comme une tâche asynchrone.

Exemple

#include <iostream>
#include <future>
#include <cmath>

int compute_square_root(double x) {
    return std::sqrt(x);
}

int main() {
    std::packaged_task<double(double)> task(compute_square_root);
    std::future<double> result = task.get_future();
    std::thread th(std::move(task), 9.0);

    std::cout << "Result: " << result.get() << std::endl;
    th.join();
    return 0;
}

Résultat de sortie :

Result: 3

std::async

std::asyncEst une fonction pratique pour lancer des tâches asynchrones. Elle peut immédiatement renvoyer unstd::futureObjet.

Exemple

#include <iostream>
#include <future>

int main() {
    std::future<int> fut = std::async(std::launch::async, [](int x) {
        return x * x;
    }, 5);

    std::cout << "Résultat : " << fut.get() << std::endl;
    return 0;
}

Résultat de sortie :

Result: 25

Gestion des exceptions

Lorsqu'une opération asynchrone lève une exception,std::futureInterceptera cette exception, et peut, en appelant.get()la méthode pour la relancer.

Exemple

#include <iostream>
#include <future>

void throw_exception() {
    throw std::runtime_error("Exception levée");
}

int main() {
    std::future<void> fut = std::async(throw_exception);

    try {
        fut.get();
    } catch (const std::exception& e) {
        std::cout << "Exception interceptée : " << e.what() << std::endl;
    }
    return 0;
}

Résultat de sortie :

Caught exception: Exception thrown

<future>La bibliothèque fournit aux programmeurs C++ un moyen simple et puissant de programmation asynchrone. En utilisantstd::promise、std::packaged_tasketstd::async, nous pouvons facilement implémenter des opérations concurrentes et asynchrones dans les programmes C++. Par ailleurs, le mécanisme de gestion des exceptions garantit également la robustesse du programme.

autres extensions