Home / Questions / 233742
Accepted
Victor Alfonso Pérez Espino
Asked: 2020-01-30 17:06:53 +0800 CST 2020-01-30 17:06:53 +0800 CST

上下近似（类似于舍入） C++

  • 772

如何在默认情况下和过量情况下近似一个数字？理解我们所说的，我们有数字 2.534823

小数点后 4 位的默认近似值为2.5348

对于超过 4 位小数的近似值，它将是2.5349

这就像四舍五入但对于特定的小数位，有没有办法在 C++ 中做到这一点？

我有以下示例，但它只会四舍五入到最接近的整数，无论​​更大或更小：

#include<iostream>
#include<math.h>
using namespace std;


int main(){

    float num;
    int decim;

    cout<<"\tCalcular aproximaciones por defecto y exceso"<<endl<<endl;

    cout<<"Ingrese un numero: " ;
    cin>>num;

    cout<<"Ingresa la cantidad de dedcimales a dejar: ";
    cin>>decim;

    /*
        con ceil y floor me acerca al entero,
        ceil al entero más cercano mayor
        floor al  entero más cercano menor
    */

    cout<<"Aproximación por exceso: "<<ceil(num)<<endl;

    cout<<"Aproximación por defecto: "<<floor(num)<<endl;

    /*
       la aproximación debería quedar como:
       numero ingresado = 1.432986

       para por defecto  con 4 decimales, quedaria 1.4329
       para exceso con 4 decimales quedaría 1.4323
       pero con ceil, subiría a 2
       y con floor bajaría a 1


    */

    return 0;
}

在C中，您可以在打印时将数字截断到指定的小数位数（即默认近似值）：

printf("%.3f", x);

任何一个

printf("%3f", x);

我不记得这两种方法中的哪一种，我想知道的是如何在C++中完成相同的操作，并且还可以通过过量获得近似值

c++

2 Answers

  1. Best Answer

    正如我们已经知道的那样，浮点数是不精确的，所以直接使用二进制值会导致......奇怪的结果。

    一种可能的解决方案是对已经转换为字符串的值进行近似，尽管这需要我们手动执行某些操作：

    #include <string>
#include <iostream>
#include <sstream>

std::string upround( float value, unsigned decimals ) {
  std::stringstream buffer;

  buffer << value;

  // Cosas mias. `str( )` devuelve copias ... no vamos a estar todo el rato copiando cosas.
  std::string workCopy( buffer.str( ) );

  // Buscamos la posición del punto decimal.
  auto posOfPoint = workCopy.find( '.' );

  // Si es un número entero (sin punto), nada que hacer.
  if( posOfPoint == std::string::npos ) return workCopy;

  // Total de número a la derecha de la coma:
  auto workDecimals = workCopy.size( ) - 1 - posOfPoint;

  // Si hay menos decimales que los pedidos, nada que hacer.
  if( workDecimals < decimals ) return workCopy;

  // Recortamos la cadena.
  if( workDecimals > decimals ) workCopy.erase( workCopy.length( ) - ( workDecimals - decimals ) );

  // Trivial: el último dígito es != 9.
  if( workCopy.back( ) != '9' ) {
    ++( workCopy.back( ) );
  } else {
    // No trivial. El último dígito es un '9'. Es el caso 'chulo' :-)
    int pickup = 1;

    for( int idx = workCopy.length( ) - 1; idx >= 0; --idx ) {
      if( workCopy[idx] == '.' ) continue;
      workCopy[idx] += pickup;
      if( workCopy[idx] > '9' ) {
        workCopy[idx] = '0';
        pickup = 1;
      } else {
        pickup = 0;
        break;
      }
    }

    // Ya terminamos con la cadena.
    // Si aún nos queda 1 por sumar, hay que añadir un número al principio.
    if( pickup ) workCopy.insert ( 0, 1, '1' );
  }

  return workCopy;
}

int main( ) {
  const auto testValue = 3.1415f;
  std::cout << "Valor de prueba: " << testValue << '\n';
  std::cout << upround( testValue, 2 ) << '\n';
  std::cout << upround( testValue, 3 ) << '\n';

  const auto testValue2 = 9.9999f;
  std::cout << "Valor de prueba: " << testValue2 << '\n';
  std::cout << upround( testValue2, 3 ) << '\n';
  std::cout << upround( testValue2, 4 ) << '\n';
  return 0;
}

    我没有彻底测试过；对于测试值（3.1415f和9.9999f）显示如下：

    测试值：3.1415
    3.15
    3.142
    测试值：9.9999
    10.000
    10.0000

    注意：将其转换为 相对容易template< >，并且为此添加一个额外的参数以便能够使用除句点 ( .) 之外的其他分隔符。

    • 4

  2. 使用std::setprecision，您的小数点后 3 位为2.535，小数点后 4 位为2.5348，此代码：

    auto valor = 2.534823;

for (auto precision : {2, 3, 4, 5, 6, 7, 8, 9, 10})
    std::cout << std::setprecision(precision) << valor << '\n';

    产生以下输出：

    2.5
2.53
2.535
2.5348
2.53482
2.534823
2.534823
2.534823
2.534823

    你可以看到它在Wandbox上运行。此外，您可以使用 设置浮点数的舍入方式std::fesetround，有四种舍入方式：

    • FE_DOWNWARD: 向负数舍入。
    • FE_TONEAREST：四舍五入到最接近的可表示值。
    • FE_TOWARDZERO: 向零舍入。
    • FE_UPWARD: 朝正方向舍入。

    通过四舍五入，上述程序：

    std::fesetround(FE_DOWNWARD);

for (auto precision : {2, 3, 4, 5, 6, 7, 8, 9, 10})
    std::cout << std::setprecision(precision) << valor << '\n';

    它显示以下输出：

    2.5
2.53
2.534
2.5348
2.53482
2.534822
2.5348229
2.53482299
2.534822999
    • 3