Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > cast from function call of type int to non-matching type double

Reply
Thread Tools

cast from function call of type int to non-matching type double

 
 
=?ISO-8859-1?Q?Martin_J=F8rgensen?=
Guest
Posts: n/a
 
      06-18-2006
Hi,

Short question:

Any particular reason for why I'm getting a warning here:
(cast from function call of type int to non-matching type double)


xdouble = (double)rand()/(double)RAND_MAX;


xdouble is ofcourse of type double. So everything should be casted to
type double. Then I don't see why the compiler (gcc) complains. The line
should create a (type double) random number between 0 and 1 and it would
be nice to have this warning go away...


Best regards
Martin Jørgensen

--
---------------------------------------------------------------------------
Home of Martin Jørgensen - http://www.martinjoergensen.dk
 
Reply With Quote
 
 
 
 
Nelu
Guest
Posts: n/a
 
      06-18-2006
Martin Jørgensen <(E-Mail Removed)> writes:

> Hi,
>
> Short question:
>
> Any particular reason for why I'm getting a warning here:
> (cast from function call of type int to non-matching type double)
>
>
> xdouble = (double)rand()/(double)RAND_MAX;
>
>
> xdouble is ofcourse of type double. So everything should be casted to
> type double. Then I don't see why the compiler (gcc) complains. The
> line should create a (type double) random number between 0 and 1 and
> it would be nice to have this warning go away...
>


