Rvalue of struct type

[SRR]

Consider the following code:
#include <stdio.h>
#include <string.h>
struct test{
char a[100];
}

funTest( void );
int main( void )
{
printf("%s",fun Test().a);
return 0;
}

struct test funTest()
{
struct test foo;
strcpy(foo.a,"H ello");
return foo;
}
In this I want to know how the following expression statement works:
printf("%s",fun Test().a);

funTest() is evaluated to yield an rvalue of type, "struct test" and
the expression "funTest(). a" yields an rvalue of type array of char,
which is converted to an rvalue equal to the pointer to the first
element of the char array and is passed to the printf() function.

My doubt is, since "funTest(). a" yields an rvalue of type, array of
char, how can it be converted to pointer type when we can have pointer
only for Lvalues and not for Rvalues.

Hope my question is clear.

Thanks in advance for the reply.

[=?utf-8?B?SGFyYWxkIHZhbiBExLNr?=]

SRR wrote:

Consider the following code:
#include <stdio.h>
#include <string.h>
struct test{
char a[100];
}

funTest( void );

While valid, this is really bad style. It looks like you forgot a
semicolon and expect funTest to return int, when you really do mean to
make funTest return struct test.

int main( void )
{
printf("%s",fun Test().a);
return 0;
}

struct test funTest()
{
struct test foo;
strcpy(foo.a,"H ello");
return foo;
}
In this I want to know how the following expression statement works:
printf("%s",fun Test().a);

funTest() is evaluated to yield an rvalue of type, "struct test" and
the expression "funTest(). a" yields an rvalue of type array of char,
which is converted to an rvalue equal to the pointer to the first
element of the char array and is passed to the printf() function.

Correct.

My doubt is, since "funTest(). a" yields an rvalue of type, array of
char, how can it be converted to pointer type when we can have pointer
only for Lvalues and not for Rvalues.

