std:: forward_like

Возвращает ссылку на x , которая обладает свойствами, аналогичными T&& .

Возвращаемый тип определяется следующим образом:

1. Если std:: remove_reference_t < T > является типом с квалификатором const, то ссылочный тип возвращаемого значения — это const std:: remove_reference_t < U > . В противном случае ссылочный тип — это std:: remove_reference_t < U > .
2. Если T&& является типом lvalue-ссылки, то возвращаемый тип также является типом lvalue-ссылки. В противном случае возвращаемый тип является типом rvalue-ссылки.

Если T не является ссылаемым типом , программа является некорректной.

Параметры

Возвращаемое значение

Ссылка на x типа, определённого как указано выше.

Примечания

Подобно std::forward , std::move и std::as_const , std::forward_like представляет собой приведение типа, которое влияет только на категорию значения выражения или потенциально добавляет const-квалификацию.

Когда m является фактическим членом и, следовательно, o. m допустимым выражением, это обычно записывается как std:: forward < decltype ( o ) > ( o ) . m в коде C++20.

Это приводит к трем возможным моделям, называемым merge , tuple , и language .

• merge : объединить const квалификаторы и принять категорию значения Owner .
• tuple : то, что делает std :: get < 0 > ( Owner ) , предполагая что Owner является std:: tuple < Member > .
• language : то, что делает std:: forward < decltype ( Owner ) > ( o ) . m .

Основной сценарий, для которого предназначен std::forward_like — это адаптация «удалённых» объектов. Ни tuple , ни language сценарии не обеспечивают корректное поведение для этого основного случая использования, поэтому для std::forward_like применяется модель merge .

Возможная реализация

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);
    }
}

` и `` оставлен без изменений, как и требовалось. HTML-разметка и атрибуты также сохранены в оригинальном виде.

Пример

#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\n";
        }
        else
        {
            if constexpr (std::is_const_v<UnrefSelfType>)
                std::cout << "const rvalue\n";
            else
                std::cout << "изменяемое 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());
        // Допустимо использовать std::forward<decltype(self)>(self).opt.value(),
        // потому что std::optional предоставляет подходящие методы доступа.
    }
    auto&& operator[](this auto&& self, std::size_t i)
    {
        return std::forward_like<decltype(self)>(self.container.at(i));
        // Не очень хорошо использовать std::forward<decltype(self)>(self)[i], потому что
        // контейнеры не предоставляют доступ к элементам через rvalue-индексацию, хотя могли бы.
    }
    auto&& from_ptr(this auto&& self)
    {
        if (!self.ptr)
            throw std::bad_optional_access{};
        return std::forward_like<decltype(self)>(*self.ptr);
        // Не рекомендуется использовать *std::forward<decltype(self)>(self).ptr, потому что
        // std::unique_ptr<TypeTeller> всегда разыменовывается в неконстантную lvalue-ссылку.
    }
};
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';
}

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

` сохранен без изменений, так как содержит C++ специфические термины (mutable, const, lvalue, rvalue), которые не подлежат переводу согласно требованиям. HTML структура и форматирование полностью сохранены.

Смотрите также