About the typecasting to the LHS

[parag_paul]

Can this be done
float a;
(int) a = getc();

[Keith Thompson]

Richard Heathfield <rj*@see.sig.in validwrites:

pa********@hotm ail.com said:

>I am not trying anything.
just trying to understand the scope of typecasting on the left side.

A cast doesn't of itself yield a modifiable lvalue, so the result of a cast
expression cannot of itself receive an assignment.

>Since I saw some code similar to that.

Then it wasn't, strictly speaking, C code.

>I was confused initially.
But do you see any potential for the above construct.

Er, no, none at all. Do you? What do you think such a construct would mean?
C doesn't offer a meaning for it, so what meaning do you think it should
have?

[...]

It has no meaning in standard C. That doesn't mean that it has no
*possible* meaning. A compiler may legally implement casts as lvalues
as an extension, as long as it defines the semantics.

gcc does this, though current versions warn about it: "warning: use of
cast expressions as lvalues is deprecated". Note that this means only
it's deprecated *by gcc*; it's never been valid in standard C.

It's a fairly silly extension, since whatever it's supposed to do,
there are clearer ways to do the same thing in standard C. Presumably
the gcc folks realized this and decided to deprecate it.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <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."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[¬a\\/b]

In data Thu, 11 Oct 2007 05:30:33 -0700, parag_paul scrisse:

>I am not trying anything.
just trying to understand the scope of typecasting on the left side.
Since I saw some code similar to that.

I was confused initially.
But do you see any potential for the above construct.

@(all who are talking about lvalue)

I am a bit familiar with the concept myself. Just trying to get an
insight from the others on the casting on the left.

the cast on the left has a sense only where there is something like
*( obj *)

int b=0;
*(char*)&b=33;

it is not portable etc but sometime is useful

or in the case of compare function for qsort

than it can be useful for write things like

int i;

if( (unsigned)iINT_ MAX) ...

in the case INT_MAX is "traslated" to unsigned integer

[Keith Thompson]

"¬a\\/b" <[e-mail] :

In data Thu, 11 Oct 2007 05:30:33 -0700, parag_paul scrisse:

>>I am not trying anything.
just trying to understand the scope of typecasting on the left side.
Since I saw some code similar to that.

I was confused initially.
But do you see any potential for the above construct.

@(all who are talking about lvalue)

I am a bit familiar with the concept myself. Just trying to get an
insight from the others on the casting on the left.

the cast on the left has a sense only where there is something like
*( obj *)

int b=0;
*(char*)&b=33;

it is not portable etc but sometime is useful

or in the case of compare function for qsort

than it can be useful for write things like

int i;

if( (unsigned)iINT_ MAX) ...

in the case INT_MAX is "traslated" to unsigned integer

I usually ignore you, but here you've made a simple error. Neither of
your examples is relevant to the discussion, since neither one
attempts to use a cast as an lvalue.

In the first case, ``*(char*)&b=33 ;'', the cast appears as part of the
expression on the LHS of the assignment, but the full LHS is a
dereference, not a cast. In the second, ``(unsigned)iIN T_MAX'', the
cast is the LHS of the ">" operator, not of an assignment.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <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."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[¬a\\/b]

In data Sat, 13 Oct 2007 14:27:13 -0700, Keith Thompson scrisse:

>"¬a\\/b" <[e-mail] :

>In data Thu, 11 Oct 2007 05:30:33 -0700, parag_paul scrisse:

>>>I am not trying anything.
just trying to understand the scope of typecasting on the left side.
Since I saw some code similar to that.

I was confused initially.
But do you see any potential for the above construct.

@(all who are talking about lvalue)

I am a bit familiar with the concept myself. Just trying to get an
insight from the others on the casting on the left.

the cast on the left has a sense only where there is something like
*( obj *)

int b=0;
*(char*)&b=3 3;

it is not portable etc but sometime is useful

or in the case of compare function for qsort

than it can be useful for write things like

int i;

if( (unsigned)iINT_ MAX) ...

in the case INT_MAX is "traslated" to unsigned integer

I usually ignore you, but here you've made a simple error. Neither of
your examples is relevant to the discussion, since neither one
attempts to use a cast as an lvalue.

In the first case, ``*(char*)&b=33 ;'', the cast appears as part of the
expression on the LHS of the assignment, but the full LHS is a
dereference, not a cast. In the second, ``(unsigned)iIN T_MAX'', the
cast is the LHS of the ">" operator, not of an assignment.

so where is the differece in your gcc exenstion from
int a=0;
*(char*)&a=43;

and the code
int a=0;
(char)a=43;

[Keith Thompson]

"¬a\\/b" <[e-mail] :

In data Sat, 13 Oct 2007 14:27:13 -0700, Keith Thompson scrisse:

>>"¬a\\/b" <[e-mail] :

[...]

>>it is not portable etc but sometime is useful

or in the case of compare function for qsort

than it can be useful for write things like

int i;

if( (unsigned)iINT_ MAX) ...

in the case INT_MAX is "traslated" to unsigned integer

I usually ignore you, but here you've made a simple error. Neither of
your examples is relevant to the discussion, since neither one
attempts to use a cast as an lvalue.

