Namespaces
Variants

std:: coroutine_handle, std:: noop_coroutine_handle

From cppreference.net
C++
Utilities library
Coroutine support
Coroutine traits
(C++20)
Coroutine handle
coroutine_handle
(C++20)
No-op coroutines
(C++20)
(C++20)
Trivial awaitables
(C++20)
(C++20)
Range generators
(C++23)
std::coroutine_handle
Défini dans l'en-tête <coroutine>
template < class Promise = void >
struct coroutine_handle ;
(1) (depuis C++20)
template <>
struct coroutine_handle < void > ;
(2) (depuis C++20)
template <>
struct coroutine_handle < std:: noop_coroutine_promise > ;
(3) (depuis C++20)
using noop_coroutine_handle =
std :: coroutine_handle < std:: noop_coroutine_promise > ;
(4) (depuis C++20)

Le modèle de classe coroutine_handle peut être utilisé pour faire référence à une coroutine suspendue ou en cours d'exécution. Chaque spécialisation de coroutine_handle est un LiteralType .

1) Modèle principal, peut être créé à partir de l'objet promesse de type Promise .
2) Spécialisation std :: coroutine_handle < void > efface le type de promesse. Elle est convertible à partir d'autres spécialisations.
3) Spécialisation std :: coroutine_handle < std:: noop_coroutine_promise > fait référence aux coroutines sans opération. Elle ne peut pas être créée à partir d'un objet promise.

Sur les implémentations typiques, chaque spécialisation de std::coroutine_handle est TriviallyCopyable .

Si le programme ajoute des spécialisations pour std::coroutine_handle , le comportement est indéfini.

Table des matières

Membres de données

Nom du membre Définition
ptr (privé) Un pointeur void * vers l'état de la coroutine.
( objet membre d'exposition uniquement* )

Fonctions membres

construit un objet coroutine_handle
(fonction membre publique)
assigne l'objet coroutine_handle
(fonction membre publique)
Conversion
obtient un coroutine_handle avec effacement de type
(fonction membre publique)
Observateurs
vérifie si la coroutine est terminée
(fonction membre publique)
vérifie si le handle représente une coroutine
(fonction membre publique)
Contrôle
reprend l'exécution de la coroutine
(fonction membre publique)
détruit une coroutine
(fonction membre publique)
Accès à la promesse
accède à la promesse d'une coroutine
(fonction membre publique)
[static]
crée un coroutine_handle à partir de l'objet promesse d'une coroutine
(fonction membre statique publique)
Exportation/Importation
exporte l'adresse sous-jacente, c'est-à-dire le pointeur supportant la coroutine
(fonction membre publique)
[static]
importe une coroutine à partir d'un pointeur
(fonction membre statique publique)

Fonctions non membres

(C++20)
compare deux objets coroutine_handle
(fonction)

Classes d'assistance

(C++20)
Support de hachage pour std::coroutine_handle
(spécialisation de modèle de classe)

Notes

Un coroutine_handle peut être suspendu, auquel cas le coroutine_handle doit être utilisé avec précaution afin d'éviter un comportement indéfini.

Exemple

Exécuter ce code 
#include <coroutine>
#include <iostream>
#include <optional>
template<std::movable T>
class Generator
{
public:
    struct promise_type
    {
        Generator<T> get_return_object()
        {
            return Generator{Handle::from_promise(*this)};
        }
        static std::suspend_always initial_suspend() noexcept
        {
            return {};
        }
        static std::suspend_always final_suspend() noexcept
        {
            return {};
        }
        std::suspend_always yield_value(T value) noexcept
        {
            current_value = std::move(value);
            return {};
        }
        // Interdire co_await dans les coroutines générateur.
        void await_transform() = delete;
        [[noreturn]]
        static void unhandled_exception() { throw; }
        std::optional<T> current_value;
    };
    using Handle = std::coroutine_handle<promise_type>;
    explicit Generator(const Handle coroutine) :
        m_coroutine{coroutine}
    {}
    Generator() = default;
    ~Generator()
    {
        if (m_coroutine)
            m_coroutine.destroy();
    }
    Generator(const Generator&) = delete;
    Generator& operator=(const Generator&) = delete;
    Generator(Generator&& other) noexcept :
        m_coroutine{other.m_coroutine}
    {
        other.m_coroutine = {};
    }
    Generator& operator=(Generator&& other) noexcept
    {
        if (this != &other)
        {
            if (m_coroutine)
                m_coroutine.destroy();
            m_coroutine = other.m_coroutine;
            other.m_coroutine = {};
        }
        return *this;
    }
    // Prise en charge de la boucle for basée sur une plage.
    class Iter
    {
    public:
        void operator++()
        {
            m_coroutine.reprendre();
        }
        const T& operator*() const
        {
            return *m_coroutine.promise().current_value;
        }
        bool operator==(std::default_sentinel_t) const
        {
            return !m_coroutine || m_coroutine.fait();
        }
        explicit Iter(const Handle coroutine) :
            m_coroutine{coroutine}
        {}
    private:
        Handle m_coroutine;
    };
    Iter begin()
    {
        if (m_coroutine)
            m_coroutine.reprendre();
        return Iter{m_coroutine};
    }
    std::default_sentinel_t end() { return {}; }
private:
    Handle m_coroutine;
};
template<std::integral T>
Generator<T> range(T first, const T last)
{
    while (first < last)
        co_yield first++;
}
int main()
{
    for (const char i : range(65, 91))
        std::cout << i << ' ';
    std::cout << '\n';
}

Sortie : 

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
*Note: Le contenu dans la balise ` 
` n'a pas été traduit car il s'agit d'une séquence alphabétique standard qui ne nécessite pas de traduction et pourrait être utilisée dans un contexte technique ou de programmation.*

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3460 C++20 la classe de base publique de coroutine_handle pouvait la laisser dans un état indésirable héritage supprimé

Voir aussi

(C++23)
Une view qui représente un générateur synchrone de coroutine
(modèle de classe)