# Ceil function in C++

In this article, Ceil function will be explored with different programming examples. Limitations of ceiling functions are also covered.

**Table of contents**

The ceil function in **C++** is a mathematical function that rounds a decimal number up to the nearest integer. It is a part of the C++ Standard Template Library (STL) and is defined in the ** <cmath>** header. The function takes a single argument, a decimal number, and returns the smallest integer greater than or equal to the input value.

For example, ceil(2.3) would return 3, and ceil(5.0) would return 5.

**Syntax:**

The syntax for the ceil function in C++ is as follows:

double ceil(double x);

Here, ** x** is the decimal number you want to round up to the nearest integer. The function returns the smallest integer greater than or equal to

**.**

*x*It’s worth noting that the return type of ceil function is ** double**; if you want to use it with other data types like

**or**

*float***, you need to cast the input argument to be**

*long double***before calling the function.**

*double*float num = 2.3;cout<<ceil(double(num))<<endl; // 3

Please include the <cmath> header in your program before using this function.

**Also explore: Default Arguments in C++**

**Must read: Understanding Operators in C++**

**Ceil() Prototypes**

In C++, the ** ceil() **function is a part of the C++ Standard Template Library (STL) and is defined in the

*<cmath>*header. The

**header provides several mathematical functions, including**

*<cmath>**ceil()*. The function is defined with multiple prototypes, depending on the data type of the input argument and the return value.

The prototypes are as follows:

double ceil(double x);float ceil(float x);long double ceil(long double x);

In addition to ceil(), C++ also provides similar functions **ceilf()** and **ceill()**, for operating on ** float** and

**data types, respectively. These functions work in the same way as**

*long double**ceil()*, but they return the result as a float and long double, respectively.

For example:

float f = 3.14f;float result = ceilf(f); //result will be 4.0f
long double l = 3.14;long double result = ceill(l); //result will be 4.0

It is important to note that the ** ceil(), ceilf(), **and

**functions are defined in the**

*ceill()***header file. So it should be included to use these functions.**

*<cmath>***Limitations of ceil() function**

There are a few drawbacks to using the ** ceil() **function in C++:

**The function can cause overflow or underflow:**If the input value is too large or too small, the function can produce unexpected results or cause errors in the program.**It can also cause performance issues:**The*ceil()*function is computationally expensive, especially when used in tight loops or with large arrays. This can slow down the performance of your program.**Loss of precision:**The*ceil()*function rounds the input value to the next highest integer, which can cause a loss of precision for certain decimal values.**Limited range of values:**The*ceil()*function can only be used for floating-point numbers, so it is not suitable for other types of data.**It doesn’t handle NaN, +infinity, and -infinity:**The function can’t handle the special cases of NaN, +infinity, and -infinity. It will output an error in such cases.

Remembering these drawbacks when using the ceil() function in your C++ program is important. In some cases, an alternative approach may be more appropriate, such as using a ** round() **function or manual rounding.

**Examples of ceil() Function**

Here are some examples of how the ceil() function can be used in C++:

**Example 1: Rounding a decimal value to the next highest integer**

#include <iostream>#include <cmath>
int main(){ double num = 3.14; std::cout << "Original value: " << num << std::endl; std::cout << "Rounded value: " << std::ceil(num) << std::endl; return 0;

**Output:**

Original value: 3.14

Rounded value: 4

**Example 2: Rounding a negative decimal value**

#include <iostream>#include <cmath>
int main(){ double num = -2.99; std::cout << "Original value: " << num << std::endl; std::cout << "Rounded value: " << std::ceil(num) << std::endl; return 0;}

**Output:**

Original value: -2.99

Rounded value: -2

**Example 3: Rounding a decimal value with a precision of 2 decimal places**

#include <iostream>#include <cmath>#include <iomanip>
int main(){ double num = 3.14; std::cout << "Original value: " << std::setprecision(2) << num << std::endl; std::cout << "Rounded value: " << std::ceil(num) << std::endl; return 0;}

**Output:**

Original value: 3.14

Rounded value: 4

You can also use** ceilf()** and

**in a similar way for**

*ceill()***and**

*float***, respectively.**

*long double*It would be best to be careful when using this function on large numbers, as it can cause overflow or underflow.

**Conclusion**

The ** ceil()** function in C++ is found in the <cmath> header file. When called, it accepts a double value as an input and returns the smallest integer value greater than or equal to the input number. This returned value is referred to as the

**ceiling value**of the number passed as a parameter.

**About the Author**

This is a collection of insightful articles from domain experts in the fields of Cloud Computing, DevOps, AWS, Data Science, Machine Learning, AI, and Natural Language Processing. The range of topics caters to upski... Read Full Bio