std::forward_like
来自cppreference.com
| 在标头 <utility> 定义
|
||
| template< class T, class U > [[nodiscard]] constexpr auto&& forward_like( U&& x ) noexcept; |
(C++23 起) | |
返回到 x 的，拥有与 T&& 相似属性的引用。
返回类型确定如下：
- 若 std::remove_reference_t<T> 为 const 限定类型，则返回类型的被引用类型为 const std::remove_reference_t<U> 。否则被引用类型为 std::remove_reference_t<U> 。
- 若 T&& 为左值引用类型，则返回类型亦为左值引用类型。否则返回类型为右值引用类型。
若 T&& 不是合法类型则程序非良构。
参数
| x | - | 需要像类型 T 一样转发的值
|
返回值
到 x 的引用，类型确定如上。
注解
类似 std::forward、 std::move 与 std::as_const ， std::forward_like 是只影响表达式的值类别或潜在地添加 const 限定的转型。
当 m 为实际成员从而 o.m 为合法表达式时，这通常在 C++20 代码中写作 std::forward<decltype(o)>(o).m 。
当 o.m 不是实际表达式，即为 lambda 闭包的成员时，用户需要 std::forward_like</*see below*/>(m) 。
这导致三种可能的模式，称为合并、元组及语言。
- 合并：合并
const限定符，并采纳Owner的值类别。 - 元组： std::get<0>(Owner) 之所为，假定
Owner为 std::tuple<Member> 。 - 语言： std::forward<decltype(Owner)>(o).m 之所为。
std::forward_like 的主要应用场景是接纳“远”对象。元组或语言模型均不能做在主要使用情况中做正确的事，故合并模型被用于 std::forward_like 。
| 功能特性测试宏 |
|---|
__cpp_lib_forward_like
|
可能的实现
template<class T, class U> [[nodiscard]] 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); } } } |
示例
运行此代码
#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 << "mutable lvalue\n"; } else { if constexpr (std::is_const_v<UnrefSelfType>) std::cout << "const rvalue\n"; else std::cout << "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()); // 可以使用 std::forward<decltype(self)>(self).opt.value() ， // 因为 std::optional 提供了适合的访问器。 } auto&& operator[](this auto&& self, std::size_t i) { return std::forward_like<decltype(self)>(container.at(i)); // 使用 std::forward<decltype(self)>(self)[i] 不太好， // 因为容器不提供右值下标访问，虽然它们能。 } 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> 始终解引用到非 const 左值。 } }; 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++11) |
获得右值引用 (函数模板) |
| (C++11) |
转发一个函数实参 (函数模板) |
| (C++17) |
获得到其实参的 const 引用 (函数模板) |