What exactly is lvalue & rvalue (old c.l.c. posts are all over the map)?

[Romeo Colacitti]

Hi,

Does anyone here have a strong understanding for the meanings of the
terms "lvalue" and "rvalue" as it pertains to C, objects, and different
contexts? If so please share.

I've been reading several old posts/threads on the subject, and they
never end with a conclusion (people keep correcting each other and
disagreeing).

My take on it is that an "lvalue" is an expression that refers to an
object (which can have (a) value(s) within it), and "rvalue" is an
expression that only has a value (ephemeral value as Chris Torek would
claim) and no association with an object.

As far as their use, an "lvalue" that refers to an object of type T,
can be used anwhere an "rvalue" that that has a type T can be, but not
vice versa. So if one uses an lvalue that refers to an int variable in
an context that requires an int value, then simply the value sitting in
the object is dumped into that context.

Is this a fair description?

[Christian Bau]

In article <42******@212.6 7.96.135>, "Bart C" <[e-mail] m> wrote:

"Romeo Colacitti" <ww*****@gmail. com> wrote in message
news:11******** **************@ c13g2000cwb.goo glegroups.com.. .

Hi,

Does anyone here have a strong understanding for the meanings of the
terms "lvalue" and "rvalue" as it pertains to C, objects, and different
contexts? If so please share.

I've been reading several old posts/threads on the subject, and they
never end with a conclusion (people keep correcting each other and
disagreeing).

I always thought an lvalue was something you could take the address of using
&.

So an assignment like:

a=b;

could be rewritten as:

*(&a)=b;

if a was a legal lvalue. If you can't then 'a' (whatever it might be) is not
an lvalue.

Bitfields can be lvalues, but you can't take the address of a bitfield.

[Christian Bau]

In article
<ch************ *************** ******@slb-newsm1.svr.pol. co.uk>,
Christian Bau <ch***********@ cbau.freeserve. co.uk> wrote:

In article <42******@212.6 7.96.135>, "Bart C" <[e-mail] m> wrote:

"Romeo Colacitti" <ww*****@gmail. com> wrote in message
news:11******** **************@ c13g2000cwb.goo glegroups.com.. .

Hi,

Does anyone here have a strong understanding for the meanings of the
terms "lvalue" and "rvalue" as it pertains to C, objects, and different
contexts? If so please share.

I've been reading several old posts/threads on the subject, and they
never end with a conclusion (people keep correcting each other and
disagreeing).

I always thought an lvalue was something you could take the address of using
&.

So an assignment like:

a=b;

could be rewritten as:

*(&a)=b;

if a was a legal lvalue. If you can't then 'a' (whatever it might be) is not
an lvalue.

Bitfields can be lvalues, but you can't take the address of a bitfield.

And I forgot: Functions are most definitely not lvalues, but you can
take the address of a function.

[Ivan A. Kosarev]

Christian,
You wrote on Sun, 06 Feb 2005 22:53:25 +0000:

> So an assignment like:
> a=b;
> could be rewritten as:
> *(&a)=b;
> if a was a legal lvalue. If you can't then 'a' (whatever it might

be) is not an lvalue.
Bitfields can be lvalues, but you can't take the address of a
bitfield.

CB> And I forgot: Functions are most definitely not lvalues, but you can
CB> take the address of a function.

You also forgot that there are non-modifiable lvalues like those that are
const-qualified or that have incomplete types.

--
Ivan

Unicals Group -- Your own commercial high-quality C99 front end for US $1
http://unicals.com/own-business.html

[Christian Bau]

In article <36************ *@individual.ne t>,
"Ivan A. Kosarev" <ik******@onlin e.ru> wrote:

Christian,
You wrote on Sun, 06 Feb 2005 22:53:25 +0000:

-- Re-inserted original post here:

"Romeo Colacitti" <ww*****@gmail. com> wrote in message
news:11******** **************@ c13g2000cwb.goo glegroups.com.. .

Hi,

Does anyone here have a strong understanding for the meanings of the
terms "lvalue" and "rvalue" as it pertains to C, objects, and different
contexts? If so please share.

I've been reading several old posts/threads on the subject, and they
never end with a conclusion (people keep correcting each other and
disagreeing).

I always thought an lvalue was something you could take the address of using
&.
-- End of re-inserted original post

> So an assignment like:
> a=b;
> could be rewritten as:
> *(&a)=b;
> if a was a legal lvalue. If you can't then 'a' (whatever it might
be) is not an lvalue.
Bitfields can be lvalues, but you can't take the address of a
bitfield.

CB> And I forgot: Functions are most definitely not lvalues, but you can
CB> take the address of a function.

You also forgot that there are non-modifiable lvalues like those that are
const-qualified or that have incomplete types.

Looks like I didn't forget anything; you just snipped the part of the
original post that I answered to.

[Kenneth Bull]

Kobu wrote:

Luke Wu wrote:

When an lvalue is used in an "general object context," then the lvalue

is directly acted upon (no conversion to an rvalue takes place).
Examples are & and sizeof.

sizeof takes more than lvalues, consider...

sizeof(int *)
sizeof('A')
sizeof(33.029e-3LD)

so are types and constants objects too (note, size of directly taking
the objects as input above, not just lvalues that refer to the

objects)

here is another example

sizeof("String Literal")

here, size is receiving only a pointer to the first element of the
string ('S'), so its equivalent to: sizeof(char *)

but that's not what we get, sizeof actually returns the size of the
whole string literal

I don't think sizeof fits cleanly with the theory of lvalues/rvalues.

Sizeof is an operator that can take two types of operands:

- types
- expressions(if lvalue expression, gives the size of the entire object
designated by the lvalue, if rvalue expression, gives the size of
object required to properly hold the rvalue)

When considering the sizeof(exp) syntax's behaviour, one might be
tempted to call this an example of an "object context." I argue that it
incorrect to say that sizeof(exp) is a case of "lvalue/object context."
Even though no lvalue-to-rvalue substitution takes plac for lvalue
expression, the fact that rvalues can be operands too should forbit us
from calling it an "object context." It is neither an "object context"
or a "value context", but rather a "makes no assumptions or
substitutions, operates directly on what you hand it CONTEXT"

This is why sizeof('A') works, not because 'A' is an lvalue or object
(constants are not objects).

[Kenneth Brody]

Romeo Colacitti wrote:

Hi,

Does anyone here have a strong understanding for the meanings of the
terms "lvalue" and "rvalue" as it pertains to C, objects, and different
contexts? If so please share.

[...]

The simplest way to think of them would probably be:

An lvalue can go on the left of an assignment statement, and an
rvalue can go on the right. (Hence "l" and "r".)

--
+-------------------------+--------------------+-----------------------------+
| Kenneth J. Brody | www.hvcomputer.com | |
| kenbrody/at\spamcop.net | www.fptech.com | #include <std_disclaimer .h> |
+-------------------------+--------------------+-----------------------------+
Don't e-mail me at: <mailto:Th***** ********@gmail. com>

[Bart C]

"Christian Bau" <ch***********@ cbau.freeserve. co.uk> wrote in message
news:ch******** *************** **********@slb-newsm1.svr.pol. co.uk...
....

In article <42******@212.6 7.96.135>, "Bart C" <[e-mail] m> wrote:

> I always thought an lvalue was something you could take the address of
> using
> &.

.... Bitfields can be lvalues, but you can't take the address of a bitfield.

And I forgot: Functions are most definitely not lvalues, but you can
take the address of a function.

I think I'm still right apart from these two exceptions..

Bart

[pete]

Kenneth Bull wrote:

Sizeof is an operator that can take two types of operands:

- types
- expressions

The types must be object types
and the expressions must be expressions of object type.

--
pete

[pete]

Christian Bau wrote:

In article
<ch************ *************** ******@slb-newsm1.svr.pol. co.uk>,
Christian Bau <ch***********@ cbau.freeserve. co.uk> wrote:

In article <42******@212.6 7.96.135>, "Bart C" <[e-mail] m> wrote:

"Romeo Colacitti" <ww*****@gmail. com> wrote in message
news:11******** **************@ c13g2000cwb.goo glegroups.com.. .
> Hi,
>
> Does anyone here have a strong understanding for
> the meanings of the
> terms "lvalue" and "rvalue" as it pertains to C,
> objects, and different
> contexts? If so please share.
>
> I've been reading several old posts/threads on the subject,
> and they
> never end with a conclusion
> (people keep correcting each other and
> disagreeing).

I always thought an lvalue was something you could
take the address of using
&.

So an assignment like:

a=b;

could be rewritten as:

*(&a)=b;

if a was a legal lvalue.
If you can't then 'a' (whatever it might be) is not
an lvalue.

Bitfields can be lvalues,
but you can't take the address of a bitfield.

And I forgot: Functions are most definitely not lvalues, but you can
take the address of a function.

register qualified variables are lvalues without addresses.

--
pete

[Romeo Colacitti]

Kenneth Bull wrote:

There are normal objects, and anonymous objects.

A search for the term - anonymous - in the C standard came up with 0
results.

Explanation for malloc does say that it allocates AN OBJECT.
Explanation for calloc does say that it allocates AN ARRAY OF OBJECTS.
No mention of anonymous though.

I've come to the conclusion that the C language (and it's standard) has
so many exceptions, loopholes and gray areas that it's better to learn
and see all the cases than to try to understand the definitions and
rules within the standard.

I bet every C programmer has a different idea for what all these terms
mean, but all experts have seen all the cases/uses enough to understand
things deep enough not to care for exact definitions. Such a
frustrating language, but I can't live without it :-)