In the first case, ``*(char*)&b=33 ;'', the cast appears as part of the
expression on the LHS of the assignment, but the full LHS is a
dereference , not a cast. In the second, ``(unsigned)iIN T_MAX'', the
cast is the LHS of the ">" operator, not of an assignment.

so where is the differece in your gcc exenstion from
int a=0;
*(char*)&a=43;

and the code
int a=0;
(char)a=43;

It's not *my* gcc extension.

In standard C, a cast is not an lvalue. ``*(char*)&a=42 '' is legal;
the cast expression ``(char*)&a'' is the operand of the unary "*"
operator, so it doesn't need to be an lvalue. In ``(char*)a=43'' the
cast is the left operand of an assignment operator, which must be an
lvalue; this is illegal in standard C, but allowed if the compiler
allows casts as lvalues as an extension.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <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."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Ben Pfaff]

Kenneth Brody <ke******@spamc op.netwrites:

Then, of course, there is the deprecated(?) "=&" operator.

The =op forms of assignment were listed as anachronisms even in
K&R1, and they aren't in C89 or C99 at all.
--
char a[]="\n .CJacehknorstu" ;int putchar(int);in t main(void){unsi gned long b[]
={0x67dffdff,0x 9aa9aa6a,0xa77f fda9,0x7da6aa6a ,0xa67f6aaa,0xa a9aa9f6,0x11f6} ,*p
=b,i=24;for(;p+ =!*p;*p/=4)switch(0[p]&3)case 0:{return 0;for(p--;i--;i--)case+
2:{i++;if(i)bre ak;else default:continu e;if(0)case 1:putchar(a[i&15]);break;}}}

[=?iso-2022-kr?q?=1B=24=29CHarald_van_D=0E=29=26=0F]

On Mon, 15 Oct 2007 10:31:48 -0700, Ben Pfaff wrote:

Kenneth Brody <ke******@spamc op.netwrites:

>Then, of course, there is the deprecated(?) "=&" operator.

The =op forms of assignment were listed as anachronisms even in K&R1,
and they aren't in C89 or C99 at all.

Right, and as a result, x=&a is valid C89 and C99, takes the address of
a, and assigns that pointer value to x. If =& were still a single
operator, it would be equally valid, but with a completely different
meaning.

[Ben Pfaff]

Harald van Dijk <tr*****@gmail. comwrites:

On Mon, 15 Oct 2007 10:31:48 -0700, Ben Pfaff wrote:

>Kenneth Brody <ke******@spamc op.netwrites:

>>Then, of course, there is the deprecated(?) "=&" operator.

The =op forms of assignment were listed as anachronisms even in K&R1,
and they aren't in C89 or C99 at all.

Right, and as a result, x=&a is valid C89 and C99, takes the address of
a, and assigns that pointer value to x. If =& were still a single
operator, it would be equally valid, but with a completely different
meaning.

I don't think that "x = &a" and "x &= a" can both be valid for
any given "x" and "a".
--
char a[]="\n .CJacehknorstu" ;int putchar(int);in t main(void){unsi gned long b[]
={0x67dffdff,0x 9aa9aa6a,0xa77f fda9,0x7da6aa6a ,0xa67f6aaa,0xa a9aa9f6,0x11f6} ,*p
=b,i=24;for(;p+ =!*p;*p/=4)switch(0[p]&3)case 0:{return 0;for(p--;i--;i--)case+
2:{i++;if(i)bre ak;else default:continu e;if(0)case 1:putchar(a[i&15]);break;}}}

[=?iso-2022-kr?q?=1B=24=29CHarald_van_D=0E=29=26=0F]

On Mon, 15 Oct 2007 12:50:50 -0700, Ben Pfaff wrote:

Harald van Dijk <tr*****@gmail. comwrites:

>On Mon, 15 Oct 2007 10:31:48 -0700, Ben Pfaff wrote:

>>Kenneth Brody <ke******@spamc op.netwrites:

Then, of course, there is the deprecated(?) "=&" operator.

The =op forms of assignment were listed as anachronisms even in K&R1,
and they aren't in C89 or C99 at all.

Right, and as a result, x=&a is valid C89 and C99, takes the address of
a, and assigns that pointer value to x. If =& were still a single
operator, it would be equally valid, but with a completely different
meaning.

I don't think that "x = &a" and "x &= a" can both be valid for any given
"x" and "a".

#include <stdbool.h>

int main(void) {
bool x, a = 0;
x = &a;
x &= a;
return x;
}

Perfectly valid C99 :)

But you are probably correct in C89.

[Kenneth Brody]

$)CHarald van D)&k wrote:

>
On Mon, 15 Oct 2007 12:50:50 -0700, Ben Pfaff wrote:

[...]

I don't think that "x = &a" and "x &= a" can both be valid for any given
"x" and "a".

#include <stdbool.h>

int main(void) {
bool x, a = 0;
x = &a;
x &= a;
return x;
}

Perfectly valid C99 :)

But you are probably correct in C89.

What type is "bool" that it can point to itself? Why doesn't
"x = &a" give a warning for converting "bool *" to "bool"?

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