C++ 为什么可以'；t我在显示矢量时看到所有有效数字<；长双人床>；？

我有一个控制台应用程序，它有一个函数，可以对Fibonacci数列的整数进行除法，演示任何Fibonacci数列中的比率如何接近Φ。我用Go和

C++11

编写了simliar代码。在

Go

（或科学计算器）中，函数返回

int64

的值，结果显示Ubuntu终端会话的精度高达16位，例如：

1.6180339937902115

在C++11中，使用

cout

，我看不到超过5位精度的结果。结果在如下函数中声明为

long double

：

typedef unsigned long long int ULInt;
typedef std::vector< ULInt> ULIntV;

std::vector<long double > CalcSequenceRatio( const ULIntV& fib )
{

    std::vector<long double> result;

    for ( int i = 0; i != fib.size( ); i ++ )
    {
         if ( i == ( fib.size( ) - 1 ) )
         {
             result[i] = 0;
             break;
          }

    long double n = fib[i + 1];
    long double n2 = fib[i];
    long double q = n / n2;

    result.push_back( q );

  }
     return result;
 }

typedef无符号长整型；
typedef std:：vectorULIntV；
标准：：矢量计算序列（常数ULIntV和fib）
{
std：：向量结果；
for（inti=0；i！=fib.size（）；i++）
{
如果（i==（纤维大小（）-1））
{
结果[i]=0；
打破
}
长双n=fib[i+1]；
长双n2=fib[i]；
长双q=n/n2；
结果：推回（q）；
}
返回结果；
}

尽管传递到

CalcSequenceRatio（const ULIntV&fib）

的向量

fib

包含100多个条目，但在16个条目之后，结果集中的所有值都显示为

1.61803

其余的值被四舍五入，尽管在Go（或计算器）中，我可以看到实际值扩展到至少16位精度

如何使

CalcSequenceRatio（）

返回更精确的值？是否存在问题，因为从

long-long-int

到

long-double

是向下转换？我是否需要将fib序列作为向量传递？怎么了

编辑：

这个问题被标记为重复，但这并不是真正正确的，因为这个问题并没有直接涉及到

cout

：虽然分析证明问题出在

cout

，但还有其他因素可能会造成不同。我发布了正确的答案：

问题在于cout，这里是解决方案。。。如中所述 另一个问题

---

这里的问题在于

std:：cout

我使用

std:：setprecision（50）

修复了它，如中所述，其中显示了如下值：

typedef unsigned long long int ULInt;
typedef std::vector< ULInt> ULIntV;

std::vector<long double > CalcSequenceRatio( const ULIntV& fib )
{

    std::vector<long double> result;

    for ( int i = 0; i != fib.size( ); i ++ )
    {
         if ( i == ( fib.size( ) - 1 ) )
         {
             result[i] = 0;
             break;
          }

    long double n = fib[i + 1];
    long double n2 = fib[i];
    long double q = n / n2;

    result.push_back( q );

  }
     return result;
 }

1.61803398749894848207210029669248109537875279784

为了使其灵活，我给用户提供了输入所需精度级别的选项：

