how the following code works?

[Ravi]

main() {
float a = 5.375;
char *p;
int i;
p = (char*)&a;
for(i=0;i<=3;i+ +)
printf("%02x",( unsigned char)p);
}

the above code gives the binary representation of a.
how does it work?

[Dave Vandervies]

In article <11************ *********@e9g20 00prf.googlegro ups.com>,
Ravi <ra*********@gm ail.comwrote:

>main() {
float a = 5.375;
char *p;
int i;
p = (char*)&a;
for(i=0;i<=3;i ++)
printf("%02x", (unsigned char)p);
}

the above code gives the binary representation of a.
how does it work?

It doesn't.
dave
(it appears to be an attempt to examine the bytes representing an object
of floating-point types, but contains at least one obvious error, one
subtle error, and one gratuitious assumption.)

--
Dave Vandervies dj******@csclub .uwaterloo.ca
P.J. Plauger has a valid reason [...] although I would say that was
more to do with his customers being less than sensible.
--Flash Gordon in comp.lang.c

[pete]

Ravi wrote:

>
main() {
float a = 5.375;
char *p;
int i;
p = (char*)&a;
for(i=0;i<=3;i+ +)
printf("%02x",( unsigned char)p);
}

the above code gives the binary representation of a.
how does it work?

It doesn't work at all.

/* BEGIN new.c */

#include <stdio.h>

int main(void)
{
float a = 5.375;
unsigned char *p;
size_t i;

p = (unsigned char *)&a;
for (i = 0; i != sizeof a; ++i) {
printf("%02x ", p[i]);
}
putchar('\n');
return 0;
}

/* END new.c */
--
pete

[Malcolm McLean]

"Ravi" <ra*********@gm ail.comwrote in message
news:11******** *************@e 9g2000prf.googl egroups.com...

main() {
float a = 5.375;
char *p;
int i;
p = (char*)&a;
for(i=0;i<=3;i+ +)
printf("%02x",( unsigned char)p);
}

the above code gives the binary representation of a.
how does it work?

Let's rewrite slightly more professionally.

#include <stdio.h>

void dump(void *bytes, int N)
{
int i;
unsigned char *cbytes = bytes;

for(i=0;i<N;i++ )
printf("%02x", cbytes[i]);
printf("\n");
}

int main(void)
{
float a = 123.567;

dump(&a, sizeof(float));
return 0;
}

Now you ought to see how the program works. Plus you have a handy little
routine you can cut and paste any time you need to examine an object's
binary representation.

--
Free games and programming goodies.
http://www.personal.leeds.ac.uk/~bgy1mm

[CryptiqueGuy]

On Jun 16, 10:38 am, Ravi <ra.ravi....@gm ail.comwrote:

main() {
float a = 5.375;
char *p;
int i;
p = (char*)&a;
for(i=0;i<=3;i+ +)
printf("%02x",( unsigned char)p);

}

oops, you had taken liberty over the size of float!

>printf("%02x", (unsigned char)p);

Never know what you are trying to do by this statement.

>
the above code gives the binary representation of a.

No, it doesn't!
Moreover, even if you correct all the mistakes, I don't think you will
get the binary representation, unless CHAR_BIT==1,in which case your
implementation is non-conforming!

You will get only "byte representation" .

how does it work?

It doesn't work at all.

[Richard Heathfield]

Ravi said:

main() {
float a = 5.375;
char *p;
int i;
p = (char*)&a;
for(i=0;i<=3;i+ +)
printf("%02x",( unsigned char)p);
}

the above code gives the binary representation of a.
how does it work?

It doesn't.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at the above domain, - www.

[Army1987]

"pete" <pf*****@mindsp ring.comha scritto nel messaggio
news:46******** **@mindspring.c om...

Ravi wrote:

>>
main() {
float a = 5.375;
char *p;
int i;
p = (char*)&a;
for(i=0;i<=3;i ++)
printf("%02x", (unsigned char)p);
}

the above code gives the binary representation of a.
how does it work?

It doesn't work at all.

/* BEGIN new.c */

#include <stdio.h>

int main(void)
{
float a = 5.375;
unsigned char *p;
size_t i;

p = (unsigned char *)&a;
for (i = 0; i != sizeof a; ++i) {

Any reason to use != where the rest of the world uses <?
(Just curious, I know that *here* they do the same.)

printf("%02x ", p[i]);
}
putchar('\n');
return 0;
}

/* END new.c */
--
pete

[Harald van =?UTF-8?B?RMSzaw==?=]

Army1987 wrote:

"pete" <pf*****@mindsp ring.comha scritto nel messaggio
news:46******** **@mindspring.c om...

> for (i = 0; i != sizeof a; ++i) {

Any reason to use != where the rest of the world uses <?
(Just curious, I know that *here* they do the same.)

In such constructs I usually put != instead of < as well. It doesn't matter
here, and it's the same thing that would be required in just a slightly
different example:
for (p = start; p != NULL; p = p->next)

[Richard Tobin]

In article <f5**********@t di.cu.mi.it>, Army1987 <pl********@for .itwrote:

> for (i = 0; i != sizeof a; ++i) {

>Any reason to use != where the rest of the world uses <?

There is a theory that it's better to use "<", because if the variable
somehow gets to be bigger than the terminating value, the loop will
still stop. I believe this is sometimes considered to be "defensive
programming".

There is another theory that this is a really bad idea, because it will
hide bugs in your program (how did the variable get the bogus value?),
and you should instead use "!=" to make the error get noticed sooner.

From the point of view of readability, I think that "<" is more likely to
express the way the programmer is thinking about it - the terminating
value expresses the end of a range, rather than a sentinel value as
is "while(*p++ != '\0')".

So using "!=" seems to me to be in the same class of idioms as writing
"if(1 == a)" rather than "if(a == 1)" - it might sometimes result in
earlier error detection, but at the expense of naturalness and hence
readability.

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

[CBFalconer]

Harald van D?k wrote:

>
Army1987 wrote:

"pete" <pf*****@mindsp ring.comha scritto nel messaggio
news:46******** **@mindspring.c om...

for (i = 0; i != sizeof a; ++i) {

Any reason to use != where the rest of the world uses <?
(Just curious, I know that *here* they do the same.)

In such constructs I usually put != instead of < as well. It doesn't matter
here, and it's the same thing that would be required in just a slightly
different example:
for (p = start; p != NULL; p = p->next)

'<' is safer. If something glitches the value of i.

--
<http://www.cs.auckland .ac.nz/~pgut001/pubs/vista_cost.txt>
<http://www.securityfoc us.com/columnists/423>
<http://www.aaxnet.com/editor/edit043.html>
cbfalconer at maineline dot net

--
Posted via a free Usenet account from http://www.teranews.com