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

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

---

例如int_h:=int_var/1.5*int_var

i*1.0应将其转换为浮点数。任何涉及任何类型的浮点数的计算都会隐式转换为

extendend

，然后在赋值时隐式转换为所需的结果类型。与C/C++不同的是，所有计算都以扩展（80位浮点，x87浮点单元的内部格式）进行，并在稍后转换回

real（i）可能也会起作用。

您可以：

myFloat := myInteger;

---

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

浮点数

不需要施放任何东西，只需分配

Float1 := Integer1;

你的问题似乎是浮点数

两种选择

Integer1 := Trunc(Float1); //truncate 

或

我有两个（我有更多，但举个例子就足够了）已加载的函数：

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; 

如何将in-Typecast整数转换为Double？ 我讨厌使用更少CPU时间的´（1.0*Value）´或´（0.0+Value）´，必须存在其他方法来实现

当心：我是说在那个电话里打字！！！ 注意：调用的是重载函数，一个调用另一个

希望有人能找到一种方法，因为输入'MyFunc（（双）值）'）表示类型转换无效。。。到底为什么不可能将整数转换为双精度？？？？一个double可以存储一个整数。。。此外，当分配它时，直接将其转换为。。。`MyVarOfTypeDouble:=MyvarOfTypeInteger；你的工作很完美

这个问题来自于重载函数。。。它不知道我想打电话到双版本一。。。这就是为什么需要演员阵容

换句话说。。。这将像一个魅力：

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+Value）´（但不使用）´（Double）Value´，因为Value是Integer类型的

所以我的回答是。。。而不是将代码´（Double）放入某个thingoftypeinteger´（这应该可以工作，但编译器不喜欢）。。。把这另一个代码´（0.0+SomethingOfTypeInteger）´，我建议不要使用´（1.0*SomethingOfTypeInteger）´，因为它的效率要低得多

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

这个功能非常好。。。但是，要比投入“0.0+价值”要花很多很多时间

现在非常非常。。。很多非常聪明的人。。。请参见以下（非常难看的）代码：

现在尝试猜测值。。。正在阅读代码不清楚必须调用什么。。。我传递一个整数，然后在整数内加载版本。。。哪一个叫。。。是真的还是真的还是双倍的。。。同样的道理也适用于通过Real48和Real48

编译器没有发现任何错误。。。但我不知道哪一个（如果只有一个）将被称为。。。当然没有追踪！！！你能吗

在这种情况下，显式cast非常适合工作

请注意我把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).

---

希望这有帮助

我想反过来说，我宁愿说I+0.0而不是I*1.0，因为即使是一年级的学生也可以加，但我认为只有在二年级你才能学会乘法。（只是开玩笑-乘法比加法需要更多的CPU或FPU能力）不仅仅是赋值有效吗？是的，赋值应该有效，因为int可以隐式转换为floatingpoint。“h”类型化为float吗？typecast无效：E2089无效的typecast。Trunc（）的反面实际上是Ceil（）。Trunc（）将向零舍入，Ceil（）将向+无穷大（如果是正数）或-无穷大（如果是负数）舍入。没有Ceil将始终向+inf舍入，Floor将始终向-inf舍入，Trunc始终向0舍入。所以Ceil（）的反面不是Trunc，而是Floor；我喜欢两者的动力：它能帮助我写出更好的答案。

    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;

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).