Qu'est-ce que std::future en C++?

std::future — c’est une classe modèle en C++ représentant le résultat (valeur ou exception) d’une opération asynchrone, qui sera disponible à l’avenir. Elle est utilisée pour obtenir le résultat de l’exécution d’une tâche lancée dans un thread séparé ou via std::async.

Caractéristiques principales :

• Asynchronie : Permet d’effectuer une opération sans bloquer le thread actuel.
• Obtention du résultat : La méthode get() permet d’obtenir le résultat. Si le résultat n’est pas encore prêt, get() bloquera le thread jusqu’à ce qu’il le soit ou qu’une exception soit levée.
• Transmission de données : Associée à un objet std::promise, qui fournit un moyen de définir le résultat ou une exception.
• État : std::future possède un état indiquant si le résultat est prêt. Peut être vérifié avec wait() ou wait_for().
• Obtention unique : La méthode get() ne peut être appelée qu’une seule fois par objet std::future.
• Type de résultat : Typé par le type de la valeur retournée par l’opération asynchrone.

Exemple d’utilisation avec std::async :

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

int calculate_something() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
}

// Exemple d’utilisation de std::future avec std::async
int main() {
    // Lance une opération asynchrone
    std::future<int> result_future = std::async(std::launch::async, calculate_something);

    // Effectue une autre tâche pendant que l’opération est en cours
    std::cout << "Faisons autre chose..." << std::endl;

    // Récupère le résultat (bloque si pas encore prêt)
    int result = result_future.get();
    std::cout << "Le résultat est : " << result << std::endl;

    return 0;
}

Exemple d’utilisation avec std::promise :

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

void worker_function(std::promise<int> promise_obj) {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    // Définit le résultat
    promise_obj.set_value(123);
}

// Exemple d’utilisation de std::future avec std::promise
int main() {
    // Crée un promise et un future
    std::promise<int> promise_obj;
    std::future<int> future_obj = promise_obj.get_future();

    // Lance un worker dans un thread séparé, en passant le promise
    std::thread worker_thread(worker_function, std::move(promise_obj));

    // Effectue une autre tâche pendant que le worker travaille
    std::cout << "Faisons autre chose..." << std::endl;

    // Récupère le résultat (bloque si pas encore prêt)
    int result = future_obj.get();
    std::cout << "Résultat du worker : " << result << std::endl;

    // Attend la fin du thread worker
    worker_thread.join();

    return 0;
}

Méthodes importantes de std::future :

Méthode	Description
get()	Obtient le résultat. Bloque si le résultat n’est pas encore prêt. Peut être appelée une seule fois.
valid()	Vérifie si std::future est associé à une opération asynchrone en cours.
wait()	Bloque le thread actuel jusqu’à ce que le résultat soit disponible (ou qu’une exception soit levée).
wait_for()	Attend le résultat pendant une durée spécifiée. Retourne l’état d’attente.
wait_until()	Attend le résultat jusqu’à un moment précis dans le temps. Retourne l’état d’attente.

std::future fait partie de la bibliothèque <future> et offre un moyen pratique de gérer les résultats de calculs asynchrones, simplifiant le développement d’applications multithread.