std::forward_like
来自 cppreference.com
| 定义在头文件 <utility> 中 |
||
| template< class T, class U > 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。
这导致了三种可能的模型，称为合并、元组和语言。
- 合并：合并 const 限定符，并采用
Owner的值类别。 - 元组：std::get<0>(Owner) 所做的事情，假设
Owner是一个 std::tuple<Member>. - 语言：std::forward<decltype(Owner)>(o).m 所做的事情。
std::forward_like 针对的主要场景是适应“远”对象。元组和语言场景对于这种主要用例都没有做到正确的事情，因此合并模型用于 std::forward_like。
| 特性测试 宏 | 值 | Std | 特性 |
|---|---|---|---|
__cpp_lib_forward_like |
202207L | (C++23) | std::forward_like
|
[编辑] 可能的实现
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); } } |
[编辑] 示例
运行这段代码
#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()); // It is OK to use std::forward<decltype(self)>(self).opt.value(), // because std::optional provides suitable accessors. } auto&& operator[](this auto&& self, std::size_t i) { return std::forward_like<decltype(self)>(self.container.at(i)); // It is not so good to use std::forward<decltype(self)>(self)[i], because // containers do not provide rvalue subscript access, although they could. } auto&& from_ptr(this auto&& self) { if (!self.ptr) throw std::bad_optional_access{}; return std::forward_like<decltype(self)>(*self.ptr); // It is not good to use *std::forward<decltype(self)>(self).ptr, because // std::unique_ptr<TypeTeller> always dereferences to a non-const 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++11) |
将参数转换为右值 (函数模板) |
| (C++11) |
转发函数参数并使用类型模板参数来保留其值类别 (函数模板) |
| (C++17) |
获取对 const 的引用到其参数 (函数模板) |
