Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > what does this double conversion mean (unsigned long)(unsigned int)

Reply
Thread Tools

what does this double conversion mean (unsigned long)(unsigned int)

 
 
CFAN
Guest
Posts: n/a
 
      04-03-2007

Here is a example of double-type-conversion
char * __cdecl _itoa (
int val,
char *buf,
int radix
)
{
if (radix == 10 && val < 0)
xtoa((unsigned long)val, buf, radix, 1);
else
xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
return buf;
}

and why need this type of conversion

 
Reply With Quote
 
 
 
 
Richard Bos
Guest
Posts: n/a
 
      04-03-2007
"CFAN" <(E-Mail Removed)> wrote:

> Here is a example of double-type-conversion


Which is silly.

> char * __cdecl _itoa (

This ^^^^^^^ does not exist at all in C, and shouldn't be
there, and this ^^^^^ is an identifier which you're not allowed to use
for a function name.

> int val,
> char *buf,
> int radix
> )


Unless you put comments after the parameters, this is a painfully stupid
way to lay out a function parameter list.

> {
> if (radix == 10 && val < 0)
> xtoa((unsigned long)val, buf, radix, 1);

This function ^^^^ does not exist in ISO C, and
this cast ^^^^^^^^^^^^^^^ is completely unnecessary or even
wrong unless xtoa() is declared unwisely or not at all.
If xtoa(), as defined by your program, takes an unsigned long as its
first argument, that cast should be unnecessary; if it doesn't, that
cast does the wrong thing.

> else
> xtoa((unsigned long)(unsigned int)val, buf, radix, 0);

As well as the above, ^^^^^^^^^^^^^^^^^^^^^^^^^^ these casts are
completely mindless. Or rather, they should be. One can dream up
imaginary scenarios in which they do something good, to do with the edge
cases of negative values passed to functions expecting small, not large,
positive ones, but really, write proper functions. And then document why
they cast.

> return buf;
> }
>
> and why need this type of conversion


You shouldn't.

Richard
 
Reply With Quote
 
 
 
 
Kenneth Brody
Guest
Posts: n/a
 
      04-03-2007
CFAN wrote:
>
> Here is a example of double-type-conversion

[...]
> int val,

[...]
> xtoa((unsigned long)val, buf, radix, 1);


Here, if val is negative, and sizeof(long)>sizeof(int), the conversion
from int to unsigned long will sign-extend the int before treating
the result as unsigned.

> else
> xtoa((unsigned long)(unsigned int)val, buf, radix, 0);


Here, val will not be sign-extended, as you are telling the compiler
to treat the value as unsigned, and then convert to unsigned long.

[...]
> and why need this type of conversion


Is there a reason you need to convert a signed int to an unsigned
long? If you can think of a reason why you need to do such a
conversion, and control the sign-extending aspects, then you will
have your answer.

--
+-------------------------+--------------------+-----------------------+
| Kenneth J. Brody | www.hvcomputer.com | #include |
| kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer.h> |
+-------------------------+--------------------+-----------------------+
Don't e-mail me at: <(E-Mail Removed)>


 
Reply With Quote
 
Eric Sosman
Guest
Posts: n/a
 
      04-03-2007
CFAN wrote On 04/03/07 08:05,:
> Here is a example of double-type-conversion
> char * __cdecl _itoa (
> int val,
> char *buf,
> int radix
> )
> {
> if (radix == 10 && val < 0)
> xtoa((unsigned long)val, buf, radix, 1);
> else
> xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
> return buf;
> }
>
> and why need this type of conversion


Suppose you're using a system where unsigned long is
wider than unsigned int -- 32 and 16 bits, for example.
Suppose also that `val' is negative one. Then

(unsigned long)val == 4294967295ul
(unsigned int)val == 65535u
(unsigned long)(unsigned int)val == 65535ul

In the code above, I'd guess that the xtoa() function
takes an unsigned long as its first argument. There may
or may not be a prototype for xtoa() in scope; if there
is, both (unsigned long) casts are unnecessary because the
compiler would perform the conversion automatically. But
a direct conversion from int to unsigned long could give a
different result than conversion from int to unsigned int
and then to unsigned long; perhaps the programmer wants
to avoid the huge numbers that a negative `val' would yield
if converted directly.

