Boost lexical_cast将double转string结果异常，求解决方案

Hey there, let's work through this issue you're having with boost::lexical_cast giving unexpected results when converting a double to a std::string. Given your environment (g++ 5.4.0, Boost 1.66), here are the most likely fixes tailored to your problem:

Common Causes & Solutions #

1. Default Precision/Scientific Notation Mismatch #

By default, lexical_cast uses the standard stream's default formatting for doubles, which might switch to scientific notation for very large/small numbers or truncate precision more than you expect. If your expected output requires fixed decimal places or specific precision, bypass the default behavior with explicit formatting:

Option 1: Use std::ostringstream with Format Manipulators

This gives you full control over how the double is rendered:

#include <sstream>
#include <iomanip>
#include <string>

std::string convert_double_to_string(double val) {
    std::ostringstream oss;
    // Adjust fixed/setprecision to match your expected output
    oss << std::fixed << std::setprecision(6) << val; 
    return oss.str();
}

• std::fixed forces fixed-point notation instead of scientific
• std::setprecision(n) sets the number of digits after the decimal point (tweak n to match your expected result)

Option 2: Use Boost.Format for Boost-native Formatting

If you prefer sticking with Boost tools, Boost.Format lets you define explicit format strings:

#include <boost/format.hpp>
#include <string>

std::string convert_double_to_string(double val) {
    // Adjust the format string (e.g., "%.8f" for 8 decimal places)
    return boost::str(boost::format("%.6f") % val); 
}

2. Handle Special Double Values (NaN/Infinity) #

If your input double is a NaN (not-a-number) or infinity, lexical_cast will output strings like "nan" or "inf" instead of a numeric value. Add checks to handle these cases:

#include <cmath>
#include <string>
#include <boost/lexical_cast.hpp>

std::string safe_double_conversion(double val) {
    if (std::isnan(val)) {
        return "0.0"; // Replace with your expected default value
    }
    if (std::isinf(val)) {
        return "0.0"; // Or another appropriate fallback
    }
    return boost::lexical_cast<std::string>(val);
}

3. Verify Input Double's Actual Value #

Double-check that the double you're converting is exactly the value you expect. Floating-point numbers can have precision errors from calculations, so if your input is the result of arithmetic operations, it might hold a value slightly different than what you think (e.g., 0.1 can't be represented exactly as a binary float). In this case, adjusting the formatting precision to round to your desired output will help.

内容的提问来源于stack exchange，提问作者AbbasFaisal