c++ - 宣告RValue方法(例如void operation()&& ;;)虚拟C++ 1x有意义

这可能有点异国情调:
(我正在努力更新新的c++标准)
在类中声明RValue方法是否有意义？
例如void operation() &&; virtual吗？我无法想象，因为手术
仅适用于临时对象，例如Base().operation()或Derived().operation()或类似createObject().operation()的东西。
表达式createObject()必须返回一个对象，并且
既不是引用也不是指针，因为它们都必须
引用左值对象。
并且由于类型 slice ，始终会调用Base::operation()。
如果您有一个Derived()对象，则会调用Derived::operation()，
尽管如此，它在Base中还是虚拟的。
那么，有没有我需要监督的案例？
感谢您的灵感!

哦，是的，我忘了，RValue有强制转换:前进!
感谢那!

我的发现是:
1.调用合格的RValue引用
操作(rqOp()&&)，我们总是必须使用std::forward
除了:Derived()。rqOp();
2.声明RValue引用合格是有意义的
虚拟操作

由于以下原因:
给定基础和派生类
具有重载的引用合格操作rqOp()
和一个非引用合格的称为op()的对象:

class Base{
public:
    virtual ~Base() = default;
    virtual
    void rqOp() &&;
    virtual void rqOp() &;
    virtual void op();

};
class Derived : public Base{
public:
    //virtual
    void rqOp() &&; //override;
    virtual void rqOp() & override;
    virtual void op() override;
};

和重载的功能:

void callOperationF(Base& b){
    cout << "callOperationF(Base& b)" << endl;

    cout << "b.rqOp();" << endl;
    b.rqOp();
}
void callOperationF(Base&& b){
    cout << "callOperationF(Base&& b)" << endl;

    cout << "b.rqOp();" << endl;
    b.rqOp();

    cout << "std::forward<Base&&>(b).rqOp();" << endl;
    std::forward<Base&&>(b).rqOp();

    cout << "std::forward<Base&&>(b).op();" << endl;
    std::forward<Base&&>(b).op();
}

以及一些对该重载的调用:

cout << "== Derived d;" << endl;
Derived d;

cout << endl;
cout << "== callOperationF(d);" << endl;
callOperationF(d);

cout << endl;
cout << "== callOperationF(Derived());" << endl;
callOperationF(Derived());

产生输出:

== Derived d;

== callOperationF(d);
callOperationF(Base& b)
b.rqOp();
Derived::rqOp() &

== callOperationF(Derived());
callOperationF(Base&& b)
b.rqOp();
Derived::rqOp() & ===> 1
std::forward<Base&&>(b).rqOp();
Derived::rqOp() && ===> 2
std::forward<Base&&>(b).op();
Derived::op()

如我们所见，要调用一个合格的RValue引用
操作(rqOp()&&)，我们需要使用forward
在===> 1时，未调用合格的RValue!
因为b是一个LValue表达式。
在===> 2处使用std::forward 正确的方法
被称为
未引用合格的操作(op())是
用std::forward 正确调用。
如果我们更改接口(interface)和
重载op()引用合格，它将仍然
调用正确的方法后，将RValue引用量化为1。

具有模板化功能，如下所示:

template<class T>
void callOperationT(T&& t){
    cout << "callOperationT(T&& t)" << endl;
    cout << "t.rqOp()" << endl;
    t.rqOp();
    cout << "std::forward<T>(t).rqOp();" << endl;
    std::forward<T>(t).rqOp();
    cout << "std::forward<T>(t).op();" << endl;
    std::forward<T>(t).op();
}

以及上面的Derived d对该函数的一些调用:

cout << endl;
cout << "== callOperationT(d);" << endl;
callOperationT(d);

cout << endl;
cout << "== Base& bRef = d;" << endl;
Base& bRef = d;
cout << "== callOperationT(move(bRef));" << endl;
callOperationT(move(bRef));

cout << endl;
cout << "== callOperationT(Derived());" << endl;
callOperationT(Derived());

产生输出:

== callOperationT(d);
callOperationT(T&& t)
t.rqOp()
Derived::rqOp() &
std::forward<T>(t).rqOp();
Derived::rqOp() &
std::forward<T>(t).op();
Derived::op()

== Base& bRef = d;
== callOperationT(move(bRef));
callOperationT(T&& t)
t.rqOp()
Derived::rqOp() &
std::forward<T>(t).rqOp();
Derived::rqOp() && ===> 3
std::forward<T>(t).op();
Derived::op()

== callOperationT(Derived());
callOperationT(T&& t)
t.rqOp()
Derived::rqOp() &
std::forward<T>(t).rqOp();
Derived::rqOp() &&
std::forward<T>(t).op();
Derived::op()

具有相同的发现:调用合格的RValue引用
操作(rqOp()&&)，我们需要使用forward
如果rqOp在===> 3处将调用Base::rqOp()&&
不是虚拟的。

谢谢!

最佳答案

不必要。右值引用限定的函数要求将对象绑定(bind)到右值引用。也就是说，您可以使用一个函数，该函数返回一个对Base的右值引用，但其动态类型为Derived:

struct Base {
    virtual void f() && { std::cout << "Base\n"; };
    virtual ~Base() = default;
};

struct Derived : Base
{
    void f() && override { std::cout << "Derived\n"; }
} child;

Base&& Get() {
    return std::move(child);
}

int main() {
    Get().f(); // Derived
}