About the typecasting to the LHS

[parag_paul]

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

[Walter Roberson]

In article <11************ *********@o80g2 000hse.googlegr oups.com>,
pa********@hotm ail.com <pa********@hot mail.comwrote:

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

No, but you could do

(int) (a = getc());

In C, assignments are expressions, so this would do the assignment
first, convert the resulting double to int, and then (because there
is nothing else on the line) throw away the int.

What were you hoping (int) a = getc() to mean? On a number of
platforms, float arithmetic (e.g., silently converting the int returned
by getc() into a float for the assignment) takes place only in
special purpose floating-point registers which cannot be manipulated
as integers.
--
"Beware of bugs in the above code; I have only proved it correct,
not tried it." -- Donald Knuth

[Kenneth Brody]

"pa********@hot mail.com" wrote:

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

No. (Check your manual and/or this group's archives for a description
of "l-value".)

Well, that and getc() needs a FILE* as an argument. Perhaps you meant
getchar()?

You could use:

a = (float)getchar( );

However, the cast to float is unnecessary.

What, exactly, are you _really_ trying to do?

--
+-------------------------+--------------------+-----------------------+
| 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>

[santosh]

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

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

No. What exactly are you trying to do? Since getc returns an int, assigning
it into floating type and trying to cast it to an int again seems pretty
pointless to me.

[Keith Thompson]

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

"pa********@hot mail.com" wrote:

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

No. (Check your manual and/or this group's archives for a description
of "l-value".)

"lvalue", without the hyphen, is likely to be a better search term.

--
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, 04 Oct 2007 07:38:18 -0700, parag_paul@ scrisse:

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

float a;
a=getchar();
i think it is be done

[parag_paul]

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.

[Richard Heathfield]

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?

@(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.

I think you need to consider more carefully the responses that you've
received so far. They're telling you something important, but you don't
seem to be getting it. Where a is a float, the expression (int)a = getc()
is simply meaningless. It's not legal C. Not even if we replace getc with
getchar.

Let's see what the compiler makes of it:

me@here:~/scratchcat foo.c
#include <stdio.h>

int main(void)
{
float FloatingPointOb ject;
(int)FloatingPo intObject = getchar();
printf("%f\n", FloatingPointOb ject);
return 0;
}

me@here:~/scratchmake
gcc -W -Wall -ansi -pedantic -Wformat-nonliteral -Wcast-align
-Wpointer-arith -Wbad-function-cast -Wmissing-prototypes
-Wstrict-prototypes -Wmissing-declarations -Winline -Wundef
-Wnested-externs -Wcast-qual -Wshadow -Wconversion -Wwrite-strings
-ffloat-store -O2 -g -pg -c -o foo.o foo.c
foo.c: In function `main':
foo.c:6: warning: ANSI C forbids use of cast expressions as lvalues
foo.c:6: warning: value computed is not used

You see? You're just not supposed to do that.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Eric Sosman]

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

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.

Remember this: The cast operator is an *operator*. Like
other operators, it takes operands (one, for a cast) and yields
a value. A *value*, not an assignable object.

Given `double x;', all these are nonsense in the same way:

(int)x = 42;
-x = 42;
tan(x) = 42;
&x = malloc(sizeof x);

Clearer now?

--
Eric Sosman
es*****@ieee-dot-org.invalid

[Richard Tobin]

In article <Kq************ *************** ***@comcast.com >,
Eric Sosman <es*****@ieee-dot-org.invalidwrot e:

Remember this: The cast operator is an *operator*. Like
other operators, it takes operands (one, for a cast) and yields
a value. A *value*, not an assignable object.

Several operators yield assignable values, * for example, so remembering
that a cast is an operator doesn't necessarily help.

-- Richard
--
"Considerat ion shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.