Delphi如何将整数转换为浮点数？答案

【问题标题】：How to convert a integer to float in Delphi?Delphi如何将整数转换为浮点数？
【发布时间】：2010-10-14 14:43:10
【问题描述】：

如何在Delphi中将整数转换为浮点数？

例如 int_h:= int_var/1.5* int_var;

【问题讨论】：

不只是分配它工作吗？
是的分配应该可以工作，因为 int 可以隐式转换为浮点数。
“h”是浮点数吗？

【解决方案1】：

i*1.0 应将其转换为浮点数。任何涉及任何类型的浮点数的计算都会隐式转换为extendend，然后在赋值时隐式转换为所需的结果类型。与 C/C++ 相比，所有计算都在 Extended（80 位浮点数，x87 浮点单元的内部格式）中进行，并在稍后转换回来。

real(i) 也可以。

【讨论】：

我希望反过来。
我宁愿说 i + 0.0 而不是 i * 1.0，因为即使是 1 年级的人也可以加法，但我认为只有在 2 年级才能学会乘法。（开个玩笑——乘法比加法需要更多的 CPU 或 FPU 能力）

【解决方案2】：

整数到浮点数

不需要投射任何东西，只需分配

Float1 := Integer1;

您的问题似乎是浮点数到整数

两种选择

Integer1 := Trunc(Float1); //truncate

或

Integer1 := Round(Float1); //Round

【讨论】：

Trunc() 的反面实际上是 Ceil()。 Trunc() 将向零舍入，Ceil() 将向 +Infinity（如果是正数）或 -Infinity（如果为负数）四舍五入。
没有 Ceil 总是舍入为 +inf，Floor 总是舍入为 -inf，而 Trunc 总是舍入为 0。所以 Ceil() 的反面不是 Trunc，而是 Floor。

【解决方案3】：

3 种可能的方式，具体取决于您的表达方式。

var
  Float: Double;
  Int1: Integer;
  Int2: Integer;
begin
  Int1 := 925;
  Int2 := 21;
  Float := Int1; // simple form: assign it
  Writeln(Float);
  Float := Int2 / Int1; // floating point division: assign it
  Writeln(Float);
  Float := (1.0 * Int2) * Int1; // integer operator: multiply by 1.0 and add parenthesis
  Writeln(Float);
end.

输出：

 9.25000000000000E+0002
 2.27027027027027E-0002
 1.94250000000000E+0004

【讨论】：

先是+1，然后是-1；我喜欢这两个方面的动力：它可以帮助我写出更好的答案。

【解决方案4】：

你可以这样做：

myFloat := myInteger;

【讨论】：

该类型转换无效：E2089 类型转换无效。

【解决方案5】：

我有这两个（我有更多，但例如就足够了）重载函数：

interface
   function MyFunc(Value:Integer):Integer;overload;
   function MyFunc(Value:Double):Double;overload;
implementation
   function MyFunc(Value:Integer):Integer;
   begin
        MyFunc:=Math.Ceil( {Do some extra complicated Math calcs}
                          *
                           MyFunc( {¿How to Type Cast as Double?} Value )
                         );
   end; 
   function MyFunc(Value:Double):Double;
   begin
        MyFunc:={Do some Math calcs with Value};
   end;

如何将 Integer 类型转换为 Double？我讨厌使用占用更少 CPU 时间的“（1.0*Value）”或“（0.0+Value）”，必须存在其他方式来做到这一点。

注意：我的意思是那个电话的类型转换！！！注意：调用是在一个重载函数上，一个调用另一个

希望有人找到一种方法，因为把“MyFunc((Double)Value)”说成无效的类型转换......为什么在地狱将整数转换为双精度是不可能的？？？？ double 可以存储一个整数......还有更多，当直接分配它时......'MyVarOfTypeDouble:=MyvarOfTypeInteger;' 完美。

问题在于重载函数...它不知道我想调用 Double 版本一...这就是为什么需要强制转换...

换句话说...这就像一个魅力：

interface
   function MyFunc_Integer(Value:Integer):Integer;
   function MyFunc_Double(Value:Double):Double;
implementation
   function MyFunc_Integer(Value:Integer):Integer;
   begin
        MyFunc_Integer:=Math.Ceil( {Do some extra complicated Math calcs}
                                  *
                                   MyFunc_Double(Value)
                                  );
   end; 
   function MyFunc_Double(Value:Double):Double;
   begin
        MyFunc_Double:={Do some Math calcs with Value};
   end;

