std::forward>(f) 的含义

Question

我对 https://koturn.hatenablog.com 中编写的代码有疑问/条目/2018/06/10/060000 当我传递左值引用时，如果我不使用 std::decay_t 删除引用，则会收到错误。
这是错误消息
'错误：'operator()'不是'main()::>&
的成员 我不明白为什么需要排除左值引用。
我想知道这个错误是什么意思。

#include <iostream>
#include <utility>


template <typename F>
class
FixPoint : private F
{
public:
  explicit constexpr FixPoint(F&& f) noexcept
    : F{std::forward<F>(f)}
  {}

  template <typename... Args>
  constexpr decltype(auto)
  operator()(Args&&... args) const
  {
    return F::operator()(*this, std::forward<Args>(args)...);
  }
};  // class FixPoint


namespace
{
template <typename F>
inline constexpr decltype(auto)
makeFixPoint(F&& f) noexcept
{
  return FixPoint<std::decay_t<F>>{std::forward<std::decay_t<F>>(f)};
}
}  // namespace


int
main()
{
  auto body = [](auto f, int n) -> int {
    return n < 2 ? n : (f(n - 1) + f(n - 2));
  };
  auto result = makeFixPoint(body)(10);
  std::cout << result << std::endl;
}

Answer 1

我不明白为什么需要排除左值
参考。我想知道这个错误是什么意思。

当您将左值 lambda 传递给 makeFixPoint() 时，makeFixPoint() 的模板参数 F 会实例化为L&，其中 L 是 lambda 类型。在函数体中，FixPoint>{...} 将被实例化为 FixPoint{...}，因此FixPoint 的构造函数被实例化为

explicit constexpr FixPoint(L&& f);

接受 lambda 类型的右值引用。在 makeFixPoint() 中，如果使用 {std::forward(f)} 初始化它，即 {std::forward (f)}，f 将作为左值转发，这将是格式错误的，因为右值引用无法绑定左值。

使用 {std::forward>(f)} 的目的是强制 f 作为右值转发。

Answer 2

,您分享的代码有毒。

template <typename F>
class FixPoint : private F
{
public:
  explicit constexpr FixPoint(F&& f)

这意味着我们期望 F 是一个值类型（因为从引用继承是不可能的）。此外，我们将只接受右值——我们将仅从另一个F移动。

  : F{std::forward<F>(f)}
{}

这个 std::forward 是没有意义的；这表明编写此代码的人认为他们是完美的转发：但事实并非如此。唯一合法的类型 F 是值类型（不是引用），如果 F 是值类型 F&& 始终是右值引用，因此 std::forward 始终等同于 std::move。

在某些情况下，您可能希望这样做

template<class X>
struct wrap1 {
  X&& x;
  wrap1(X&& xin):x(std::forward<X>(xin)){}
};

，甚至

template<class X>
struct wrap2 {
  X x;
  wrap2(X&& xin):x(std::forward<X>(xin)){}
};

上述代码与某些用例相似，但它不是这些用例之一。 （这里的区别是 X 或 X&& 是成员的类型，而不是基类；基类不能是引用）。

wrap2 的用途是当您想要“延长”右值的生命周期，并且只需引用左值时。 wrap1 的使用是当您想要继续完美转发某些表达式时（wrap1 样式对象通常不安全地保留超过一行代码；< code>wrap2 是安全的，只要它们不超过传递给它们的任何左值）。

---

template <typename F>
inline constexpr decltype(auto)
makeFixPoint(F&& f) noexcept
{
  return FixPoint<std::decay_t<F>>{std::forward<std::decay_t<F>>(f)};
}

好的，这里有更多危险信号。 inline constexpr 是无意义的标志； constexpr 函数始终是内联。可能有些编译器将额外的内联视为有意义的内容，因此不能保证出现问题。

return FixPoint<std::decay_t<F>>{std::forward<std::decay_t<F>>(f)};

std::forward 是一个有条件的移动。如果有右值或值类型传递给它，它就会移动。 decay 保证返回值类型。所以我们只是扔掉了操作的条件部分，并将其变成了一个原始的动作。

return FixPoint<std::decay_t<F>>{std::move(f)};

这是一个更简单的，但具有相同含义的。

此时您可能会看到危险：

template <typename F>
constexpr decltype(auto)
makeFixPoint(F&& f) noexcept
{
  return FixPoint<std::decay_t<F>>{std::move(f)};
}

我们无条件地放弃 makeFixPoint 参数。名称 makeFixPoint 中没有任何内容表明“我从参数中移动”，并且它接受转发引用；所以它会默默地消耗一个左值并从中移动。

这是非常粗鲁的。

---

因此，代码的合理版本是：

template <typename F>
class FixPoint : private F
{
public:
  template<class U,
    class dU = std::decay_t<U>,
    std::enable_if_t<!std::is_same_v<dU, FixPoint> && std::is_same_v<dU, F>, bool> = true
  >
  explicit constexpr FixPoint(U&& u) noexcept
    : F{std::forward<U>(u)}
  {}

[SNIP]

namespace
{
  template <typename F>
  constexpr FixPoint<std::decay_t<F>>
  makeFixPoint(F&& f) noexcept
  {
    return FixPoint<std::decay_t<F>>{std::forward<F>(f)};
  }
}  // namespace

，它可以稍微清理一下内容。

Answer 3

这样模板就无法按预期工作。

首先，因为它应该可以从F继承，所以使用std::decay_t没有多大意义。相反，它可能应该只是 std::remove_cvref_t ，但在 C++20 之前，编写起来有点麻烦，而 std::decay_t 的作用几乎相同。

在类模板中 F 旨在成为非引用类型。它不是构造函数的模板参数。所以它不能用于完美转发。构造函数参数始终是不能采用左值的右值引用。

即使将左值传递给 makeFixPoint，调用 std::forward>(f) 也会强制转换为右值引用，这会导致然后可以在构造函数中使用。这显然是危险的。该函数始终的行为就好像您已将参数std::move放入其中一样。

它应该只是 std::forward(f) 并且构造函数应该采用另一个可用于形成转发引用的模板参数：

template<typename G>
requires std::is_same_v<std::remove_cvref_t<G>, F>
explicit constexpr FixPoint(G&& g) noexcept
  : F{std::forward<G>(g)}
{}