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

i*1.0应将其转换为浮点数。任何涉及任何类型的浮点数的计算都将隐式转换为 extendend 然后在赋值时隐式转换为所需的结果类型。与C/C++相比,所有计算都在扩展的(80位浮点,X87浮点单元的内部格式)中进行,并在以后进行转换。

真的(我)也可能工作。

整数到浮点

不需要强制转换任何内容,只需分配

Float1 := Integer1;

你的问题似乎是浮点数

两个选择

Integer1 := Trunc(Float1); //truncate 

或

Integer1 := Round(Float1); //Round

你可以做到:

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

我有这两个(我有更多,但例如足够多)oveloaded函数:

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; 

如何才能在类型中将整数转换为double? 我不喜欢把(1.0*值)或(0.0+值)放在CPU时间较短的地方,必须有其他的方法来完成。

当心:我的意思是打那个电话!!!! 注意:调用是在重载函数上进行的,一个调用另一个

希望有人能找到方法,因为输入myfunc(double)值表示无效的类型转换…为什么不可能把一个整数强制转换成一个双精度数呢????一个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+值)(双精度)值,当值是integer类型时。

所以我的回答是…而不是将代码(double)放在somethingoftypeinteger(应该可以,但编译器不喜欢)中…把这另一个代码(0.0+somethingoftypeinteger),我建议不要使用(1.0*somethingoftypeinteger),因为它的效率要低得多…

从未想过要创建这样的函数(它也比1.0*值差):

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;

现在试着猜测价值…正在读取代码,不清楚必须执行哪些调用…我传递一个整数,然后在整数oveload版本中…哪个叫…real48过载还是real one或double one?…同样适用于传递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用于分配的情况下编译。SE代码:

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

希望这有帮助!