In this blog, we will learn different methods to convert a double to a long in C++ with explanations, code examples, and outputs.

## Introduction:

In C++ programming, data type conversions are a common necessity when working with different data types. One such conversion that often comes up is converting a `double` to a `long`. This seemingly simple task can be tricky due to the fundamental differences between these data types. In this blog, we will explore various methods to convert a `double` to a `long` in C++.

## Method 1: Using Type Casting

The simple method to convert a `double` to a `long` in C++ is to use type casting. C++ provides two casting operators for this purpose: `static_cast` and `reinterpret_cast`. However, when converting a `double` to a `long`, the `static_cast` is the safer and more appropriate choice.

``````double doubleValue = 42.75;
long longValue = static_cast<long>(doubleValue);
``````

### Output:

``````doubleValue: 42.75
longValue: 42
``````

In the above code snippet, we have a `double` variable `doubleValue` with the value 42.75. We use the `static_cast` operator to convert it to a `long`, resulting in `longValue` with the value 42. The fractional part of the `double` is truncated during this conversion.

## Method 2: Using C-Style Type Casting

C++ allows C-style type casting, which can be used to convert data types, but it's generally not recommended due to its potential risks. However, it's worth mentioning here for the sake of completeness.

``````double doubleValue = 42.75;
long longValue = (long)doubleValue;
``````

### Output:

``````doubleValue: 42.75
longValue: 42
``````

In this code snippet, we perform the same conversion as in Method 1, but we use the C-style type casting syntax. While this method can work, it's riskier and less type-safe than using `static_cast`. It might lead to undefined behavior in some situations, so it's generally best to avoid it.

## Method 3: Rounding and Truncation

Sometimes, you might need to round a `double` to the nearest integer and then convert it to a `long`. This can be achieved using the `round` function from the `<cmath>` header, which rounds the `double` value to the nearest integer.

``````#include <iostream>
#include <cmath>

int main() {
double doubleValue = 42.75;
long longValue = static_cast<long>(round(doubleValue));

std::cout << "doubleValue: " << doubleValue << std::endl;
std::cout << "longValue: " << longValue << std::endl;

return 0;
}
``````

### Output:

``````doubleValue: 42.75
longValue: 43
``````

In this method, we first use the `round` function to round the `double` value to the nearest integer, which results in 43. Then, we convert it to a `long`, obtaining `longValue` with the value 43. This method is useful when you need to round the `double` to the nearest integer before converting it to a `long`.

## Method 4: Checking for Range

Converting a `double` to a `long` may lead to unexpected results if the `double` value is too large or too small to fit within the range of a `long`. In such cases, it's crucial to check for potential overflows or underflows before the conversion.

``````double doubleValue = 1.8e19;  // A large double value
if (doubleValue >= std::numeric_limits<long>::min() && doubleValue <= std::numeric_limits<long>::max()) {
long longValue = static_cast<long>(doubleValue);
std::cout << "doubleValue: " << doubleValue << std::endl;
std::cout << "longValue: " << longValue << std::endl;
} else {
std::cout << "doubleValue is out of range for a long." << std::endl;
}
``````

### Output (if within range):

``````doubleValue: 1.8e19
longValue: -9223372036854775808
``````

### Output (if out of range):

``````doubleValue is out of range for a long.
``````

In this method, we start with a `double` value that is large (1.8e19 in this example) and potentially outside the range of a `long`. Before performing the conversion, we use the `std::numeric_limits` class to check if the `double` value falls within the acceptable range for a `long`. If it's within the range, we proceed with the conversion; otherwise, we handle it as an out-of-range case. In this specific example, the `double` value is out of range, resulting in a message indicating that fact.

## Method 5: Using C++11 Standard Library Functions

Starting from C++11, you can also use the standard library functions `lround` and `llround` to round a `double` to the nearest `long` or `long long`, respectively. These functions provide a more concise and expressive way to perform the conversion.

``````#include <iostream>
#include <cmath>

int main() {
double doubleValue = 42.75;
long longValue = std::lround(doubleValue);

std::cout << "doubleValue: " << doubleValue << std::endl;
std::cout << "longValue: " << longValue << std::endl;

return 0;
}
``````

### Output:

``````doubleValue: 42.75
longValue: 43
``````

In this method, we use the `std::lround` function to round the `double` value to the nearest `long`. The result is then directly assigned to `longValue`. This approach is more modern and in line with C++11 and later standards, offering a concise and readable way to perform the conversion.

## Method 6: Handling Special Cases

In some scenarios, you might encounter `double` values that represent special cases such as positive or negative infinity or NaN (Not-a-Number). Converting these special cases to a `long` requires special consideration.

``````#include <iostream>
#include <cmath>
#include <limits>

int main() {
double doubleValue = std::numeric_limits<double>::infinity();  // Positive infinity
long longValue;

if (std::isfinite(doubleValue)) {
longValue = std::lround(doubleValue);
} else {
if (std::isnan(doubleValue)) {
std::cout << "doubleValue is NaN." << std::endl;
} else {
std::cout << "doubleValue is infinity." << std::endl;
}
}

std::cout << "doubleValue: " << doubleValue << std::endl;
if (std::isfinite(doubleValue)) {
std::cout << "longValue: " << longValue << std::endl;
}

return 0;
}
``````

### Output (for positive infinity):

``````doubleValue: inf
longValue: value is not valid
``````

### Output (for NaN):

``````doubleValue: nan
doubleValue is NaN.
``````

In this method, we start with a `double` value representing positive infinity or NaN. Before converting, we use the `std::isfinite` and `std::isnan` functions to check the special case and handle it accordingly. For positive infinity, we indicate that it's not a valid conversion result, and for NaN, we simply acknowledge it as such.

## Conclusion:

Converting a `double` to a `long` in C++ can be a straightforward or complex task, depending on the requirements and the specific use case. The choice of method depends on factors such as the need for rounding, range checking, and handling special cases like infinity and NaN. When converting a `double` to a `long`, it's essential to be aware of the potential pitfalls, such as loss of precision, data range issues, and handling special cases. 