I think I may have come up with an example of rvalue of array type

C++03 §4.2 N°1:

An lvalue or rvalue of type “array of N T” or “array of unknown bound of T” can be converted to an rvalue of type “pointer to T.” The result is a pointer to the first element of the array.

What has been confusing in this statement for a long time for me was that I didn't quite understand what an rvalue of array type would mean. That is, I couldn't come up with an expression whose type were an array and the result were an rvalue. I read this thread, which basically asks the same question and the accepted answer is "no, there is no rvalue of array type". I think I just might have a contradiction to this.

C++03 §5.2.5 N°4: (is about expression E1.E2)

If E2 is a non-static data member, and the type of E1 is “cq1 vq1 X”, and the type of E2 is “cq2 vq2 T”,the expression designates the named member of the object designated by the first expression. If E1 is an lvalue, then E1.E2 is an lvalue.

I assume that otherwise it is an rvalue (provided E2 is not a reference, that case is covered by §5.2.5 N°3) and therefore...

struct A
{
   int a[4];
};
A f()开发者_JAVA百科
{
   A a;
   return a; 
}
int main()
{
   f().a; //I think this is an rvalue of array type...
}

I see two options here:

Option1: I am correct, hurray, yay, cool. In this case the question is: are there other examples?

Option2: I am incorrect, in this case the question is: is this a defect of the standard?

I don't know about 1, but I really doubt about 2 because when they speak about function-to-pointer conversions they mention just lvalues of function types (obviously appreciating that there are no rvalues of such). So it's very likely they had thought abour rvalues of array types.

So, basically my question is whether or not I have come up with an example of rvalue of array type, and if not, please provide a valid one, which I stongly believe there exists.

---

Yes, you are correct. The expression is an rvalue of array type. This is not a defect - the committee knows about it, and it was also a common issue in C89, which only allows conversion to pointers for lvalues of array types. As a consequence, you could not index or dereference an array like f().a. C99 fixed this, and C++ does not have a problem with it.

Note that whether or not it is an rvalue is independent to whether or not the expression denotes an object. C++03 accidentally omitted to say that an rvalue expression that is of array type denotes an object. This was fixed in C++0x by DR#450.

(obviously appreciating that there are no rvalues of such)

There are actually rvalues of function types. These occur for non-static member functions denoted by a class member access expression

struct A { void f(); };

/* A().f is an rvalue of type "void()" */
int main() { A().f(); }

---

The A is an rvalue. The array inside it isn't. Imagine the case in which you have a method chain on that temporary object - the variables within it live for more than one method call and return, and they may pass references (valid for the duration of the chain) to other functions. Those functions cannot know in advance that they shall be called upon an rvalue.

In the latest version of the draft, you can overload functions on rvalue/lvalue *this. However, even then, an rvalue reference does not make the contents of what is referred to an rvalue, and I'm not entirely sure that ANY compiler currently supports this, and I know that MSVC doesn't.

Infact, using decltype, you can determine easily that the compiler calls that array an lvalue.

Consider:

template<typename A, typename B> auto sum(A&& a, B&& b) -> decltype(std::forward<A>(a) + std::forward<B>(b)) {
    return std::forward<A>(a) + std::forward<B>(b);
}

That's what decltype was for, and it most definitely differentiates between lvalues and rvalues. Alternatively, consider this:

int main()
{
    auto var = f().a;
}

Var is an int*. That's an instant fail, since f().a immediately dies. Not sure of my immediate opinion on that, but it's certainly not valid for an rvalue.