What is the difference in behavior between 1.0*a/b and (float)a/b when performing division in a simple calculator implementation?

Here is the link to the problem
It's relatively easy looking problem with simple logic, of making your own calculator.
You input two numbers and character any of these four('+', '-', '*', '/') and output the answer.

So I wrote my code like this:

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	float a, b, d;
	char c;
	
	cin>>a>>b;
	cin>>c;
	
if(c=='+') cout<<a+b;
if(c=='-') cout<<a-b;
if(c=='*') cout<<a*b;
if(c=='/') cout<<setprecision(10)<<(float)a/b;
	return 0;
}

But it wasn't able to pass all the test cases. I tweaked a bit with code line of division and looked up other people's submission and found out correct answer as

#include <iostream>
#include <iomanip>
using namespace std;

int main() {
	float a, b, d;
	char c;
	
	cin>>a>>b;
	cin>>c;
	
if(c=='+') cout<<a+b;
if(c=='-') cout<<a-b;
if(c=='*') cout<<a*b;
if(c=='/') cout<<setprecision(10)<<1.0*a/b; //here is the change
	return 0;
}

so I wasn't able to understand what kind of input gives different output to above both codes

Difference between these two lines:

if(c=='/') cout<<setprecision(10)<<(float)a/b;
if(c=='/') cout<<setprecision(10)<<1.0*a/b;

The main difference is that 1.0*a/b creates a double (as 1.0 is a double) while (float)a/b creates a float that has less precision.

Also you can use std::numeric_limits<T>::digits10 to know how many digits you need in base 10 to represent a number without loss. You'll notice that for float and double you have:

• std::numeric_limits<float>::digits10 == 6 which is less than your required precision (10)
• std::numeric_limits<double>::digits10 == 15 which is more than your required precision (10)

For more information about the precision you can check cppreference.

The difference is that:

• (float) a / b is converting a to float, and performing a division between a and b. This is actually unnecessary, because a and b are already declared as float, so you could have just as well written a / b
• 1.0 * a / b is multiplying a with 1.0 and 1.0 is a double literal. This means that both a and b will be converted to double precision types before the division, and the result of the division will have double precision too.

The latter expression could have been written as (double) a / b as well. If double is an IEEE-754 floating-point number, then multiplication with 1.0 is a no-op, i.e. an operation that does nothing.
The only effect of multiplying with 1.0 is that the other side gets converted to double if it's a float.

Another solution is to declare all the variables as double:

double a, b, d;

If you need more precision, it's usually best to use the same level of precision everywhere, not just for one operation.

In your original program these expressions

(float)a/b

and

a/b

are equivalent because the both expressions have the type float due to the type of the operands.

This expression

1.0*a/b

has the type double due to the constant 1.0 of the type double. So the result is more precised.

Try the following demonstration program.

#include <iostream>
#include <limits>

int main()
{
	std::cout << "std::numeric_limits<float>::digits10 = "
		<< std::numeric_limits<float>::digits10
		<< '\n';

	std::cout << "std::numeric_limits<double>::digits10 = "
		<< std::numeric_limits<double>::digits10
		<< '\n';
}

Its output might look like

std::numeric_limits<float>::digits10 = 6
std::numeric_limits<double>::digits10 = 15

As you can see objects of the type double can be represented more accurately with more digits.

You could write instead like

( double )a/b

or

static_cast<double>( a )/b

to get the same result. Or you could initially declare the variables as having the type double.

double a, b;

You need also to check whether the variable b is not equal to zero before performing the calculation.

Pay attention to that in the both programs the variable d is not used and may be removed.