C++-Standardbibliothek<future>

In C++11 eingeführt<future>Die Headerdatei bietet einen Mechanismus für die asynchrone Programmierung, der es dem Programm ermöglicht, während des Wartens auf den Abschluss einer Operation weiterhin andere Aufgaben auszuführen.<future>Die Bibliothek ist Teil der nebenläufigen Programmierung in der C++-Standardbibliothek und ermöglicht Programmierern, asynchrone Vorgänge auf eine prägnantere und knappere Weise zu handhaben.

<future>Die Bibliothek bietet mehrere Schlüsseltypen:

  • std::future: Repräsentiert das Ergebnis einer asynchronen Operation und ermöglicht es Ihnen, den Status der Operation abzufragen, das Ergebnis abzurufen oder auf den Abschluss der Operation zu warten.
  • std::promise: verwendet mitstd::futuregekoppelt, wird verwendet, um das Ergebnis asynchroner Operationen festzulegen.
  • std::packaged_task: Umschließt eine Funktion oder ein aufrufbares Objekt, sodass es als asynchrone Aufgabe ausgeführt werden kann.

std::promise

std::promiseWird verwendet, um das Ergebnis asynchroner Operationen festzulegen. Es ist gepaart mitstd::futurein Paaren verwendet.

Beispiel

#include <iostream>
#include <future>

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

    // Das Ergebnis in einem anderen Thread setzen
    std::thread t([prom]() {
        prom.set_value(10);
    });

    // Auf das Ergebnis warten
    std::cout << "Future value: " << fut.get() << std::endl;

    t.join();
    return 0;
}

Ausgabeergebnis:

Future value: 10

std::packaged_task

std::packaged_taskVerpackt eine Funktion oder ein aufrufbares Objekt, sodass es als asynchrone Aufgabe ausgeführt werden kann.

Beispiel

#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 << "Ergebnis: " << result.get() << std::endl;
    th.join();
    return 0;
}

Ausgabeergebnis:

Result: 3

std::async

std::asyncIst eine praktische Funktion zum Starten asynchroner Aufgaben. Sie kann sofort einstd::futureObjekt.

Beispiel

#include <iostream>
#include <future>

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

    std::cout << "Result: " << fut.get() << std::endl;
    return 0;
}

Ausgabeergebnis:

Result: 25

Ausnahmebehandlung

Wenn eine asynchrone Operation eine Ausnahme auslöst,std::futureWird diese Ausnahme abfangen und kann durch Aufrufen.get()Methode, um sie erneut auszulösen.

Beispiel

#include <iostream>
#include <future>

void throw_exception() {
    throw std::runtime_error("Exception thrown");
}

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

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

Ausgabeergebnis:

Caught exception: Exception thrown

<future>Die Bibliothek bietet C++-Programmierern eine einfache und leistungsstarke Möglichkeit für asynchrone Programmierung. Durch die Verwendungstd::promise、std::packaged_taskundstd::async, können wir in C++-Programmen leicht nebenläufige und asynchrone Operationen implementieren. Der Mechanismus zur Ausnahmebehandlung gewährleistet außerdem die Robustheit des Programms.

Weitere Erweiterungen