Double Data Type in C++ | A Comprehensive Guide

Predominantly, there are three major categories of data types in C++ - primary, derived, and user-defined data types. Primary data types in C++ (also known as primitive data types) are the data types that are provided by the language and are inbuilt. The C++ double data type falls under this category. This data type is widely used by programmers and is used to store floating-point numbers. All real numbers are floating-point values. A variable can be declared as double by adding the double keyword as a prefix to it.

You majorly used this data type where the decimal digits are 14 or 15 digits. However, one must use it cautiously as it consumes memory storage of 8 bytes and is an expensive method.

What is Double Data Type in C++?

Double data type in C++ is a versatile data type that can represent any numerical value in the compiler, including decimal values. There are two types of double data types in C++: whole numbers as well as fractional numbers with values.

Syntax of Double in C++

The syntax to declare a variable of double type:

double variable_name;

double var_1, var_2, var_3;

It specifies the keyword double followed by the variable name to declare a variable of the double type. The following examples show different ways in which it can initialize a double variable:

// variables of double type

double var1 = 5.999999;

double var2 = 5.0;

double var3 = 5;

double var4 = -5.0000;

How Does Double Data Type work in C++?

The C++ double can hold floating-point values of up to 15 digits taking up a space of 8 bytes in the memory.
The range of the values that can be stored in a double type variable is 1.7E - 308 to 1.7E + 308.
The compiler in C++, by default, treats every value as a double and implicitly performs a type conversion between different data types.
Generally, the double type is used as it is more precise and prevents a loss of data in terms of significant digits.

Our Free Courses with Certificate

Introduction to C++ Enroll Now!
Learn Advanced C++ Course Enroll Now!
C Programming Basics Enroll Now!
Introduction to C# Enroll Now!
JavaScript for Beginners Enroll Now!

Rules and Regulations for Using Double in C++

There are no hard and fast rules for using double in C++, nevertheless, some regular rules are there that make the code cleaner and help in understanding the double data type in a better way.

The C++ double should have a floating-point precision of up to 15 digits as it contains a precision that is twice the precision of the float data type.
When you declare a variable as double, you should initialize it with a decimal value. For example, 3.0 is a decimal number. However, if you initialize it with 3, it will also work fine because although 3 and 3.0 seem to be identical i.e., an integer, there is a big difference in their internal representation.
When you perform the division or multiplication operation, both the numbers should be of the double data type or else there could be a loss of some data.
If you declare a variable as float and during initialization you did not add f in the end, it will consider it as a double variable. For example:

// it is considered as a float variable

float n = 1.414f;

//it is considered as a double variable

float n = 1.414;

Examples of C++ Double

The following examples illustrate the double data type in C++.

Example 1: Program to Find the Surface Area and Volume of a Sphere

#include <iostream>

using namespace std;

// function to calculate surface area and volume

// of a sphere

void sphere(int radius)

{

// variables to hold double values

double surfaceArea, sphereVolume;

surfaceArea = 4 * 3.14 * radius * radius;

sphereVolume = (surfaceArea * radius ) / 3;

cout << "The surface area of the sphere is: " << surfaceArea;

cout << "\n\nThe volume of the sphere is: " << sphereVolume;

}

int main()

{

int radius = 6;

sphere(radius);

cout << "\n\n";

return 0;

}

Cpp_Double_1.

In the above example, the variables surfaceArea and sphereVolume of double type are declared to store the results calculated in the function sphere(). The function finds the surface area and volume of a sphere, which can be floating-point values.

Example 2: Program to Perform Arithmetic Operations on the Double Type Values

#include <iostream>

using namespace std;

double findSum(double x, double y)

{

return x + y;

}

double findDifference(double x, double y)

{

return x - y;

}

double findProduct(double x, double y)

{

return x * y;

}

double findQuotient(double x, double y)

{

return x / y;

}

int main()

{

double value1 = 10.45, value2 = 6.28;

cout << "The sum is: " << findSum(value1, value2) << "\n\n";

cout << "The difference is: " << findDifference(value1, value2) << "\n\n";

cout << "The product is: " << findProduct(value1, value2) << "\n\n";

cout << "The quotient is: " << findQuotient(value1, value2) << "\n\n";

return 0;

}

Cpp_Double_2

In the above example, the basic arithmetic operations, addition, subtraction, multiplication, and division are performed on two double operands value1 and value2. The result of their division produces 1.664012738, but only 6 digits are printed because the cout only prints 6 digits by default by rounding off the value.

Example 3: Program to Find the Cube Root of a Number