看，如果函数名称不同，则无需强制转换...直到我找到更好的解决方案，我必须害怕我会在应该工作的地方使用“（0.0 +值）”（但不能）“（ Double)value´，其中 Value 的类型为 Integer。

所以我的回答是...而不是输入代码“（Double）SomethingOfTypeInteger”（应该可以，但编译器不喜欢它）...输入其他代码“（0.0+SomethingOfTypeInteger）”，我不建议使用“(1.0*SomethingOfTypeInteger)”，因为它的效率要低得多......

永远不要考虑创建这样的函数（它也比 1.0*Value 最差）：

function ConvetIntegerToDouble(Value:Integer):Double;
begin
     ConvetIntegerToDouble:=Value;
end;

该功能非常符合...但比输入“0.0+值”要花费很多很多时间。

现在非常、非常……很多非常聪明的人……看到这个（非常丑陋的）代码：

    interface
       function MyFunc(Value:Integer):Integer;overload;
       function MyFunc(Value:Real48):Real48;overload;
       function MyFunc(Value:Real):Real;overload;
       function MyFunc(Value:Double):Double;overload;
       procedure CanYouGuess;
    implementation
    var
       MyVarOfTypeDouble:Double;
       function MyFunc(Value:Integer):Integer;
       begin
            MyFunc:=Round(MyFunc(1.0+Value));
       end;
       function MyFunc(Value:Real48):Real48;
       begin
            MyFunc:=MyFunc(2.0+Value);
       end;
       function MyFunc(Value:Real):Real;
       begin
            MyFunc:=MyFunc(4.0+Value);
       end;
       function MyFunc(Value:Double):Double;
       begin
            MyFunc:=(8.0+Value);
       end;
       procedure CanYouGuess;
       var
          MyVarOfTypeReal48:Real48;
          MyVarOfTypeReal:Real;
       begin
            MyVarOfTypeDouble:=MyFunc( 0 ); // What value will be on MyVarOfTypeDouble?
            MyVarOfTypeReal48:=0;
            MyVarOfTypeDouble:=MyFunc(MyVarOfTypeReal48); // What value will be on MyVarOfTypeDouble?
            MyVarOfTypeReal:=0;
            MyVarOfTypeDouble:=MyFunc(MyVarOfTypeReal); // What value will be on MyVarOfTypeDouble?
            MyVarOfTypeDouble:=MyFunc(0.0); // What value will be on MyVarOfTypeDouble?
       end;

现在尝试猜测值...阅读代码不清楚调用必须去...我传递一个整数，然后在 Integer 重载版本中...调用哪个... Real48 重载或 Real 一个或双一？ ...同样适用于传递 Real48 和传递 Real...

编译器根本没有发现任何错误...但我不知道会调用哪个（如果只有一个）...当然没有跟踪！！！可以吗？

在这种情况下，显式强制转换非常有用......

请注意我放了 1.0+、2.0+、4.0+、8.0+ ... 2 的幂...所以可以看到其中任何一个或一些的任何总和...如果结果是 15...所有其中已经运行...如果 3 只有 1.0 和 2.0 等...二进制模式！像位重量等......它只是为了展示代码如何变得过于复杂......只是因为重载的函数必须具有不同的参数......

这是不允许的，因为编译器不知道调用哪一个：

    interface
       function MyFunc(Value:Double):Integer;overload;
       function MyFunc(Value:Double):Real48;overload;
       function MyFunc(Value:Double):Real;overload;
       function MyFunc(Value:Double):Double;overload;

是的，编译器是一个非常愚蠢的......它只能在 MyFunc 用于分配的情况下编译......请参阅此代码：

MyVarOfTypeReal48:=MyFunc(1); // It can know return value must be Real48, so call that one... but compiler is not so Intelligent

在这种情况下，可以知道要调用哪一个....问题出在：

MyVarOfTypeInteger:=Round(5*MyFunc(1)+MyFunc(2)*1.3); // This is problematic, first one could be understod as Integer version, second one as ... as what? Real, Real48 or Double? not possible to know... that is why compiler does not like such overloaded (with same arguments).

希望这会有所帮助！

【讨论】：