将双精度序列化为字符串并再次返回的最佳方法是什么？

Question

我有一个 Java 程序，它使用 ProcessBuilder 启动一个 C++ 程序，并将 C++ 应用程序的输出作为字符串读取。数据是多种数据类型的混合，我通过std::cout 将所有内容序列化为字符串，如下所示：

void write_data(int x) {
    std::cout << "int:" << x << std::endl;
}

void write_data(double x) {
    std::cout << "double:" << x << std::endl;
}

在 Java 方面，我正在做类似的事情：

String line = readLineFromSubProcess();
String[] parts = line.split(":");

if (parts[0].equals("double")) {
  return Double.parseDouble(parts[1]);
}

但是，由于我正在读取传感器数据，因此我担心浮点值会丢失精度。我直接控制序列化格式。

如何将 double 值从 C++ 写入 std::cout，以使从 Java 中读取它会产生完全相同的双精度值？

Answer 1

这会有帮助吗？

std::cout << std::setprecision(5) << f << '\n';

请参阅以下示例：

http://www.cplusplus.com/reference/iomanip/setprecision/

Answer 2

我决定采用的解决方案是将reinterpret_cast 将double 转换为int64_t 并将float 转换为int32_t，并且仅针对这两种数据类型使用部分模板特化。我仍然缺少字节序转换，但由于这里的所有内容都是小字节序，我想我会没事的：

template <typename T>
void write_data(T x) {
    std::cout << get_type_name<T>() << ":" << x << std::endl;
}

template<>
void write_data<double>(double x) {
    union {
        double d;
        int64_t i;
    } n;
    n.d = x;
    std::cout << "double_as_int64:" << n.i << std::endl; 
}

template<>
void write_data<float>(double x) {
    union {
        float f;
        int32_t i;
    } n;
    n.f = x;
    std::cout << "float_as_int32:" << n.i << std::endl; 
}

我并不是真的在做 reinterpret_cast，因为我的编译器 (GCC) 给了我一个 warning about aliasing，这与我们在这里使用的编译器开关有关：

取消引用类型双关指针会破坏严格的别名规则

在 Java 方面我正在做：

String line = readLineFromSubProcess();
String[] parts = line.split(":");

if (parts[0].equals("double")) {
  return Double.parseDouble(parts[1]);
} else if (parts[0].equals("double_as_int64") {
  return Double.longBitsToDouble(Long.parseLong(parts[1]));
} else if (parts[0].equals("float_as_int32") {
  return Float.intBitsToFloat(Integer.parseInt(parts[1]));
}

这是什么Google Protocol Buffers are doing under the hood。

Answer 3

嗯，正如你所说，有两种选择，如果你关心可读性并且需要打印双打那么：

方法一： （可读）

#include <limits>

void double_to_string(double the_double, int offset_to_max)
{
        typedef std::numeric_limits<double> doublelimit;

        // ready to transfer
        std::cout.precision(doublelimit::digits10 + offset_to_max);
        std::cout << the_double << std::endl;
}

// Back to double
double cstring_to_double(const char *s)
{
        return std::atof(s);
}

int main(int argc, char *argv[]) {

        double the_double = 0.10000000000000002;
        //double the_double = 0.1; 
        int offset = 2;

        double_to_string(the_double, offset);
}

这样，打印的双精度数将使用全精度 (17) 出现别名。我建议使用 17，因为默认值总是会尝试舍入。无论哪种方式，使用此方法的完整正确打印都需要更强大的库。

方法二： （二进制）

只需 memcpy 值，使用 int64 即可，double 最多可存储 53 位：

template<typename T, typename H = int64_t>
H write_data(T x) 
{
    H i;
    // Can we hold the data?
    if (sizeof(T) > sizeof(H)) assert(false); // or write some error procesing
    // Now take the lower size of the two.
    memcpy(&i, &x, sizeof(H) > sizeof(T) ? sizeof(T) : sizeof(H));

    return i;
}

// union version
template<typename T, typename H = int64_t>
H write_data_u(T x)
{
    // Can we hold the data?
    if (sizeof(T) > sizeof(H)) assert(false); // or write some error procesing

    union {
        T d;
        H i;
    } n;

    n.d = x;

    return n.i;
}


int main(int argc, char *argv[]) 
{
    double the_double = 0.10000000000000001;
    int64_t double_holder = write_data<double, int64_t>(the_double);

    // Binary data as decimal string: ready to transfer the string, remember to convert to big_endian first if you transfer the binary representation.
    std::cout << "double_as_int64:" << double_holder << std::endl;

    // Back to double (we know int64_t holds a double so we dont care about the remaining bits)
    double back_to_double = write_data<int64_t, double>(double_holder);
    std::cout.precision(std::numeric_limits<double>::digits10 + 2);
    std::cout << "back_to_double:" << back_to_double << std::endl;
}