从 double 到 const int 的 C++ 类型转换无法正常工作

Posted 2023-02-25

【中文标题】从 double 到 const int 的 C++ 类型转换无法正常工作

【英文标题】：C++ Type casting from double to const int does not work properly

【发布时间】：2013-01-24 20:21:41

【问题描述】：

我有一个 const int 类型的变量，但它所依赖的参数是 double 类型。当我尝试将其从“double”转换为“const int”时，它无法正常工作。例如，当N应该是991时，输入为990。我尝试了几种方法，只有一种有效，但我不确定这种方法是否会一直有效。以下是我尝试过的一些方法：

第一种方法：

const int N = (Ls-1)/dx + 1;

第二种方法：

const int N = static_cast<const int>((Ls-1)/dx) + 1;

第三种方法：

double Z = (Ls-1)/dx + 1;
const int N = Z;

第四种方法（唯一的工作方法）：

double Z = (Ls-1)/dx;
const int N = Z + 1;

请注意，dx 是一个值，使得 (Ls-1)/dx 的余数始终为零（即它始终是整数值）。无论如何可以解释为什么其他方法不起作用，以便我可以更好地理解类型转换？

编辑：根据要求，我正在上传整个代码以显示一切是如何工作的：

#include <iostream>
#include <math.h>
#include <stdio.h>
#include <fstream>
#include <cmath>
#include <algorithm>

#define pi 3.14159265

using namespace std;

//Define Fluid Properties
double rho_L = 998; //Liquid Density
double rho_LG = 828.9; //Liquid-Gas Density Ratio
double mu_L = 0.000798; //Liquid Viscosity
double mu_LG = 40.24; //Liquid-Gas Viscosity Ratio
double sigma = 0.0712; //Surface Tension
double nu_G = (mu_L/mu_LG)/(rho_L/rho_LG);

//Define Injector Properties
double Uinj = 56.7; //Injection Velocity
double Dinj = 0.0998; //Injector Diameter
double theta = 15.0*pi/180.0; //Spray Cone Angle
double L = 500.0*Dinj; //Atomization Length
double Ls = L/Dinj; //Normalized Atomization Length

//Define Solver Parameters
double K = 5294; //Viscous Dissipation Coefficient
double Eps = pow(10,-5); //Residual Error
double dx = 0.0001; //Step Size
double Ui = 10; //Initial Guess
//const int Z = static_cast<const int>((Ls-1)/dx + 1) + 1;
const int N = (Ls-1)/dx + 1;//Z;

double deriv (double U, double X, double delta, double m)

    double dudx;
    dudx = -(1.0/delta)*(1.0/U)*(U - sqrt(1.0 - U)/sqrt(m*X*X))*(U - sqrt(1.0 - U)/sqrt(m*X*X));
    return (dudx);


int main()

    //Declare Variables
    int max_step;
    double ERR;
    int step;
    double DEN;
    double SMD;
    double m;
    double Ug;
    double Re;
    double Cd;
    double delta;
    double K1;
    double K2;
    double K3;
    double K4;

    //Allocate Memory From Heap
    double *U = new double [N];
    double *X = new double [N];

    //Initialize Vectors and Variables
    DEN = 0.5*rho_L - (4.0/3.0)*K*(mu_L)/(Uinj*Dinj*Dinj)*L;

    m = 4.0/rho_LG*tan(theta)*tan(theta);

    for (int i = 0; i < N; i++)
    
        X[i] = 1.0 + dx*i;
    
    U[0] = 1.0;

    max_step = 1;
    ERR = 1;
    step = 0;
    while(abs(ERR) > Eps && step < max_step)
    

        //Calculate Ug
        Ug = sqrt(1.0 - (Ui/Uinj))/sqrt(m*Ls*Ls)*Uinj;

        //Calculate SMD
        SMD = 6.0*sigma/(DEN*(Uinj*Uinj - Ui*Ui));

        //Calculate Re # and Drag Coefficient
        Re = abs(Ui-Ug)*SMD/nu_G;

        if(Re <= 0.01)
        
            Cd = (0.1875) + (24.0/Re);
        
        else if(Re > 0.01 && Re <= 260.0)
        
            Cd = (24.0/Re)*(1.0 + 0.1315*pow(Re,(0.32 - 0.05*log10(Re))));
        
        else
        
            Cd = (24.0/Re)*(1.0 + 0.1935*pow(Re,0.6305));
        

        //Determine New U
        delta = (4.0/3.0)*(1.0/Cd)*(rho_LG)*(SMD/Dinj);

        //RK4
        for (int i = 0; i < N-1; i++)
        
            K1 = deriv(U[i],X[i],delta,m);
            K2 = deriv(U[i]+0.5*dx*K1,X[i]+0.5*dx,delta,m);
            K3 = deriv(U[i]+0.5*dx*K2,X[i]+0.5*dx,delta,m);
            K4 = deriv(U[i]+dx*K3,X[i+1],delta,m);
            U[i+1] = U[i] + dx/6.0*(K1 + 2.0*K2 + 2.0*K3 + K4);
            //if(i >= 0 && i <= 3)
                //cout << i << " " << K1 << " " << K2 << " " << K3 << " " << K4 << " " << U[i] << endl;
        

        ERR = abs(U[N-1]*Uinj - Ui)/Ui;

        Ui = U[N-1]*Uinj;

        step = step + 1;
    

    SMD = 6.0*sigma/(DEN*(Uinj*Uinj - Ui*Ui));

    cout << "U = " << Ui << endl;
    cout << "SMD = " << SMD << endl;
    cout << "DEN = " << DEN << endl;
    cout << "Ug = " << Ug << endl;
    cout << "m = " << m << endl;
    cout << "delta = " << delta << endl;
    cout << "Re = " << Re << endl;
    cout << "Cd = " << Cd << endl;
    cout << "U* = " << U[N-1] << endl;
    cout << "Error = " << ERR << endl;
    cout << "step = " << step << endl;

    //Output Data Into Text File
    ofstream outputdata("result-500-15.txt");
    for (int i = 0; i < N; i++)
    
        outputdata << X[i] << " " << U[i] << '\n';
    
    outputdata.close();

    delete [] U;
    delete [] X;

    return 0;

