 # C++ float and double

In this tutorial, we will learn about the float and double data types with the help of examples. We will also look at some of the key differences between them and when to use them.

In C++, both `float` and `double` data types are used for floating-point values. Floating-point numbers are used for decimal and exponential values. For example,

``````// creating float type variables
float num1 = 3.0f;
float num2 = 3.5f;
float num3 = 3E-5f; // 3x10^-5

// creating double type variables
double num4 = 3.0;
double num5 = 3.5;
double num6 = 3E-5; // 3x10^-5``````

We must add the suffix `f` or `F` at the end of a `float` value. This is because the compiler interprets decimal values without the suffix as `double`.

Consider this code.

``float a = 5.6;``

Here, we have assigned a `double` value to a `float` variable.

In this case, 5.6 is converted to `float` by the compiler automatically before it is assigned to the variable a. This may result in data loss. To learn more, visit C++ Type conversion.

## Difference Between float and double

float double
Size: 4 bytes Size: 8 bytes
Precision: In general, 7 decimal digits precision Precision: In general, 15 decimal digits precision
Example: `3.56f`, `3e5f` etc. Example: `3.56`, `3e5` etc.

Note: Unless you have a specific requirement, always use `double` instead of `float`, as `float` variables may be prone to introduce errors when working with large numbers.

### Example 1: C++ float and double

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

int main() {
// Creating a double type variable
double a = 3.912348239293;

// Creating a float type variable
float b = 3.912348239293f;

// Printing the two variables
cout << "Double Type Number  = " << a << endl;
cout << "Float Type Number  = " << b << endl;

return 0;
}``````

Output

```Double Type Number  = 3.91235
Float Type Number = 3.91235```

Note: The compiler used for this example (MinGW compiler) allowed for 6 digits. So, our variable values were rounded off and truncated to 6 digits by the compiler.

## setprecision() to Specify Decimal Points

We can specify the number of decimal points to print in `cout` by using the `setprecision()` function.

This function is defined in the `iomanip` header file, which stands for input/output manipulation.

### Example 2: Using setprecision() For Floating-Point Numbers

``````#include <iomanip>
#include <iostream>

using namespace std;

int main() {
// Creating a double type variable
double a = 3.912348239293;

// Creating a float type variable
float b = 3.912348239293f;

// Setting the precision to 12 decimal places
cout << setprecision(13);

// Printing the two variables
cout << "Double Type Number  = " << a << endl;
cout << "Float Type Number      = " << b << endl;

return 0;
}``````

Output

```Double Type Number  = 3.912348239293
Float Type Number      = 3.912348270416```

As we can see from the example above, we have specified the precision up to 13 digits.

``cout << setprecision(13);``

The floating-point value we have assigned to our variables also consists of 13 digits.

However, since `float` has a precision of up to only 7 digits, it shows garbage values after its precision is exceeded.

Our `double` variable shows the correct number because it has a precision of 15 digits, while the number itself consists of 13 digits.

As an alternative, we can specify different precisions for different variables while printing them.

### Example 3: Different Precisions For Different Variables

``````#include <iomanip>
#include <iostream>

using namespace std;

int main() {
// Creating a double type variable
double a = 3.912348239293;

// Creating a float type variable
float b = 3.912348239293f;

// Setting precision to 11 for double
cout << "Double Type Number = " << setprecision(11) << a << endl;

// Setting precision to 7 for float
cout << "Float Type Number  = " << setprecision(7) << b << endl;

return 0;
}``````

Output

```Double Type Number = 3.9123482393
Float Type Number    = 3.912348```

From the program above, we can see that we have set two different precision values for `float` and `double`.

In both cases, the precision is smaller than the actual digits of the number. So the last digit is rounded off and the rest is truncated.

Note: If we specify the precision greater than the precision of the data type itself (7 for `float` and 15 for `double`), then the compiler will give us garbage values after the precision limit has been exceeded, as can be seen with the `float` output in example 2.

## Work with Exponential Numbers

As mentioned above, `float` and `double` can also be used to represent exponential numbers. For example,

``````// ex = 325 X (10 ^ 25)
double ex = 325E25;``````

C++ outputs exponential numbers and very large numbers in a format called the scientific format. The variable ex will be outputted in this format by default since it is a very large number.

In order to force C++ to display our floating-point numbers in the `scientific` format regardless of the size of the number, we use the format specifier `scientific` inside of `cout`.

``````double num = 3.25;

// ex = 325 X (10 ^ 25)
double ex = 325E25;

// using scientific format
cout << scientific << num;
cout << scientific << ex;``````

In addition to this, there is another format specifier known as `fixed`, which displays floating-point numbers in the decimal format.

It is similar to displaying floating-point numbers by only using `cout` without `setprecision()`, except for the fact that `fixed` displays numbers up to 6 decimal points.

On the other hand, only using `cout` displays digits according to the specific compiler (6 total digits in the case of MinGW compiler, including the digits before the decimal point).

### Example 4: Fixed and Scientific Formats

``````#include <iomanip>
#include <iostream>

using namespace std;

int main() {
// Creating a decimal double type variable
double a = 3.912348239293;

// Creating an exponential double type variable
double ex1 = 325e+2;

// Creating a float type variable
float b = 3.912348239293f;

// Creating an exponential float type variable
float ex2 = 325e+2f;

// Displaying output with fixed
cout << "Displaying Output With fixed:" << endl;
cout << "Double Type Number 1 = " << fixed << a << endl;
cout << "Double Type Number 2 = " << fixed << ex1 << endl;
cout << "Float Type Number 1  = " << fixed << b << endl;
cout << "Float Type Number 2  = " << fixed << ex2 << endl;

// Displaying output with scientific
cout << "\nDisplaying Output With scientific:" << endl;
cout << "Double Type Number 1 = " << scientific << a << endl;
cout << "Double Type Number 2 = " << scientific << ex1 << endl;
cout << "Float Type Number 1  = " << scientific << b << endl;
cout << "Float Type Number 2  = " << scientific << ex2 << endl;
return 0;
}``````

Output

```Displaying Output With fixed:
Double Type Number 1 = 3.912348
Double Type Number 2 = 32500.000000
Float Type Number 1  = 3.912348
Float Type Number 2  = 32500.000000

Displaying Output With scientific:
Double Type Number 1 = 3.912348e+000
Double Type Number 2 = 3.250000e+004
Float Type Number 1  = 3.912348e+000
Float Type Number 2  = 3.250000e+004```

## long double

Apart from `float` and `double`, there is another data type that can store floating-point numbers. This is known as `long double`.

It usually occupies a space of 12 bytes (depends on the computer system in use), and its precision is at least the same as `double`, though most of the time, it is greater than that of `double`.

`long double` values should end with `L`. For example,

``````// declaring a long double variable

long double num_ldb = 2.569L;``````

Note: The floating-point data types supported by C++ are `float`, `double` and `long double`. There is no `long float`.