I have no idea why "base 10, negative" is treated
differently from "base 8, positive." That's something
you'll need to ask the programmer about.

--
http://www.velocityreviews.com/forums/(E-Mail Removed)
 
Reply With Quote
 
William Hughes
Guest
Posts: n/a
 
      04-03-2007
On Apr 3, 8:05 am, "CFAN" <(E-Mail Removed)> wrote:
> Here is a example of double-type-conversion
> char * __cdecl _itoa (
> int val,
> char *buf,
> int radix
> )
> {
> if (radix == 10 && val < 0)
> xtoa((unsigned long)val, buf, radix, 1);
> else
> xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
> return buf;
>
> }
>
> and why need this type of conversion


This code(possibly) makes implementation specific assumptions
and uses the implementation name space (on the other hand
it may be part of an implementation).


Consider the case where long and int do not have the same size
(say int is 16 bits and long is 32)

then
(unsigned int) (-1) = 0xFFFFFFFF



(unsigned long) (-1) = 0xFFFFFFFFFFFFFFFF

So if you want _itoa to print out FFFFFFFF when passed a signed int
value -1 and a radix of 16, you need the double cast.

If long and int have the same size then the cast is unneeded but
harmless.

The code assumes that if you are printing in decimal you want
to print out negative integers, but if you are printing in something
else you only use positive integers, so if something looks like a
negative
integer it is really a big positive integer (but no bigger than an
int).

A couple of comments would be a GOOD THING.

- William Hughes

 
Reply With Quote
 
Martin Ambuhl
Guest
Posts: n/a
 
      04-03-2007
CFAN wrote:
> Here is a example of double-type-conversion
> char * __cdecl _itoa (
> int val,
> char *buf,
> int radix
> )
> {
> if (radix == 10 && val < 0)
> xtoa((unsigned long)val, buf, radix, 1);
> else
> xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
> return buf;
> }
>
> and why need this type of conversion


You don't. See if the following answers your question:
#include <stdio.h>
#include <limits.h>

/* mha: Let's first give a prototype for the non-standard function
xtoa */
inline void xtoa(unsigned long, char *, int, int);

/* mha: remove meaningless invasion of implementation namespace __cdecl,
rename similar _itoa */
char *tst_itoa(int val, char *buf, int radix)
{
if (radix == 10 && val < 0)
/* mha: remove useless cast */
xtoa(val, buf, radix, 1);
else
/* mha: remove useless casts */
xtoa(val, buf, radix, 0);
return buf;
}

/* mha: supply the missing non-standard xtoa */
inline void xtoa(unsigned long value, char *buffer, int unused1,
int unused2)
{
sprintf(buffer, "%lu", value);
}

/* mha: to make a complete compilable program: */
int main(void)
{
char buff[BUFSIZ];
unsigned long foo = ULONG_MAX;
tst_itoa(foo, buff, 10);
printf("For foo=%lu, tst_itoa filled buff with \"%s\"\n", foo,
buff);
return 0;
}


[output]
For foo=4294967295, tst_itoa filled buff with "4294967295"

 
Reply With Quote
 
Tor Rustad
Guest
Posts: n/a
 
      04-04-2007
CFAN wrote:
> Here is a example of double-type-conversion
> char * __cdecl _itoa (
> int val,
> char *buf,
> int radix
> )
> {
> if (radix == 10 && val < 0)
> xtoa((unsigned long)val, buf, radix, 1);
> else
> xtoa((unsigned long)(unsigned int)val, buf, radix, 0);
> return buf;
> }
>
> and why need this type of conversion
>


__cdecl specify the calling convention used by Microsoft C compilers,
look up their MSDN documentation, which is even available online AFAIK.

--
Tor
 
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
Beginner Q: What does the double underscore __ mean? StarPilgrim Python 6 09-10-2012 05:38 AM
weighted mean; weighted standard error of the mean (sem) C Barrington-Leigh Python 1 09-10-2010 02:03 AM
what does double free or corruption (!prev): mean? Thank u~ xiao C Programming 5 08-08-2008 06:48 PM
conversion double* to vector<double> and vice versa J.M. C++ 5 03-08-2007 03:45 PM
cannot convert parameter from 'double (double)' to 'double (__cdecl *)(double)' error Sydex C++ 12 02-17-2005 06:30 PM



Advertisments