【问题讨论】：

听起来这可能是一个四舍五入的问题——也许(Ls-1)/dx 实际上是（比如）990.999999999999，所以它实际上是 991，但向下转换会将它截断为 990。如果你尝试 @987654327 会发生什么@?

目前dx = 0.1，Ls-1 = 99，所以(Ls-1)/dx 应该是990，但也许不能用二进制做0.1？如果我添加 0.01，它确实有效，但它会一直有效吗？

实际上，现在我想起来，舍入应该不是问题，因为包含“+1”应该可以解决任何舍入问题。

如果 Z 最后是一个整数，+1 会给你错误的答案。最好使用“const int N = Z + 0.5”。但是，如果 Z 为负数，那将失败。最好使用 C 标准库函数 roundl() 来处理这种情况。

我想我可能错误地描述了这个等式。 “N = (Ls - 1)/dx + 1”实际上是我要解决的问题。 +1 是等式的一部分。我基本上是在尝试给定间距 (dx) 以及起点和终点 (Ls-1) 的向量中的点数。

【参考方案1】：

您的猜测是正确的：0.1 在二进制中没有有限表达式。这是一个相当复杂的问题，并且有 许多 极端情况，通常无法通过添加 0.01 来解决，如您的评论中提到的。 （这在很大程度上取决于您期望的值等。）

您的问题表明商始终应该是整数。在这种情况下，保持正确结果的正确方法是不使用任何doubles 开头（对于Ls、dx、Z）。要么使用小数类型（C++ 中没有内置，使用你自己的或库），任意精度的十进制类型（同样，使用像 gmp 这样的库 - 如果你知道你的所有数字都有一个终止的十进制表达式是明智的)，或者，最简单的方法：如果保证Ls 和dx 在小数点后最多有n 数字，则将两者乘以10^n 并使用整数类型。

---

好的，您的代码与我的预期大不相同。在这种情况下，在我看来，正确的做法是固定步数 N 并从中计算 dx，而不是反过来：

const int N = 10000;
double dx = (Ls-1.0)/(double)(N-1);

如果您想从 dx 的值开始并选择 N 以便计算出 dx 的值，请在程序启动时询问用户：

#include <cmath>

double dxestim;
cout << "dx should be close to: ";
cin >> dxestim;
cout << "Candidate values for N: " << endl;
int N1 = (int) floor((Ls-1)/dx + 1.0);
int N2 = (int) ceil((Ls-1)/dx + 1.0);
cout << N1 << " gives dx = " << (Ls-1.0)/(double)(N1-1) << endl;
cout << N2 << " gives dx = " << (Ls-1.0)/(double)(N2-1) << endl;
cout << "Please choose N: ";
cin >> N;
...

【讨论】：

((Ls-1)/dx + 1) 给出数组从端点 (Ls) 到初始点 (1) 的长度，其中 (dx) 是每个元素之间的间距。我选择 (dx) 使 ((Ls-1)/dx + 1) 始终是一个整数，但不幸的是，我必须将 (Ls) 和 (dx) 作为双精度数，因为它们在其他地方使用代码。或者我稍后使用显式类型转换升级它们会更好？

嗯。很难说没有看到大局，我不清楚他们是否应该是双打。根据您的描述，您如何选择dx 以使商为整数？在我看来，这需要知道整数应该是什么，所以你可以在那时保存它。

它是一个数学求解器，因此需要改变 dx 以使解稳定。我选择它的方式是 (Ls-1)/dx 总是一个整数。我事先确切知道 N 的值需要是什么，但我想自动完成，这样每次更改 dx 时我都不必手动输入它。如果能更好地说明问题，我可以上传整个代码。

@user1562781 好的，这与我的预期非常不同。请参阅我的编辑，了解我认为最简单的解决方法。

是的，您应该指定 N 并从中计算 dx，而不是相反。