void printGolden( const std::vector<long double>& golden )
{
    cout << "Enter desired precision:" << endl;
    int precision{};
    cin >> precision;
    std::cout << std::setprecision( precision );
    for ( auto i : golden )
    {
      std::cout << i << "; ";
    }

void printGolden（const std:：vector&golden）
{
精密度；
std:：cout这里的问题在于
std:：cout

我使用
std:：setprecision（50）
修复了它，如中所述，其中显示了如下值：

typedef unsigned long long int ULInt;
typedef std::vector< ULInt> ULIntV;

std::vector<long double > CalcSequenceRatio( const ULIntV& fib )
{

    std::vector<long double> result;

    for ( int i = 0; i != fib.size( ); i ++ )
    {
         if ( i == ( fib.size( ) - 1 ) )
         {
             result[i] = 0;
             break;
          }

    long double n = fib[i + 1];
    long double n2 = fib[i];
    long double q = n / n2;

    result.push_back( q );

  }
     return result;
 }

1.61803398749894848207210029669248109537875279784

为了使其灵活，我给用户提供了输入所需精度级别的选项：

void printGolden( const std::vector<long double>& golden )
{
    cout << "Enter desired precision:" << endl;
    int precision{};
    cin >> precision;
    std::cout << std::setprecision( precision );
    for ( auto i : golden )
    {
      std::cout << i << "; ";
    }

void printGolden（const std:：vector&golden）
{
精密度；
std:：cout这里的问题在于
std:：cout

我使用
std:：setprecision（50）
修复了它，如中所述，其中显示了如下值：

typedef unsigned long long int ULInt;
typedef std::vector< ULInt> ULIntV;

std::vector<long double > CalcSequenceRatio( const ULIntV& fib )
{

    std::vector<long double> result;

    for ( int i = 0; i != fib.size( ); i ++ )
    {
         if ( i == ( fib.size( ) - 1 ) )
         {
             result[i] = 0;
             break;
          }

    long double n = fib[i + 1];
    long double n2 = fib[i];
    long double q = n / n2;

    result.push_back( q );

  }
     return result;
 }

1.61803398749894848207210029669248109537875279784

为了使其灵活，我给用户提供了输入所需精度级别的选项：

void printGolden( const std::vector<long double>& golden )
{
    cout << "Enter desired precision:" << endl;
    int precision{};
    cin >> precision;
    std::cout << std::setprecision( precision );
    for ( auto i : golden )
    {
      std::cout << i << "; ";
    }

void printGolden（const std:：vector&golden）
{
精密度；
std:：cout这里的问题在于
std:：cout

我使用
std:：setprecision（50）
修复了它，如中所述，其中显示了如下值：

typedef unsigned long long int ULInt;
typedef std::vector< ULInt> ULIntV;

std::vector<long double > CalcSequenceRatio( const ULIntV& fib )
{

    std::vector<long double> result;

    for ( int i = 0; i != fib.size( ); i ++ )
    {
         if ( i == ( fib.size( ) - 1 ) )
         {
             result[i] = 0;
             break;
          }

    long double n = fib[i + 1];
    long double n2 = fib[i];
    long double q = n / n2;

    result.push_back( q );

  }
     return result;
 }

1.61803398749894848207210029669248109537875279784

为了使其灵活，我给用户提供了输入所需精度级别的选项：

void printGolden( const std::vector<long double>& golden )
{
    cout << "Enter desired precision:" << endl;
    int precision{};
    cin >> precision;
    std::cout << std::setprecision( precision );
    for ( auto i : golden )
    {
      std::cout << i << "; ";
    }

void printGolden（const std:：vector&golden）
{
精密度；
std：：cout听起来您想使用：用于不同的“往返”转换-与
std：：setprecision
结合使用

e、 例如，对于
float
这通常是
（9）
=>或
1.8
格式。
double
通常是
（17）
=>
1.16

长双精度
通常在x86上实现为80位类型，或128位类型，分别为
（21）
=>
1.20
和
（36）
=>
1.35
格式。然而，
长双精度
仅要求提供至少与
双精度
相同的精度

有一系列关于相关主题的注释。
听起来你想使用：用于不同的“往返”转换-与
std:：setprecision
结合使用

e、 例如，对于
float
这通常是
（9）
=>或
1.8
格式。
double
通常是
（17）
=>
1.16

长双精度
通常在x86上实现为80位类型，或128位类型，分别为
（21）
=>
1.20
和
（36）
=>
1.35
格式。然而，
长双精度
仅要求提供至少与
双精度
相同的精度

有一系列关于相关主题的注释。
听起来你想使用：用于不同的“往返”转换-与
std:：setprecision
结合使用

e、 例如，对于
float
这通常是
（9）
=>或
1.8
格式。
double
通常是
（17）
=>
1.16

长双精度
通常在x86上实现为80位类型，或128位类型，分别为
（21）
=>
1.20
和
（36）
=>
1.35
格式。然而，
长双精度
只需要提供至少与相同的精度