最轻松的……

#include <limits>

using std::numeric_limits;

    ...
    cout.precision(numeric_limits<double>::digits10 + 1);
    cout << d;

以下是我会使用的方法:

std::cout << std::setprecision (std::numeric_limits<double>::digits10 + 1)
          << 3.14159265358979
          << std::endl;

基本上，限制包具有所有内置类型的特性。 浮点数(float/double/long double)的特征之一是digits10属性。这定义了以10为基底的浮点数的精度(我忘记了确切的术语)。

参见:http://www.cplusplus.com/reference/std/limits/numeric_limits.html 查看其他属性。

最轻松的……

#include <limits>

using std::numeric_limits;

    ...
    cout.precision(numeric_limits<double>::digits10 + 1);
    cout << d;

最好的选择是使用std::setprecision，解决方案是这样的:

# include <iostream>
# include <iomanip>

int main()
{
    double a = 34.34322;
    std::cout<<std::fixed<<a<<std::setprecision(0)<<std::endl;
    return 0;
}

注意:您不需要使用cout。我在std::setprecision处填充0，因为它必须有一个参数。

在这个问题中，有一个关于如何无损地将double类型转换为字符串的描述(在Octave中，但它可以很容易地在c++中重现)。我们的想法是对浮点数有一个人类可读的简短描述和一个十六进制形式的无损描述，例如:pi -> 3.14{54442d18400921fb}。

这是一个适用于任何浮点类型的函数，而不仅仅是双精度浮点类型，它还将流放回之后找到它的方式。不幸的是，它不能很好地与线程交互，但这是iostreams的本质。你需要在文件的开头包含以下内容:

#include <limits>
#include <iostream>

这是这个函数，如果你经常使用它，你可以把它放在头文件中:

template <class T>
void printVal(std::ostream& os, T val)
{
    auto oldFlags = os.flags();
    auto oldPrecision = os.precision();

    os.flags(oldFlags & ~std::ios_base::floatfield);
    os.precision(std::numeric_limits<T>::digits10);
    os << val;
    
    os.flags(oldFlags);
    os.precision(oldPrecision);
}

像这样使用它:

double d = foo();
float f = bar();
printVal(std::cout, d);
printVal(std::cout, f);

如果你想使用普通的插入<<操作符，你可以使用额外的包装器代码:

template <class T>
struct PrintValWrapper { T val; };
template <class T>
std::ostream& operator<<(std::ostream& os, PrintValWrapper<T> pvw) {
    printVal(os, pvw.val);
    return os;
}
template <class T>
PrintValWrapper<T> printIt(T val) {
    return PrintValWrapper<T>{val};
}

现在你可以这样使用它:

double d = foo();
float f = bar();
std::cout << "The values are: " << printIt(d) << ", " << printIt(f) << '\n';