#include <iostream>

using namespace std;

double findCube(double num)

{

double ans;

double precision = 0.000001;

// calculate the integer part

for (double ans = 1; (ans * ans * ans) <= num; ++ans)

;

ans--;

// Calculate the fractional part

for (ans; (ans * ans * ans) < num; ans += precision)

;

return ans;

}

int main()

{

int num = 5;

cout << "The cube root of the number is: ";

cout << findCube(num) << "\n\n";

return 0;

}

Cpp_Double_3

In the above example, it calculates the cube root of an integer. It stores the result in a double variable ans.

Difference Between Float and Double

In C++, float and double are both used to store floating-point numbers. Floating-points values are real numbers, for eg: 1801.0, -4.258, or 0.08244. These two data types differ from each other in many ways. Now, understand how the float differs from the C++ double.

Float: The C++ float type is a primitive data type that holds floating values up to 7 digits.

Double: The C++ double is also a primitive data type that is used to store floating-point values up to 15 digits.

The following program illustrates the difference between C++ float and C++ double:

#include<iostream>

using namespace std;

int main()

{

// initialize float and double variables

float var1 = 1.1426f; // the float value should end with an 'f'

double var2 = 1.1426576;

// print the size of the float variable

cout << "The float datatype takes " << sizeof(var1) << " bytes in the memory.";

// print the value of the long double variable

cout << "\n\nThe value stored in the variable is: " << var1;

cout << "\n\n";

// print the size of the long double variable

cout << "The long double datatype takes " << sizeof(var2) << " bytes in the memory.";

// print the value of the long double variable

cout << "\n\nThe value stored in the variable is: " << var2;

cout << "\n\n";

return 0;

}

Cpp_Double_4

In the above example, variables of float and double types are initialized with floating-point values. The value of the float variable ends with an “f” suffix because the compiler by default treats all values as double. The sizeof() operator is used to print the size of float and double data types in bytes.

The following comparison chart highlights the key difference between the C++ float and the C++ double:

FLOAT	DOUBLE
Float consumes 4 bytes of memory for storage.	Double consumes 8 bytes of memory for storage.
Float has comparatively less precision and is used to store decimal numbers with fewer digits.	Double has almost twice the precision as float and is used to store decimal numbers with more digits.
It has a 32-bit floating-point precision according to IEEE.	It has a 64-bit floating-point precision according to IEEE.
It stores up to 7 decimal points and rounds off the rest of the digits.	It can store up to 15 decimal points without rounding them off.

setprecision() to Specify Decimal Points

The setprecision() method in C++ is used to set the precision of floating points up to a certain number of significant digits. It provides a way to control the number of floating points. It is mainly useful in cases where the resulting number is irrational and repeating, i.e., where the decimal points repeat themselves after reaching a certain point. This function can be used in the program by adding the iomanip header file.

The Syntax for the setprecision() Method:

setprecision(int n)

Parameter

This function accepts an integer that specifies the number of significant digits up to which the precision has to be set.

Return Value

This function returns nothing. It is just a manipulator function that formats the floating-point values.

The following examples illustrate the working of setprecision() function in C++:

Example 1

#include <iostream>

#include <iomanip>

using namespace std;

int main()

{

// initialising the value of pi

// upto two places

double pi = 3.142857142857;

cout << "Value of pi before using setprecision(): "

<< pi << endl;

// Using setprecision()

cout << "Using the setprecision to set the precision upto 4: ";

cout << setprecision(4);

cout << pi << endl;

// Using setprecision()

cout << "Using the setprecision to set the precision upto 8: ";

cout << setprecision(8);

cout << pi << endl;

// setting the precision value that

// is beyond the number of digits

// in the initialised value

cout << "Using the setprecision to set the precision upto 15: ";

cout << setprecision(15);

cout << pi << endl;

return 0;

}

Cpp_Double_5.

In the above example, although the total number of digits after the decimal of the initialized value of pi is 13, the printed value contains only 6 decimal points, as in MinGW. The cout function prints the number up to 6 digits at max and truncates the rest of the decimal digits by rounding off the value. You used the setprecision() function up to 4 and 8 and got the expected output but when you tried to set the precision up to 15; it gave the maximum digits of the initialized value that is 13.

Example 2

#include <iostream>

#include <iomanip>

using namespace std;

int main()

{

double pos = 1.41421356, neg = -1.41421356;

//using setprecision()

cout << "Setting precision to 0:\t";

cout << setprecision(0) << "pos = " << pos << " ";