**Float** and **double** are both fundamental undivided data types (Primitive data type) of Java C/C++ used to store real constants. Real constants are numbers with decimal points or fractions such as 1.82765236 or 22/7 etc. **int** data type only contains real numbers, but Float and Double contain both Real and decimal numbers.

The main difference between them is the only length. Double as shown by the name contains double-length than float. It is an advanced data type of float. Float is compatible with lightweight applications in comparison to Double.

## Float

In computing, afloat is a data type made from a number that is not an integer, since it includes a fraction represented by decimal format. It corresponds to a 4-byte floating-point. The precision of float is up to 7 decimal points, and it ranges from ±3.40282347E+38. Float is also referred to as double precision.

## Double

Double is IEEE standard 64-bits decimal value which works faster than float data type. In terms of accuracy, double is 2x more exact than float as Double consumes 8 bytes of memory, enhancing the capacity to store 15-16 decimal digits of precision. It utilizes 64 bits as 1 bit for sign, 11 for exponents, and the remaining 52 for value.

**Code**

```
#include <iostream>
using namespace std;
int main() {
// define float type variable
float f = 1.2897343645643f;
// define double type variable
double d = 1.2897343645643;
// Set precision to 7
cout << "Float data type = " << setprecision(7) << f << endl;
// Set precision to 14
cout << "Double data type = " << setprecision(14) << d << endl;
return 0;
}
```

**Output**

```
Float data type = 1.289734
Double data type = 1.2897343645643
```

In the above-mentioned program, initialized two data types of double and float.

As a result, the precision is smaller than the input numbers of both data types. The last digit is rounded off, and the rest of the digits are truncated.

If the precision value increases than the limit of data type memory(7 in float and 15 in double), then the output will show trash values due to exceeded precision.

## Float vs Double

Float data type | Double data type |

The size of a float is 4 bytes | The size of double is 8 bytes |

According to IEEE, it has a floating-point precision of 32 bits | It has a floating-point precision of 64 bits, which means it can store double the numbers float can store. |

The floating range is ±3.40282347E+38F | However, the double range is ±1.79769313486231570E+308 |

Float has a precision of up to 6 to 7 decimal places. | While double has a precision of up to 15 to 16 decimal places. |

Float has a single precision. | Double is two times more precise than float. |

It is simpler to manage by the compilers. | It is comparatively difficult. |

It is generally for the graphics-based libraries to make the process faster. | Programming languages use double for assigning values having a real or decimal based number such as pi and e |

Float uses 1 bit for sign, 8 bits for the exponent, and 23 bits for mantissa. | While double uses 1 bit for a sign, 11 bits for the exponent, and 52 bits for mantissa. |

It is cheap as use in lightweight applications. | It is expensive as it occupies 8 bytes to store variables. |

Doubles are two times more precise than float, so for large numbers, double is preferable, though float is cheaper than double as it is half the precision of it. You can continue working with float unless you need a precision of up to 15 to 16 decimal places.

However, in Java, floating-point numbers are double, so to convert that in float, you must put ‘f’ or ‘F’ as a suffix or cast them explicitly.

**Now here a question arises: where would we use the precisions? **

If working with minor numbers of data like area of land etc., by default, use double. But if you are dealing with many numbers where precision is high, and each rounding-off can make a difference, it is important to select between float and double. With all the differences, however, there are some similarities in float and double. They function the same in all the programming languages as they represent real numbers. In Java, they pitch NumberFormatException, where the actual numbers are not involved.

## Why use Double instead of Float?

In the computational calculation, infinite numbers after the decimal point will be handled according to the data type initialized in the program. Values after decimal point do not create a huge difference in the arithmetic calculation but in the scientific calculation where every point makes great changes. Although both data types are not accurate, double is more precise in comparison to float.

**Conclusion**

Float is a cheap, lightweight, cost-effective way to store fractional variables in comparison, Double is an expensive data type compatible with high memory(RAM), and it is suitable when programmers are concerned with accuracy.