std:: forward_like

Retourne une référence à x qui possède des propriétés similaires à T&& .

Le type de retour est déterminé comme suit :

1. Si std:: remove_reference_t < T > est un type qualifié const, alors le type référencé du type de retour est const std:: remove_reference_t < U > . Sinon, le type référencé est std:: remove_reference_t < U > .
2. Si T&& est un type de référence lvalue, alors le type de retour est également un type de référence lvalue. Sinon, le type de retour est un type de référence rvalue.

Si T n'est pas un type référençable , le programme est mal formé.

Paramètres

Valeur de retour

Une référence à x du type déterminé comme ci-dessus.

Notes

Comme std::forward , std::move , et std::as_const , std::forward_like est un transtypage qui n'influence que la catégorie de valeur d'une expression, ou ajoute potentiellement une qualification const.

Lorsque m est un membre réel et donc o. m une expression valide, cela s'écrit généralement std:: forward < decltype ( o ) > ( o ) . m dans le code C++20.

Cela conduit à trois modèles possibles, appelés merge , tuple , et language .

• merge : fusionner les const qualifiers, et adopter la catégorie de valeur du Owner .
• tuple : ce que fait std :: get < 0 > ( Owner ) , en supposant que Owner est un std:: tuple < Member > .
• language : ce que fait std:: forward < decltype ( Owner ) > ( o ) . m .

Le scénario principal que std::forward_like adresse est l'adaptation d'objets « distants ». Ni le tuple ni le langage ne traitent correctement ce cas d'usage principal, c'est pourquoi le modèle de fusion est utilisé pour std::forward_like .

Implémentation possible

template<class T, class U>
constexpr auto&& forward_like(U&& x) noexcept
{
    constexpr bool is_adding_const = std::is_const_v<std::remove_reference_t<T>>;
    if constexpr (std::is_lvalue_reference_v<T&&>)
    {
        if constexpr (is_adding_const)
            return std::as_const(x);
        else
            return static_cast<U&>(x);
    }
    else
    {
        if constexpr (is_adding_const)
            return std::move(std::as_const(x));
        else
            return std::move(x);
    }
}

Exemple

#include <cstddef>
#include <iostream>
#include <memory>
#include <optional>
#include <type_traits>
#include <utility>
#include <vector>
struct TypeTeller
{
    void operator()(this auto&& self)
    {
        using SelfType = decltype(self);
        using UnrefSelfType = std::remove_reference_t<SelfType>;
        if constexpr (std::is_lvalue_reference_v<SelfType>)
        {
            if constexpr (std::is_const_v<UnrefSelfType>)
                std::cout << "const lvalue\n";
            else
                std::cout << "lvalue mutable\n";
        }
        else
        {
            if constexpr (std::is_const_v<UnrefSelfType>)
                std::cout << "const rvalue\n";
            else
                std::cout << "valeur mutable rvalue\n";
        }
    }
};
struct FarStates
{
    std::unique_ptr<TypeTeller> ptr;
    std::optional<TypeTeller> opt;
    std::vector<TypeTeller> container;
    auto&& from_opt(this auto&& self)
    {
        return std::forward_like<decltype(self)>(self.opt.value());
        // Il est acceptable d'utiliser std::forward<decltype(self)>(self).opt.value(),
        // car std::optional fournit des accesseurs appropriés.
    }
    auto&& operator[](this auto&& self, std::size_t i)
    {
        return std::forward_like<decltype(self)>(self.container.at(i));
        // Il n'est pas très judicieux d'utiliser std::forward(self)[i], car
        // les conteneurs ne fournissent pas d'accès par indice avec rvalue, bien qu'ils pourraient.
    }
    auto&& from_ptr(this auto&& self)
    {
        if (!self.ptr)
            throw std::bad_optional_access{};
        return std::forward_like<decltype(self)>(*self.ptr);
        // Il n'est pas bon d'utiliser *std::forward<decltype(self)>(self).ptr, car
        // std::unique_ptr<TypeTeller> se déréférence toujours en une lvalue non constante.
    }
};
int main()
{
    FarStates my_state
    {
        .ptr{std::make_unique<TypeTeller>()},
        .opt{std::in_place, TypeTeller{}},
        .container{std::vector<TypeTeller>(1)},
    };
    my_state.from_ptr()();
    my_state.from_opt()();
    my_state[0]();
    std::cout << '\n';
    std::as_const(my_state).from_ptr()();
    std::as_const(my_state).from_opt()();
    std::as_const(my_state)[0]();
    std::cout << '\n';
    std::move(my_state).from_ptr()();
    std::move(my_state).from_opt()();
    std::move(my_state)[0]();
    std::cout << '\n';
    std::move(std::as_const(my_state)).from_ptr()();
    std::move(std::as_const(my_state)).from_opt()();
    std::move(std::as_const(my_state))[0]();
    std::cout << '\n';
}

lvalue mutable
lvalue mutable
lvalue mutable
lvalue const
lvalue const
lvalue const
rvalue mutable
rvalue mutable
rvalue mutable
rvalue const
rvalue const
rvalue const

Voir aussi