Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > Lvalues and Rvalues

Reply
Thread Tools

Lvalues and Rvalues

 
 
ramasubramanian.rahul@gmail.com
Guest
Posts: n/a
 
      10-14-2006
i was reading soemthing about Lvalues Rvalues and modifiable
Lvalues....
i am confused now...
like for eg
int *y , x ;
y = &x ;
in the second is x a lvalue or rvalue
any pointers on some good reading on lvalues and rvalues on the web ??
thanks in advance
Kind Regard
rahul

 
Reply With Quote
 
 
 
 
Brian C
Guest
Posts: n/a
 
      10-14-2006
http://www.velocityreviews.com/forums/(E-Mail Removed) wrote:
> i was reading soemthing about Lvalues Rvalues and modifiable
> Lvalues....
> i am confused now...
> like for eg
> int *y , x ;
> y = &x ;
> in the second is x a lvalue or rvalue
> any pointers on some good reading on lvalues and rvalues on the web ??
> thanks in advance
> Kind Regard
> rahul
>

Well, there really isn't much to it, if I get where you're going. You
might want to read up on http://c-faq.com/ .... this is a general C-FAQ,
but you kind of asked a general question, so...
 
Reply With Quote
 
 
 
 
Keith Thompson
Guest
Posts: n/a
 
      10-14-2006
"(E-Mail Removed)" <(E-Mail Removed)> writes:
> i was reading soemthing about Lvalues Rvalues and modifiable
> Lvalues....
> i am confused now...
> like for eg
> int *y , x ;
> y = &x ;
> in the second is x a lvalue or rvalue
> any pointers on some good reading on lvalues and rvalues on the web ??


An "lvalue" is an expression that (potentially) designates an object.
The origin of the term is "left value", i.e., something that can
appear on the left side of an assignment statement (though not all
lvalues can actually appear on the left side of an assignment
statement).

In your example above:
y = &x;
both y and x are lvalues; the operand of a unary "&" must be an
lvalue, since "&" takes the address of an object. (It's not *quite*
that simple, but don't worry about it.)

A "modifiable lvalue" is an lvalue that refers to an object that can
be modified (for example, one that isn't declared as const).

The C standard doesn't actually use the term "rvalue". You can think
of an rvalue as any expression that isn't used as an lvalue, or
(loosely) as an expression that can appear on the right side of an
assignment.

--
Keith Thompson (The_Other_Keith) (E-Mail Removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.
 
Reply With Quote
 
SM Ryan
Guest
Posts: n/a
 
      10-14-2006
"(E-Mail Removed)" <(E-Mail Removed)> wrote:
# i was reading soemthing about Lvalues Rvalues and modifiable
# Lvalues....
# i am confused now...
# like for eg
# int *y , x ;
# y = &x ;
# in the second is x a lvalue or rvalue
# any pointers on some good reading on lvalues and rvalues on the web ??
# thanks in advance

Unfortunately except for Algol 68 and assmebly language,
variableness is left out of type systems, requiring instead
much verbal handwaving that could be more precise.

Borrowing & from C++ with restriction that a reference type
cannot be inside any other type, then when you declare a
scalar and array,
T v,w[n],*x;
v has type (&T), w has type (*T), and x has type (&*T).

Then the pointer/variable operator types are
v = e
v is coerceable to type &T
and e is coerceable to type T
and (v=e) is type T
*x
x is coercecable to *T
and *x is type &T
&v
v is coercecable to &T
and &v is type *T
s.f
If s is coercable to &T and f has nonreference type S,
(s.f) has type &S [endowed with subnames in Algol 68].
If s is not coercable to T and f has nonreference type S,
(s.f) has type S.
LOAD(v) is an implicit operator
v is coerceable to &T
and LOAD(v) is type T

Expressions q in the language is then applied to one of two implicit
functions LVALUE(q) or RVALUE(q)
LVALUE(q) = q and q must have type &T
RVALUE(q) = LOAD(q) if q has type &T
RVALUE(q) = q if q has type T which is not a reference type

The pointer/variable operator implicits are
LVALUE(v) = RVALUE(e)
* RVALUE(x)
& LVALUE(x)
s . f - There is no implicit on s.
A variable by itself has its declared type, T or &T.
All other expressions are
prefixop RVALUE(operand)
RVALUE(leftoperand) infixop RVALUE(rightoperand)
RVALUE(predicate) ? RVALUE(truebranch) : RVALUE(falsebranch)

GCC has an alternate rule for ?: - there is no implicit RVALUE or
LVALUE on the branches except they must be coerceable to a balanced
type T, T may be a reference type.
(p?v:*x) = e
LVALUE((RVALUE(p) ? v : *RVALUE(x))) = RVALUE(e)
with the types LVALUE(RVALUE(int) ? &T : *RVALUE(&*T)) = RVALUE(S)
LVALUE(RVALUE(int) ? &T : *(LOAD(&*T))) = S
LVALUE(RVALUE(int) ? &T : *(*T)) = S
LVALUE(RVALUE(int) ? &T : &T) = S
LVALUE(&T) = S
&T = S
and if S is coerceable to T, the assignment is valid in GCC,
but in ANSI C, the types are T=S which is invalid.

--
SM Ryan http://www.rawbw.com/~wyrmwif/
But I do believe in this.
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
lvalues and rvalues Nicklas Karlsson C Programming 127 05-05-2010 10:58 PM
casts and lvalues jacob navia C Programming 68 06-27-2007 03:32 PM
cv-qualified rvalues Steven T. Hatton C++ 1 12-14-2006 09:45 PM
rvalues and constant reference to a pointer ? amparikh@gmail.com C++ 6 06-08-2005 03:19 PM
string literal is an lvalue; other literals are rvalues. Steven T. Hatton C++ 11 04-20-2004 01:38 AM



Advertisments