typedef struct A {
int x[10];
} A;
A func() {
A a;
return a;
}
int main( void )
{
int* p0 = &(func().x[0]);
/*This is valid though func().x[0] is an rvalue object */
/* Note: for C99 only.
C89 does not permit to take an rvalue's address in any case. */
/* &(func().x) is invalid because func().x is an rvalue array, and is
neither the result of a [] operator nor that of a * operator. */
return 0;
}
In fact, not all objects are lvalues (for example, the returned objects
by functions). The Standard should point this out but fails to do so,
perhaps due to the fact that taking an rvalue object's address is rare
and seems useless in C.
Indeed, this is a peculiar situation, and one I think at best poorly
covered in both C89 and C99. Even if you can do the above with "p0",
you can never *use* p0 in any way after that.
It probably would have been better (in my opinion at least) if both
standards said something like this:
When a function returns a structure value, this produces a
value-context object. The only defined operations on a
value-context object are:
- to discard it entirely, or
- to copy it wholly, as by assignment to an ordinary
object or parameter, or
- to take a pointer to it whose value is not used beyond the
next sequence point, or
- to select an element (via the "." operator), producing a
value-context object to which these rules apply recursively.
For example, if f() has a structure return value with elements
x and y, and x has array type and y has type int:
struct S { int x[N]; int y; /* and possibly others */ };
struct S f(void);
struct S r;
void g(int);
(void) f(); /* valid (discarded entirely) */
r = f(); /* valid (copied wholly) */
g(f().y); /* valid (element selected then copied wholly) */
memcpy(r.x, f().x, sizeof r.x); /* invalid -- f().x is
not being "copied wholly"; instead, a pointer is taken
and used beyond the next sequence point */
memcpy(&r.x[0], &f().x[0], sizeof r.x); /* still invalid,
for the same reason */
r.x[0] = f().x[0]; /* valid (albeit complicated!) */
Note that these rules also permit one to write, e.g.:
g((&(f()))->y);
I have fully parenthesized this to show where the operators bind:
f() returns a "struct S"; we take the address of this "value context
object" -- or "rvalue object" if you prefer such terms -- but
immediately, without an intervening sequence point, use the "->"
operator to select an element whose value is then copied wholly,
to be sent as a parameter value to g().
The above rules probably need some additional clarification (probably
grouped with the unary "*" operator) so that it is clear that "*",
applied to one of these funny pointers resulting from taking the
address of a "value-context object", produces the actual value-
context object in question, to which the special rules apply.
All of this leaves room for a future C standard to define operations
on entire arrays, so that one can write:
r.x = f().x;
to copy the whole "x" array without copying the "y" value. And, in
any case, the goal is to make the lifetime of a "value-context
object" that of a single between-sequence-points region, as if
there were a brace-enclosed local variable involved, whose lifetime
is only that of the expression:
int h(int *);
h(f().x); /* invalid */
is treated much as if we had written something like:
int h(int *);
int *p;
{
struct S temp;
temp = f();
p = &temp.x[0];
/* note that uses of both p and *p are valid here ... */
}
/* but uses of p or *p are undefined here */
h(p);
This mirrors how compilers are often likely to treat structure-valued
functions: they "return" an object whose lifetime is that of a stack
temporary, created just long enough to run the expression(s) involved,
and the way the value is "returned" is via a secret parameter. That
is:
g(f().y);
is compiled as something very much like:
{ struct S temp; f(&temp); g(temp.y); }
in a number of actual implementations. I only say "very much like"
because the temp.x space may be re-used or discarded even "inside
the braces" here, e.g., assembly code like:
sub #44,sp /* make stack space for "temp" */
lea 0(sp),r1
call f /* f(&temp) */
add #40,sp /* delete temp.x but leave temp.y */
mov (sp)+,r1 /* fetch temp.y and finish deleting temp */
call g /* g(that) */
(on a machine with a stack, and arguments passed in registers r1
onward).
}