This warning should show up on gcc only when a specific compilation
option is set (I don't remember it, something with -W...). It tells
you if you cast a function call to a type that's different, like
double and int. I think it protects against int malloc() [it's void *
malloc() in the proper header is included]
being cast to a pointer.

--
Ioan - Ciprian Tandau
tandau _at_ freeshell _dot_ org (hope it's not too late)
(... and that it still works...)
 
Reply With Quote
 
 
 
 
Robert Gamble
Guest
Posts: n/a
 
      06-18-2006
Martin Jørgensen wrote:
> Hi,
>
> Short question:
>
> Any particular reason for why I'm getting a warning here:
> (cast from function call of type int to non-matching type double)
>
>
> xdouble = (double)rand()/(double)RAND_MAX;
>
>
> xdouble is ofcourse of type double. So everything should be casted to
> type double. Then I don't see why the compiler (gcc) complains. The line
> should create a (type double) random number between 0 and 1 and it would
> be nice to have this warning go away...


gcc has an option, -Wbad-function-cast, that will warn "whenever a
function call is cast to a non-matching type". Either don't use this
option, explicitly disable is using -Wno-bad-function-cast, or better
yet, lose the superfluous cast:

xdouble = rand()/(double)RAND_MAX;

Robert Gamble

 
Reply With Quote
 
=?ISO-8859-1?Q?Martin_J=F8rgensen?=
Guest
Posts: n/a
 
      06-18-2006
Robert Gamble wrote:
> Martin Jørgensen wrote:
>
>>Hi,
>>
>>Short question:
>>
>>Any particular reason for why I'm getting a warning here:
>>(cast from function call of type int to non-matching type double)
>>
>>
>>xdouble = (double)rand()/(double)RAND_MAX;
>>
>>
>>xdouble is ofcourse of type double. So everything should be casted to
>>type double. Then I don't see why the compiler (gcc) complains. The line
>>should create a (type double) random number between 0 and 1 and it would
>>be nice to have this warning go away...

>
>
> gcc has an option, -Wbad-function-cast, that will warn "whenever a
> function call is cast to a non-matching type". Either don't use this
> option, explicitly disable is using -Wno-bad-function-cast, or better


Bad idea. I want it to catch "real errors", but not those intentionally
casts I make.

> yet, lose the superfluous cast:
>
> xdouble = rand()/(double)RAND_MAX;


Great (problem solved)! I just don't understand: I won't complain if I
divided two numbers of type double and store the result as a type double
-> therefore the cast. So, rand() returns an integer, which is divided
by a type double. This doesn't give any warning....?

What exactly is a "non-matching type"?


Best regards
Martin Jørgensen

--
---------------------------------------------------------------------------
Home of Martin Jørgensen - http://www.martinjoergensen.dk
 
Reply With Quote
 
Keith Thompson
Guest
Posts: n/a
 
      06-18-2006
Martin Jørgensen <(E-Mail Removed)> writes:
> Short question:
>
> Any particular reason for why I'm getting a warning here:
> (cast from function call of type int to non-matching type double)
>
>
> xdouble = (double)rand()/(double)RAND_MAX;
>
>
> xdouble is ofcourse of type double. So everything should be casted to
> type double. Then I don't see why the compiler (gcc) complains. The
> line should create a (type double) random number between 0 and 1 and
> it would be nice to have this warning go away...


There should be nothing wrong with that line; casting an int to double
is perfectly legitimate. I don't get a warning when I compile it
myself. Show us a complete program and the *exact* warning message.

--
Keith Thompson (The_Other_Keith) http://www.velocityreviews.com/forums/(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
 
Richard Heathfield
Guest
Posts: n/a
 
      06-18-2006
Martin Jørgensen said:

> Hi,
>
> Short question:
>
> Any particular reason for why I'm getting a warning here:
> (cast from function call of type int to non-matching type double)
>
>
> xdouble = (double)rand()/(double)RAND_MAX;


Why are you casting in the first place? Why aren't you doing this:

xdouble = rand() / (RAND_MAX + 1.0);

instead?

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)
 
Reply With Quote
 
=?ISO-8859-1?Q?Martin_J=F8rgensen?=
Guest
Posts: n/a
 
      06-18-2006
Richard Heathfield wrote:
> Martin Jørgensen said:
>
>
>>Hi,
>>
>>Short question:
>>
>>Any particular reason for why I'm getting a warning here:
>>(cast from function call of type int to non-matching type double)
>>
>>
>>xdouble = (double)rand()/(double)RAND_MAX;

>
>
> Why are you casting in the first place? Why aren't you doing this:
>
> xdouble = rand() / (RAND_MAX + 1.0);


I also do that now, as that don't give any warnings. But I did it
because I thought that I wouldn't get any problem if I divided two type
double-numbers/variables with each other.

So: My idea was: It must be better do do this:

500.0 / 100000.0

Than this:

500 / 100000.0

But the compiler didn't share that logic with me


Best regards
Martin Jørgensen

--
---------------------------------------------------------------------------
Home of Martin Jørgensen - http://www.martinjoergensen.dk
 
Reply With Quote
 
Jack Klein
Guest
Posts: n/a
 
      06-18-2006
On Sun, 18 Jun 2006 07:52:00 +0200, Martin Jørgensen
<(E-Mail Removed)> wrote in comp.lang.c:

> Robert Gamble wrote:
> > Martin Jørgensen wrote:
> >
> >>Hi,
> >>
> >>Short question:
> >>
> >>Any particular reason for why I'm getting a warning here:
> >>(cast from function call of type int to non-matching type double)
> >>
> >>
> >>xdouble = (double)rand()/(double)RAND_MAX;
> >>
> >>
> >>xdouble is ofcourse of type double. So everything should be casted to
> >>type double. Then I don't see why the compiler (gcc) complains. The line
> >>should create a (type double) random number between 0 and 1 and it would
> >>be nice to have this warning go away...

> >
> >
> > gcc has an option, -Wbad-function-cast, that will warn "whenever a
> > function call is cast to a non-matching type". Either don't use this
> > option, explicitly disable is using -Wno-bad-function-cast, or better

>
> Bad idea. I want it to catch "real errors", but not those intentionally
> casts I make.
>
> > yet, lose the superfluous cast:
> >
> > xdouble = rand()/(double)RAND_MAX;

>
> Great (problem solved)! I just don't understand: I won't complain if I
> divided two numbers of type double and store the result as a type double
> -> therefore the cast. So, rand() returns an integer, which is divided
> by a type double. This doesn't give any warning....?


You cannot divide an int by a double in C. The language does not
allow it. When you think you are dividing (or adding, subtracting,
multiplying, and so on) two different arithmetic types, something else
is really happening.

C has conversions of one type to another. Some conversions are
automatic, and will happen automatically if the expression calls for
it. The most common of these are what are called "the usual integer
conversions" in the C standard.

When an expression or subexpression performs a binary operation on two
scalar values of different type, the lesser type is automatically
promoted to the greater type. No cast is required.

So if you have code like this:

double two_thirds;
two_thirds = 2 / 3.0;

....the integer constant '2' is automatically converted to type double
because the divisor is the double constant '3.0'.

Exactly the same thing happens in the expression:

rand() / (double)RAND_MAX;

Both operands are evaluated. The cast on the denominator makes it a
double value. This causes the compiler to automatically convert the
int returned by rand() to a double to do the division.

> What exactly is a "non-matching type"?


Well, the type of the return value of rand() is an int. Any type
other than int would be a non-matching type.

> Best regards
> Martin Jørgensen


--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html
 
Reply With Quote
 
=?ISO-8859-1?Q?Martin_J=F8rgensen?=
Guest
Posts: n/a
 
      06-18-2006
Jack Klein wrote:
> On Sun, 18 Jun 2006 07:52:00 +0200, Martin Jørgensen
> <(E-Mail Removed)> wrote in comp.lang.c:

-snip-

>
> You cannot divide an int by a double in C. The language does not
> allow it. When you think you are dividing (or adding, subtracting,
> multiplying, and so on) two different arithmetic types, something else
> is really happening.


Ok.

> C has conversions of one type to another. Some conversions are
> automatic, and will happen automatically if the expression calls for
> it. The most common of these are what are called "the usual integer
> conversions" in the C standard.
>
> When an expression or subexpression performs a binary operation on two
> scalar values of different type, the lesser type is automatically
> promoted to the greater type. No cast is required.


Just to make sure it's clear:

When you write "the greater type" what is that then. The type for which
sizeof( double/int ) is the largest? Sizeof(double) = 8 on my system and
sizeof(int) = 4, so suppose (I don't know if it's possible), two
different types were both 4/8 bytes what would the "greater type" be?

> So if you have code like this:
>
> double two_thirds;
> two_thirds = 2 / 3.0;
>
> ...the integer constant '2' is automatically converted to type double
> because the divisor is the double constant '3.0'.


I must have remembered incorrect, but I believe that I once tried to do
something where the result was an integer - at least - I wanted to avoid
the result being: two_thirds = 0 (it should be 0,666666667)...

> Exactly the same thing happens in the expression:
>
> rand() / (double)RAND_MAX;
>
> Both operands are evaluated. The cast on the denominator makes it a
> double value. This causes the compiler to automatically convert the
> int returned by rand() to a double to do the division.


Ok.

>>What exactly is a "non-matching type"?

>
>
> Well, the type of the return value of rand() is an int. Any type
> other than int would be a non-matching type.


Now I get it.... It (the compiler) didn't look at the denominator... It
only looked at the numerator and thought: Hey, you probably
shouldn't/dont want to cast the return type (int) from rand() to type
double as I know it's type int and I would like it to stay that type no
matter what kind of type it's divided by...


Best regards
Martin Jørgensen

--
---------------------------------------------------------------------------
Home of Martin Jørgensen - http://www.martinjoergensen.dk
 
Reply With Quote
 
Barry Schwarz
Guest
Posts: n/a
 
      06-18-2006
On Sun, 18 Jun 2006 07:52:00 +0200, Martin Jørgensen
<(E-Mail Removed)> wrote:

>Robert Gamble wrote:
>> Martin Jørgensen wrote:
>>
>>>Hi,
>>>
>>>Short question:
>>>
>>>Any particular reason for why I'm getting a warning here:
>>>(cast from function call of type int to non-matching type double)
>>>
>>>
>>>xdouble = (double)rand()/(double)RAND_MAX;
>>>
>>>
>>>xdouble is ofcourse of type double. So everything should be casted to
>>>type double. Then I don't see why the compiler (gcc) complains. The line
>>>should create a (type double) random number between 0 and 1 and it would
>>>be nice to have this warning go away...

>>
>>
>> gcc has an option, -Wbad-function-cast, that will warn "whenever a
>> function call is cast to a non-matching type". Either don't use this
>> option, explicitly disable is using -Wno-bad-function-cast, or better

>
>Bad idea. I want it to catch "real errors", but not those intentionally
>casts I make.
>
>> yet, lose the superfluous cast:
>>
>> xdouble = rand()/(double)RAND_MAX;

>
>Great (problem solved)! I just don't understand: I won't complain if I
>divided two numbers of type double and store the result as a type double
>-> therefore the cast. So, rand() returns an integer, which is divided
>by a type double. This doesn't give any warning....?


The integer rand returned is first implicitly converted to double and
the division is performed using two doubles. You are not casting the
return from rand to double. Since an implicit conversion is not a
cast, the bad-function-cast option should not be involved.

Note that the compiler is free to generate any kind of diagnostic it
likes as long as it still generates the correct code for a well
defined expression. It could still generate a warning of the type
"Hey, you are dividing an int by a double and I consider that to be an
operation of dubious value." It's a quality of implementation issue.

>
>What exactly is a "non-matching type"?


Whatever your compiler decides it is.


Remove del for email
 
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
Why does "template<typename T> ... function<T(int)>" not match "int(&)(int)" implicitly? Steve Hicks C++ 2 09-28-2009 05:24 PM
Alternative for int ** to const int ** cast? Randall Parker C++ 4 05-19-2006 06:56 PM
cannot convert parameter from 'double (double)' to 'double (__cdecl *)(double)' error Sydex C++ 12 02-17-2005 06:30 PM
int main(int argc, char *argv[] ) vs int main(int argc, char **argv ) Hal Styli C Programming 14 01-20-2004 10:00 PM
dirty stuff: f(int,int) cast to f(struct{int,int}) Schnoffos C Programming 2 06-27-2003 03:13 AM



Advertisments