可以返回右值引用吗？

Question

#include <stdio.h>
#include <memory>

struct A {
  A() { printf("A()\n"); }
  virtual ~A() { printf("~A()\n"); }
};

struct B : public A {
  B() { printf("B()\n"); }
  virtual ~B() { printf("~B()\n"); }
};

A&& foo() {
  B b;
  return std::move(b);
}

int main() {
  A&& a = foo();
//  const A& a = foo(); // same output
  printf("checkpoint\n");
}

output:
A() 
B() 
~B() 
~A() 
checkpoint

检查点是最后一行，为什么？我想让 foo 返回引用而不是指针来实现多态，有没有办法做到这一点？

PS：这个问题可能相关：Why a & b have the same address?

更重要的是，我只是一个返回函数内创建的对象的方案，但不使用指针。出于一个原因，指针需要删除，出于另一个原因，认为 A & B 是支持基于范围的 for 循环的迭代器，其取消引用 operator* 被重新定义，使用指针或 unique_ptr/shared_ptr 不是一个好主意，我猜。

Answer 1

这是格式错误的，因为foo() 正在返回对本地对象的引用，当foo() 返回时该对象将被销毁；那么返回的引用总是悬空的。

您可以改用智能指针（如std::unique_ptr）。例如

std::unique_ptr<A> foo() {
  std::unique_ptr<A> b = std::make_unique<B>();
  return b;
}

LIVE

Answer 2

看到这个答案：Is returning by rvalue reference more efficient?

A&& foo() { 与 B b;返回 std::move(b); } 您正在返回一个悬空引用：https://godbolt.org/z/HU88aU

我不太明白返回引用（而不是指针）与多态性有什么关系？ B 基于 A 并且在 foo() 中创建实例会超过对象的生命周期 - 仅此而已。

Answer 3

这在很多层面都是错误的。

多态与使用引用和指针没有任何关系。例如，当从类层次结构中调用对象的成员函数时，就会发生多态性。根据对象的确切类型，它将导致执行不同的函数。如果您有一个指向该对象的指针并调用foo->bar() 或对它的引用并调用foo.bar()，这并不重要。无论哪种方式，你都会得到多态性。

通过手动声明析构函数，您可以防止自动生成移动构造函数和移动赋值运算符。当试图移动没有移动语义的东西时，它会被复制。因此，即使您只是添加一个析构函数来记录日志，您也需要手动启用移动：

A(A&&) = default;

您似乎不了解右值引用的工作原理。我不会在这里详细解释整个主题，但std::move 本质上只是将左值转换为右值。您无需声明左值并将其转换为右值即可获得右值。所以这个：

B b;
return std::move(b);

可以改为：

return B {};

这会将您的代码更改为：

#include <iostream>
#include <memory>

struct A {

    A()
    { 
        std::cout << "A()" << std::endl;
    }

    A(A&&) = default;   

    virtual ~A()
    { 
        std::cout << "~A()" << std::endl;
    }
};

struct B : public A 
{
    B()
    {
        std::cout << "B()" << std::endl;
    }

    B(B&&) = default;

    virtual ~B() 
    { 
        std::cout << "~B()" << std::endl;
    }
};

A foo() 
{
    return B {};
}

int main() 
{
    A a = foo();

    std::cout << "checkpoint" << std::endl;
}