Является ли член структуры rvalue rvalue или lvalue?

Член выражения rvalue - это rvalue.

Стандартные положения в 5.3.5 [expr.ref]:

Если объявлено, что E2 имеет тип «ссылка на T», то E1.E2 является lvalue [...] - если E2 является нестатическим элементом данных, а тип E1 - «cq1 vq1 X», а тип E2 - «cq2 vq2 T», выражение обозначает именованный член объекта, обозначенного первым выражением. Если E1 - это lvalue, то E1.E2 - это lvalue.

Изменить: Хорошо, я думаю, у меня наконец-то есть что-то из стандарта:

Обратите внимание, что v относится к типу int, который имеет встроенный оператор присваивания:

13.3.1.2 Операторы в выражениях

4 Для встроенных операторов присваивания преобразование левого операнда ограничено следующим образом: - не вводятся временные элементы для хранения левого операнда и [...]

fun1() должен возвращать ссылку. Тип возвращаемого значения функции без ссылки / указателя - это r-значение.

3.10 Значения L и r

5 Результатом вызова функции, которая не возвращает ссылку lvalue, является rvalue [...]

Таким образом, fun1().v - это rзначение.

8.3.2 Ссылки

2 Ссылочный тип, объявленный с помощью &, называется ссылкой lvalue, а ссылочный тип, объявленный с помощью &&, называется ссылкой rvalue. Ссылки Lvalue и ссылки rvalue - это разные типы.

Сейчас хорошее время, чтобы узнать, что такое xvalues ​​ и glvalues ​​.

Rvalues ​​ может быть двух типов - prvalues ​​ и xvalues ​​. Согласно новому стандарту C ++ 17

prvalue - это выражение, оценка которого инициализирует объект, битовое поле или операнд оператора в соответствии с контекстом, в котором оно появляется.

поэтому что-то вроде fun() в вашем примере оценивается как prvalue (которое является rvalue). Это также говорит нам, что fun().v не является значением prvalue, поскольку это не обычная инициализация.

Значения X, которые также являются значениями r, определяются следующим образом

xvalue (значение "eXpiring") также относится к объекту, обычно ближе к концу его жизненного цикла (например, чтобы его ресурсы можно было перемещать). Определенные виды выражений, включающие ссылки на rvalue (8.3.2), дают значения x. [Пример: результатом вызова функции, возвращаемый тип которой является ссылкой rvalue на тип объекта, является xvalue (5.2.2). - конец примера]

В дополнение к rvalues ​​другой зонтичной категорией значений является glvalue, которая бывает двух типов: xvalues ​​ и традиционные lvalues ​​.

На этом этапе мы определили основные категории ценностей. Это можно визуализировать так

В широком смысле можно подумать, что категория glvalue означает то, что должны были означать lvalue до того, как семантика перемещения стала вещью - вещью, которая может находиться в левой части выражения. glvalue означает обобщенное lvalue.

Если мы посмотрим на определение xvalue, то в нем говорится, что что-то является xvalue, если оно приближается к концу своего жизненного цикла. В вашем примере срок службы fun().v близок к концу. Таким образом, его ресурсы можно перемещать. И поскольку его ресурсы могут быть перемещены, это не lvalue, поэтому ваше выражение соответствует единственной оставшейся категории конечных значений - xvalue.

Я заметил, что в gcc, как правило, очень мало замечаний по поводу использования rvalue в качестве lvalue в выражениях присваивания. Это, например, отлично компилируется:

class A {
};

extern A f();

void g()
{
   A myA;
   f() = myA;
}

Почему это законно, а это нет (то есть не компилируется), хотя меня действительно смущает:

extern int f();

void g()
{
   f() = 5;
}

IMHO, у стандартного комитета есть некоторые объяснения относительно lvalues, rvalues ​​и того, где их можно использовать. Это одна из причин, по которой меня так интересует этот вопрос о rvalues ​​< / а>.

Это становится очевидным, если учесть, что компилятор сгенерирует для вас конструктор по умолчанию, конструктор копирования по умолчанию и оператор присваивания копии по умолчанию, если ваша структура / класс не содержит ссылочных членов. Затем подумайте о том, что стандарт позволяет вам вызывать методы членов во временных библиотеках, то есть вы можете вызывать неконстантные члены в неконстантных временных библиотеках.

См. Этот пример:

struct Foo {};
Foo foo () {
    return Foo();
}

struct Bar {
private:
    Bar& operator = (Bar const &); // forbid
};
Bar bar () {
    return Bar();
}
int main () {
    foo() = Foo(); // okay, called operator=() on non-const temporarie
    bar() = Bar(); // error, Bar::operator= is private
}

Если вы напишете

struct Foo {};
const Foo foo () { // return a const value
    return Foo();
}

int main () {
    foo() = Foo(); // error
}

т.е. если вы позволите функции foo () возвращать временное значение const, произойдет ошибка компиляции.

Чтобы завершить пример, вот как вызвать член const temporarie:

struct Foo {
    int bar () const { return 0xFEED; }
    int frob ()      { return 0xFEED; }
};
const Foo foo () {
    return Foo();
}

int main () {
    foo().bar(); // okay, called const member method
    foo().frob(); // error, called non-const member of const temporary
}

Вы можете определить время жизни временного объекта в текущем выражении. И вот почему вы также можете изменять переменные-члены; если бы вы не могли, то возможность вызова методов неконстантных членов была бы доведена до абсурда.

изменить: И вот необходимые цитаты:

12.2 Временные объекты:

• 3) [...] Временные объекты уничтожаются на последнем этапе оценки полного выражения (1.9), которое (лексически) содержит точку, в которой они были созданы. [...]

а потом (или лучше раньше)

3.10 Значения L и r:

• 10) l-значение для объекта необходимо для изменения объекта, за исключением того, что r-значение типа класса также может использоваться для изменения его референта при определенных обстоятельствах. [Пример: функция-член, вызываемая для объекта (9.3), может изменять объект. ]

И пример использования: http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Named_Parameter

В вашем коде нет сцены. Возвращенная структура размещается в стеке, поэтому результат присваивания будет немедленно утерян.

Ваша функция должна выделить новый экземпляр A следующим образом:

new A()

В этом случае лучше подпись

A* f(){ ...

Или верните существующий экземпляр, например:

static A globalInstance;
A& f(){ 
  return globalInstance;
}