The pointer points to a temporary, and accessing that temporary after
the next sequence point, or modifying it, results in undefined
behaviour. (If you don't know what a sequence point is, please ask.)

char c = funTest().a[0]; /* valid, initialises c with 'H' */
char *p = funTest().a; /* valid, initialised p with a pointer value */
c = *p; /* invalid, accessing the function call's result after the
next sequence point */

funTest().a[0] = 'H'; /* invalid, modifying function call's result */

char str[100];
strcpy(str, funTest().a); /* invalid, accessing the function call's
result after the next sequence point */

[SRR]

On Mar 10, 2:51Â*pm, "Harald van Dijk" <true...@gmail. comwrote:

SRR wrote:

Consider the following code:
#include <stdio.h>
#include <string.h>
struct test{
Â* Â* Â* Â*char a[100];
}

funTest( void );

While valid, this is really bad style. It looks like you forgot a
semicolon and expect funTest to return int, when you really do mean to
make funTest return struct test.

Yes! You are right. But I did it inadvertantly while pasting the code.
Actually I typed it as
struct test{
char a[100];
}funTest( void );
Thanks for your comment abouy it.

>

int main( void )
{
Â* Â* printf("%s",fun Test().a);
Â* Â* return 0;
}

struct test funTest()
{
Â* Â* Â* Â*struct test foo;
Â* Â* Â* Â*strcpy(foo.a, "Hello");
Â* Â* Â* Â*return foo;
}

In this I want to know how the following expression statement works:
printf("%s",fun Test().a);

funTest() is evaluated to yield an rvalue of type, "struct test" and
the expression "funTest(). a" yields an rvalue of type array of char,
which is converted to an rvalue equal to the pointer to the first
element of the char array and is passed to the printf() function.

Correct.

My doubt is, since "funTest(). a" yields an rvalue of type, array of
char, how can it be converted to pointer type when we can have pointer
only for Lvalues and not for Rvalues.

The pointer points to a temporary, and accessing that temporary after
the next sequence point, or modifying it, results in undefined
behaviour. (If you don't know what a sequence point is, please ask.)

Thanks, I know the concept of Sequence Point. A function Call is a
sequence point as all the arguments are evaluated including all side
effects before entering the function.
Therefore my code produces undefined behavior as the temporary storage
may no longer contain the required data!
Now I understood why I got run time error when I compiled and executed
the code using Dev-CPP for Windows OS, but it executed well with
TurboCPP for MS-Dos.
Thanks once again for helping me understand what is really happening.

>
char c = funTest().a[0]; /* valid, initialises c with 'H' */
char *p = funTest().a; /* valid, initialised p with a pointer value */
c = *p; /* invalid, accessing the function call's result after the
next sequence point */

funTest().a[0] = 'H'; /* invalid, modifying function call's result */

char str[100];
strcpy(str, funTest().a); /* invalid, accessing the function call's
result after the next sequence point */- Hide quoted text -

Let us extend the topic. Is this the only case, when an rvalue of type
array is converted to rvalue of type pointer to the first element of
the array using temporary storage?
Any other possibility?
Thanks in advance for the reply.

- Show quoted text -

[SRR]

On Mar 10, 2:51Â*pm, "Harald van Dijk" <true...@gmail. comwrote:

SRR wrote:

Consider the following code:
#include <stdio.h>
#include <string.h>
struct test{
Â* Â* Â* Â*char a[100];
}

funTest( void );

While valid, this is really bad style. It looks like you forgot a
semicolon and expect funTest to return int, when you really do mean to
make funTest return struct test.

int main( void )
{
Â* Â* printf("%s",fun Test().a);
Â* Â* return 0;
}

struct test funTest()
{
Â* Â* Â* Â*struct test foo;
Â* Â* Â* Â*strcpy(foo.a, "Hello");
Â* Â* Â* Â*return foo;
}

In this I want to know how the following expression statement works:
printf("%s",fun Test().a);

funTest() is evaluated to yield an rvalue of type, "struct test" and
the expression "funTest(). a" yields an rvalue of type array of char,
which is converted to an rvalue equal to the pointer to the first
element of the char array and is passed to the printf() function.

Correct.

My doubt is, since "funTest(). a" yields an rvalue of type, array of
char, how can it be converted to pointer type when we can have pointer
only for Lvalues and not for Rvalues.

The pointer points to a temporary, and accessing that temporary after
the next sequence point, or modifying it, results in undefined
behaviour. (If you don't know what a sequence point is, please ask.)

char c = funTest().a[0]; /* valid, initialises c with 'H' */
char *p = funTest().a; /* valid, initialised p with a pointer value */
c = *p; /* invalid, accessing the function call's result after the
next sequence point */

funTest().a[0] = 'H'; /* invalid, modifying function call's result */

Forgot to ask you one more question.
The left operand of assignment operator should be an Lvalue, but in
this case it is an rvalue, but the compiler doesn't complain that
"Lvalue required". So can I conclude that a structure containing an
array type returned by a function is converted from Rvalue to Lvalue!
(Really funny!!)
Or is it Compiler dependent?
Does the standard say anything about the value returned by, functions
returning structure containing array type?
I hope my question is clear.

Thanks in advance for the reply.

>
char str[100];
strcpy(str, funTest().a); /* invalid, accessing the function call's
result after the next sequence point */- Hide quoted text -

- Show quoted text -

[=?utf-8?B?SGFyYWxkIHZhbiBExLNr?=]

On Mar 10, 11:38 am, "SRR" <SRRajesh1...@g mail.comwrote:

On Mar 10, 2:51 pm, "Harald van Dijk" <true...@gmail. comwrote:SRRwro te:

Consider the following code:
#include <stdio.h>
#include <string.h>
struct test{
char a[100];
}

funTest( void );

int main( void )
{
printf("%s",fun Test().a);
return 0;
}

struct test funTest()
{
struct test foo;
strcpy(foo.a,"H ello");
return foo;
}

[...]

char c = funTest().a[0]; /* valid, initialises c with 'H' */
char *p = funTest().a; /* valid, initialised p with a pointer value */
c = *p; /* invalid, accessing the function call's result after the
next sequence point */

funTest().a[0] = 'H'; /* invalid, modifying function call's result */

char str[100];
strcpy(str, funTest().a); /* invalid, accessing the function call's
result after the next sequence point */

Let us extend the topic. Is this the only case, when an rvalue of type
array is converted to rvalue of type pointer to the first element of
the array using temporary storage?

A structure that is not a function call's result must be an lvalue, as
far as I know. So yes, I believe this is the only special case.

[=?utf-8?B?SGFyYWxkIHZhbiBExLNr?=]

On Mar 10, 12:03 pm, "SRR" <SRRajesh1...@g mail.comwrote:

On Mar 10, 2:51 pm, "Harald van Dijk" <true...@gmail. comwrote:

funTest().a[0] = 'H'; /* invalid, modifying function call's result */

Forgot to ask you one more question.
The left operand of assignment operator should be an Lvalue, but in
this case it is an rvalue, but the compiler doesn't complain that
"Lvalue required". So can I conclude that a structure containing an
array type returned by a function is converted from Rvalue to Lvalue!

funTest().a[0] is short for *(funTest().a + 0).

funTest().a is an rvalue array, funTest().a + 0 is an rvalue pointer,
and *(funTest().a + 0) is a dereferenced pointer. Any dereferenced
pointer is an lvalue. There is no rvalue-to-lvalue conversion that
takes place.

The difference can matter:

struct S {
char m[1];
};
struct S s;
struct S f(void) {
return s;
}
int main(void) {
char *p;
p = s.m; /* valid */
p = (char *) &s.m; /* valid */
p = f().m; /* valid (but useless) */
p = (char *) &f().m; /* invalid */
}

The last statement is invalid because f().m is not an lvalue, so you
cannot apply to & operator to it. (The compiler I'm trying right now
disagrees with me; I might be wrong on this.)

[Chris Torek]

[regarding a function, in this case named "funTest", that returns
a structure "struct test", containing an array, in this case "a"]

>SRR wrote:

>>In this I want to know how the following expression statement works:
printf("%s",fu nTest().a);

funTest() is evaluated to yield an rvalue of type, "struct test" and
the expression "funTest(). a" yields an rvalue of type array of char,
which is converted to an rvalue equal to the pointer to the first
element of the char array and is passed to the printf() function.

In article <11************ *********@8g200 0cwh.googlegrou ps.com>
Harald van Dijk <tr*****@gmail. comwrote:

>Correct.

[...]

>The pointer points to a temporary, and accessing that temporary after
the next sequence point, or modifying it, results in undefined
behaviour. (If you don't know what a sequence point is, please ask.)

char c = funTest().a[0]; /* valid, initialises c with 'H' */

It is worth adding that this is new in C99. C89 never really
quite said enough about these things: we can make guesses, but
there is no wording in that standard to pin down the behavior.
In C89, even something like:

char c = funTest().a[0];

might not be valid. (One might hope that it *is* valid, with the
semantics required by C99, but I think it is dangerous to assume
so.) Note that:

struct test val;

val = funTest();

is valid in both C89 and C99, and is "safe way" to handle
structure-valued functions.
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[Rajesh S R]

On Mar 10, 10:02Â*pm, "Harald van Dijk" <true...@gmail. comwrote:

On Mar 10, 12:03 pm, "SRR" <SRRajesh1...@g mail.comwrote:

On Mar 10, 2:51 pm, "Harald van Dijk" <true...@gmail. comwrote:

funTest().a[0] = 'H'; /* invalid, modifying function call's result */

Forgot to ask you one more question.
The left operand of assignment operator should be an Lvalue, but in
this case it is an rvalue, but the compiler doesn't complain that
"Lvalue required". So can I conclude that a structure containing an
array type returned by a function is converted from Rvalue to Lvalue!

funTest().a[0] is short for *(funTest().a + 0).

funTest().a is an rvalue array, funTest().a + 0 is an rvalue pointer,
and *(funTest().a + 0) is a dereferenced pointer. Any dereferenced
pointer is an lvalue. There is no rvalue-to-lvalue conversion that
takes place.

The difference can matter:

struct S {
Â* Â* char m[1];};

struct S s;
struct S f(void) {
Â* Â* return s;}

int main(void) {
Â* Â* char *p;
Â* Â* p = s.m; /* valid */
Â* Â* p = (char *) &s.m; /* valid */
Â* Â* p = f().m; /* valid (but useless) */
Â* Â* p = (char *) &f().m; /* invalid */

}

The last statement is invalid because f().m is not an lvalue, so you
cannot apply to & operator to it. (The compiler I'm trying right now
disagrees with me; I might be wrong on this.)

Thanks, You are right.
My compiler Dev-CPP, gives Lvalue required error for the statement:
p = (char *) &f().m; /* invalid */

And I think it is even more "intelligen t" enough to point out that the
statement:
p = f().m; /* valid (but useless) */
is useless and generates an error "invalid use of non-lvalue array"!

Now I modified the Code u gave:
#include <stdio.h>
struct S {
char m[1];
};
struct S s;
struct S f(void) {

return s;

}
int main(void) {
char *p;
printf("%s",(ch ar*)f().m);/*Note Explicit casting to (char*) */

}

I know that I'm invoking UB by the following statement, if executed,:

printf("%s",(ch ar*)f().m);/* Note Explicit casting to (char*) */

But the above statement is not compiling and gives an error:

"cannot convert to a pointer type"

But C standard guarantees that any pointer can be converted to (char*)
and back without causing any error or UB.
So I guess the assertion, "expression f().m is evaluated to yield an
rvalue pointer" is wrong and it remains as an rvalue array type only,
which is further clarified by the following code:
struct S {
char m[1];
};
struct S s;
struct S f(void) {

return s;

}
int main(void) {
char *p;
*(f().m+0) = 'a';/*Compiler complains*/

}

Compiler gives an error corresponding to the line:
*(f().m+0) = 'a';/*Compiler complains*/
The error is
"invalid operands to binary + "
which is possible only when f().m is an array type and not a pointer
type as we might think. So there is no conversion from array type to
pointer type here, *though C standard requires it*!

But, how the expression statement:
f().m[0] = 'a';
gets executed when f().m is not converted to pointer type?

Note that when we give statement like the following:

printf("%s",f() .m);/* I am invoking a UB, but leave it! */

The compiler compiles without any error because printf() is a variable
argument function and there is no way to check the type of each
argument, though there is no possibility of passing an array as such
in C!(except in this case, I guess!)

Do reply about my comments and correct me if I'm wrong.

[Rajesh S R]

On Mar 10, 10:02Â*pm, "Harald van Dijk" <true...@gmail. comwrote:

On Mar 10, 12:03 pm, "SRR" <SRRajesh1...@g mail.comwrote:

On Mar 10, 2:51 pm, "Harald van Dijk" <true...@gmail. comwrote:

funTest().a[0] = 'H'; /* invalid, modifying function call's result */

Forgot to ask you one more question.
The left operand of assignment operator should be an Lvalue, but in
this case it is an rvalue, but the compiler doesn't complain that
"Lvalue required". So can I conclude that a structure containing an
array type returned by a function is converted from Rvalue to Lvalue!

funTest().a[0] is short for *(funTest().a + 0).

funTest().a is an rvalue array, funTest().a + 0 is an rvalue pointer,
and *(funTest().a + 0) is a dereferenced pointer. Any dereferenced
pointer is an lvalue. There is no rvalue-to-lvalue conversion that
takes place.

The difference can matter:

struct S {
Â* Â* char m[1];};

struct S s;
struct S f(void) {
Â* Â* return s;}

int main(void) {
Â* Â* char *p;
Â* Â* p = s.m; /* valid */
Â* Â* p = (char *) &s.m; /* valid */
Â* Â* p = f().m; /* valid (but useless) */
Â* Â* p = (char *) &f().m; /* invalid */

}

The last statement is invalid because f().m is not an lvalue, so you
cannot apply to & operator to it. (The compiler I'm trying right now
disagrees with me; I might be wrong on this.)

Sorry, I forgot to mention an important thing.
I recently subscribed to this group and I gave my full name
Rajesh S R
for subscription, which is abbreviated as SRR in the above posts!
So dont get confused by the new name in the recent post!!

I know that, what I said just now might be irrelevant, but I dont want
to confuse people unnecessarily!!

[=?utf-8?B?SGFyYWxkIHZhbiBExLNr?=]

Rajesh S R wrote:

On Mar 10, 10:02Â*pm, "Harald van Dijk" <true...@gmail. comwrote:

On Mar 10, 12:03 pm, "SRR" <SRRajesh1...@g mail.comwrote:

On Mar 10, 2:51 pm, "Harald van Dijk" <true...@gmail. comwrote:
funTest().a[0] = 'H'; /* invalid, modifying function call's result */

Forgot to ask you one more question.
The left operand of assignment operator should be an Lvalue, but in
this case it is an rvalue, but the compiler doesn't complain that
"Lvalue required". So can I conclude that a structure containing an
array type returned by a function is converted from Rvalue to Lvalue!

funTest().a[0] is short for *(funTest().a + 0).

funTest().a is an rvalue array, funTest().a + 0 is an rvalue pointer,
and *(funTest().a + 0) is a dereferenced pointer. Any dereferenced
pointer is an lvalue. There is no rvalue-to-lvalue conversion that
takes place.

The difference can matter:

struct S {
Â* Â* char m[1];};

struct S s;
struct S f(void) {
Â* Â* return s;}

int main(void) {
Â* Â* char *p;
Â* Â* p = s.m; /* valid */
Â* Â* p = (char *) &s.m; /* valid */
Â* Â* p = f().m; /* valid (but useless) */
Â* Â* p = (char *) &f().m; /* invalid */

}

The last statement is invalid because f().m is not an lvalue, so you
cannot apply to & operator to it. (The compiler I'm trying right now
disagrees with me; I might be wrong on this.)

Thanks, You are right.
My compiler Dev-CPP, gives Lvalue required error for the statement:
p = (char *) &f().m; /* invalid */

And I think it is even more "intelligen t" enough to point out that the
statement:
p = f().m; /* valid (but useless) */
is useless and generates an error "invalid use of non-lvalue array"!

Yes, I now see that too that I'm using GCC. It converts non-lvalue
arrays to pointers only in C99 mode (using the -std=c99 command-line
option). I missed that it's new in C99, but Chris Torek explained it
quite well. This also applies to the rest of your post.