Simple Typecast Q (int to float)

**The Brain** · 08-31-2004

Is there a better way to do this...?? (the 'wins' and 'losses' variables have been previously declared as 'int')

Code:

float blackjack::win_percentage()
{
        //Prevents 'division by zero' errors
	if ((wins + losses) == 0)

		return 0.00;

	else
	{
		
		//Cast 'wins' & 'losses' to float 
		cout.setf(ios::fixed);
		cout.setf(ios::showpoint);
		cout.precision(1);


		float answer =  (( (float)wins / ( (float)wins + (float)losses)) * 100);

		return answer;

	}

}

I think there is a better way to perform this typecast.. also i think there is a different way to set precision.

Thanks in advance.

**prog-bman** · 09-01-2004

Why do you even need to type cast since your declaring a float and then diving two ints in it you should still be ok without a typecast or at least i think

**The Brain** · 09-01-2004

just tried it this way.. and the results I am getting are consistant with integer division...

Code:

float answer =  ((wins / (wins + losses)) * 100);

For example, if I win the first hand.. I will get a 100% win percentage.. but if I lose the second hand.. I will have a 0% win percentage.. subsequent wins yeild 0% as anything less than 100% will truncate to zero percent.

**bithub** · 09-01-2004

Your casting is correct in your original post Mr. Brain.

**DominicTrix** · 09-01-2004

It's correct but there is a prettier way (well less brackets anyway):

Code:

float answer = (float)wins / float(wins + losses) * 100;

or, to save even more excess:

Code:

return (float)wins / float(wins + losses) * 100;

There's no need for the brackets around "(float)wins / float(wins + losses)" as the divide will b done before the multiply anyway.

As for the precision, I've no idea, but if that works I can't imagine a more efficient method.

Hope that helps

dt

**alphaoide** · 09-01-2004

Code:

floatVar = static_cast<float>(intVar);

**curlious** · 09-01-2004

We where discussing casts in my c/c++ class today and I made the comment that the form (type)expression for casting is the c-style form of casting and that the new style forms for c++ are prefered.

Taken Effective C++ second edition by Scott Meyers the casts are
static_cast<type>(expression)
const_cast<type>(expression)
dynamic_cast<type>(expression)
reinterpret_cast<type>(expression)

while this casting may be more typing as Meyers points out they are easier to identify and "the narrower focus of the casts allow compilers to diagnose usage errors"

**DominicTrix** · 09-01-2004

Wow, so exactly why is using this style class preffered over type(expression) or (type)expression? I understand the recognition, it is very clear to read (if that's what you mean), but what you quote Meyers as saying makes no sense to me. Does what he say really apply in a case as simple as this?

**curlious** · 09-01-2004

Well I admit I originaly learned to use the simple c style type casting but having read other books on the subject I think that the change in syntax does apply.
The simplicty may not be apparent to the beginning programmer. Suppose a client misinterprets the traditional style of casting for a function call or some other anomoli. Still the static_cast<type>(expression) form leaves no room for misinterpretation or incorrect casting. Neatly formated code would make clarity a simple process. The potenitial for error would decrease because of the apparent signal for possible logic errors in incorrect type casting. This is all my opinion on the subject. I have little programming experience so take it with a grain of salt if you like but it has caused me some thought upon the subject. It is tempting to take the route that most simply leades to our destination but taking the alternate route may lead to a clearer understanding of the code across all level of programmers. I would think the experienced programmers are used to the traditional c-style casting and many would resist changing to the newer c++ style casts but who knows perhaps my own opinion could be changed with more experience or by your own replies.

**DominicTrix** · 09-01-2004

Was just looking for Meyer's book to buy, when saw some demo snippets online, including the chapter on type casting! It's here,

http://www.awprofessional.com/conten...MEC/MI5_FR.HTM

I've not read it all yet, but enough to see at least one reason for using the C++ style (to do with avoiding conversions from double to char etc).

**The Brain** · 09-01-2004

Aside from casting an int to a float... I have also realized a better way to write this algorithm... using an optimization method called, "stacking the deck" (no pun intended)

Since ((wins + losses) == 0) will only occur on the opening hand.. why not make this the ELSE.

more optimal approach

Code:

float blackjack::win_percentage()
{

	//Prevents division by zero error
	if ((wins + losses) != 0)
	{
		
		//Cast wins & losses to float 
		cout.setf(ios::fixed);
		cout.setf(ios::showpoint);
		cout.precision(1);

		float answer =  (( (float)wins / ( (float)wins + (float)losses)) * 100);

		return answer;

	}

	else

	        return 0.00;

}

With this type of architecture, the IF statement should only short circuit on the opening hand... all subsquent hands will satisfy ((wins + losses) != 0)... thus, "stacking the deck" towards the more frequently satisfied condition... saving a ton of overhead by not having to resort to ELSE everytime.

simple yet fun technique.

**The Brain** · 09-11-2004

Just want to let everyone know.. that I have settled on this hybrid approach to making this typecast...

Code:

float blackjack::win_percentage()
{

	//Prevents division by zero error
	if ((wins + losses) != 0)
	{			
		cout.setf(ios::fixed);
		cout.setf(ios::showpoint);
		cout.precision(1);

		//Typecast wins & losses to float 
		float answer = static_cast<float>((wins) / ( wins + (float)losses)) * 100;

		return answer;
	}


	else

		return 0.00;

}

**swoopy** · 09-11-2004

>also i think there is a different way to set precision.
I suppose you could do it like this:

Code:

cout << fixed << showpoint << setprecision(1);

**DominicTrix** · 09-11-2004

If your going to use the hybrid (and I'm not sure why you would), then why not use the yet again more efficient:

Code:

      return   static_cast<float>(wins) / (float)(wins + losses) * 100;

That way, there is no need to setup the extraneous float variable and you ditch a set of brackets that you didn't need (the devide will be done before the multiplication anyway).

I think though, that for total clarity and consistency, you should use one type of cast. i.e.:

Code:

      return   static_cast<float>(wins) / static_cast<float>(wins + losses) * 100.0;

// or

      return  float(wins) / float(wins + losses) * 100.0;

dt

**Codeplug** · 09-11-2004

I wouldn't modify cout's flags unless you're actually going to use it. You may also want to consider restoring cout's original flags once you've done your output, to "play nice" with any other output functions that you add later which can expect the default flags to be set.

As for the casting, in this case you only need one cast to promote the entire expression to float:
>> ((float)wins / (wins + losses)) * 100

>> saving a ton of overhead
There's extremely little "overhead" in a single jump instruction, not a ton. You can also perform "wins + losses" calculation once and don't touch cout.

Code:

float blackjack::win_percentage()
{
    int tot = wins + losses;

    if (tot)
        return ((float)wins / tot) * 100;

    return 0;
}//win_percentage

gg

Thread: Simple Typecast Q (int to float)

Thread Tools

Search Thread

Display

Simple Typecast Q (int to float)

Similar Threads

how to combine these working parts??

Function argument assignment between types "unsigned int" and "unsigned long"

Moving Average Question

Binary Search Trees Part III

Half-life SDK, where are the constants?