Функция на C++, возвращающая по значению, может ли возвращать rvalue-ссылку?

Я читал о rvalue и наткнулся на что-то, пытаясь запустить фрагмент кода в компиляторе explorer. Вот вымышленный пример:

class A
{
    public:

    A&& func(A& rhs)
    {
        //return rhs;
        return std::move(rhs); //возвращая A&&
    }
};

в сравнении с

class A
{
    public:

    A func(A& rhs)
    {
        //return rhs;
        return std::move(rhs); //возвращая A&&
    }
};

Я ожидал, что этот второй фрагмент не скомпилируется из-за несовпадения типов возвращаемого значения. Возвращаемый тип функции здесь A, тогда как на самом деле она возвращает A&& благодаря std::move(). Я пробовал последние версии gcc, clang и msvc. Все имеют такое же поведение. Может кто-то объяснить, что здесь происходит?

Обновление:

Я думаю, что нашел ответ, ну, по меньшей мере, тот, который имеет смысл для моего маленького мозга. X и X&& — два разных типа, но причина, по которой это работает, в том, что на самом деле есть возможность преобразования через конструктор перемещения по умолчанию. Я изменил фрагмент на это, и компиляция начала вызывать ошибки:

class A
{
    public:
    A(const A& rhs){}; 
    A(A&& rhs) = delete; //конструктор перемещения удален

    A func(A& rhs)
    {
        //return rhs;
        return std::move(rhs);
    }
};

<source>(27): error C2280: 'A::A(A &&)': попытка сослаться на удаленную функцию

Это поведение аналогично примеру float one() { return 1; }, приведенному @JaMiT ниже.

Спасибо всем за ваши комментарии. C++ заставляет меня теряться.

В C++, когда вы используете std::move на объекте, вы на самом деле не преобразуете его в rvalue-ссылку (T&&). Вместо этого вы преобразуете его в rvalue, что сигнализирует компилятору о том, что он может рассматривать объект как временный и, если возможно, перемещать его вместо копирования. Однако std::move не изменяет базовый тип; он просто предоставляет подсказку для компилятора, чтобы использовать семантику перемещения.

Вот что происходит в обоих примерах:

Пример 1: A&& func(A& rhs)

В этой версии функция func возвращает A&& (ссылку на rvalue типа A). Когда вы возвращаете std::move(rhs), вы прямо возвращаете ссылку на rvalue, что соответствует возвращаемому типу A&&. Это имеет смысл и будет компилироваться как ожидалось.

Пример 2: A func(A& rhs)

В этом случае функция func имеет возвращаемый тип A, который является значением (не rvalue-ссылкой). Однако, когда вы возвращаете std::move(rhs), вы все равно преобразуете rhs в rvalue-ссылку (A&&). Вот почему это все еще компилируется и ведет себя так, как вы наблюдали:

• Автоматическое преобразование: Когда вы указываете тип возвращаемого значения как A (значение), компилятор ожидает создать и вернуть объект A. Если вы предоставляете A&& (через std::move(rhs)), компилятор интерпретирует это как инструкцию переместить и сконструировать A из rhs, а не копировать его. Компилятор видит, что rhs является rvalue и использует конструктор перемещения для создания возвращаемого значения.

• Выявление возвращаемого типа и временная материация: Компилятор будет неявно выполнять перемещение при возврате rvalue, если возвращаемый тип является значением. В этом случае A func(A& rhs) указывает возвращаемый тип A, поэтому компилятор рассматривает std::move(rhs) как rvalue, создавая временный A с использованием конструктора перемещения.

Я ожидал, что этот второй фрагмент не скомпилируется из-за несовпадения типов возвращаемого значения.

Здесь нет проблем с несовпадением.
В вашем втором случае функция возвращает rvalue типа A.
Это возвращаемое значение будет использоваться с конструктором перемещения класса A для создания экземпляра A на стороне вызова.

Это демонстрируется ниже:

#include <iostream>

class A {
public:
    A()                              { std::cout << "default ctor\n"; };
    ~A()                             { std::cout << "dtor\n"; };
    A([[maybe_unused]] A const & a)  { std::cout << "copy ctor\n"; };
    A([[maybe_unused]] A && a)       { std::cout << "move ctor\n"; };

    // Чтобы соблюдать правило 5, нам также нужны копирующий и перемещающий оператор=, 
    // но здесь это опущено для примера

    static A func(A& rhs) {
        //return rhs;
        return std::move(rhs); //возвращая A&&
    }
};

int main() {
    A a1;
    A a2 = A::func(a1);
}

Вывод:

default ctor
move ctor
dtor
dtor

Живая демонстрация

Если вы не предоставите конструктор перемещения, компилятор сгенерирует его.