Comment faire pour convertir un nombre entier pour flotter dans Delphi?

Question

Comment faire pour convertir un nombre entier pour flotter dans Delphi?

E.g int_h: = int_var/1.5 * int_var;

Answer 1

i * 1.0 devrait le convertir en un nombre à virgule flottante. Tout calcul impliquant des nombres à virgule flottante de tout type est implicitement converti en extendend, puis converti implicitement en le type de résultat souhaité lors de l'affectation. Contrairement à C/C++, tous les calculs se déroulent en Extended (80 bits float, le format interne de l'unité à virgule flottante x87) et sont reconvertis plus tard.

réel (i) pourrait aussi fonctionner.

Answer 2

Vous pouvez faire:

myFloat := myInteger; 

Answer 3

3 façons possibles, en fonction du type d'expressions que vous avez.

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. 

Sortie:

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

Answer 4

Entier FLOTTER

Il n'y a pas besoin de jeter quoi que ce soit, juste assigner

Float1 := Integer1; 

Votre question semble être Float Integer

Deux options

Integer1 := Trunc(Float1); //truncate 

ou

Integer1 := Round(Float1); //Round 

Answer 5

Je ces deux (j'ai plus, mais serait par exemple assez) fonctions 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; 

Comment en Typecast Entier sur une double ? Je déteste mettre '(1.0 * Value)' ou '(0.0 + Value)' qui utilise moins de temps CPU, doit exister d'une autre façon de le faire.

ATTENTION: je veux dire catégorisé sur cet appel !!! ATTENTION: l'appel est sur une fonction surchargée, on appelle l'autre

Espérons que quelqu'un trouve un moyen, car mettre'MonFunc ((Double) Valeur) 'dit invalide typecast ... pourquoi sur l'enfer de lancer un entier à un double n'est pas possible ???? un double peut stocker un nombre entier ... aussi plus, quand l'assignation le jette directement ...'MyVarOfTypeDouble: = MyvarOfTypeInteger; 'fonctionne parfaitement.

Le problème est livré avec les fonctions surchargées ... il ne sait pas que je veux appeler à la version Double un ... c'est pourquoi un casting est nécessaire ...

En d'autres termes ... cette volonté travailler comme un charme:

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; 

Voir, si les noms de fonctions sont différentes, pas besoin de jeter ... jusqu'à ce que je trouve une meilleure solution i doit avoir peur que je vais utiliser '(0.0 + valeur)' où elle devrait fonctionner (mais pas) '(Double) value', whe Value est de type Integer.

Donc, ma réponse est ...au lieu de mettre du code '(Double) SomethingOfTypeInteger' (cela devrait fonctionner mais complier ne l'aime pas) ... mettre cet autre code' (0.0 + SomethingOfTypeInteger) ', je recommande de ne pas utiliser' (1.0 * SomethingOfTypeInteger) ' est beaucoup moins efficace ...

ne jamais penser à la création d'une fonction comme celle-ci (il est aussi pire que 1,0 * Valeur):

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

cette fonction est conforme grande ... mais prend beaucoup , beaucoup plus de temps que de mettre '0.0 + valeur '.

maintenant à très, très ... beaucoup des gens très intelligents ... voir ce (très laid) Code:

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; 

Maintenant, essayez de deviner les valeurs ... la lecture de code on ne sait pas ce que les appels doivent partir ... je passe un nombre entier, puis à l'intérieur de la version d'oveload d'Integer ... laquelle s'appelle ... Real48 surchargé ou Real one ou Double one? ... il en va de même pour passer un Real48 et aussi passer un Real ...

Le compilateur n'a trouvé aucune erreur ... mais je ne sais pas lequel (si un seul) sera appelé ... sans suivi, bien sûr!!! peut tu?

Pour de telles situations est où serait transtypage explicite génial de travailler ...

S'il vous plaît noter que je mets 1.0+, 2.0+, 4.0+, 8.0+ ... puissances de 2 ... de sorte que toute somme de tout ou partie d'entre eux peuvent être vus ... si resoult est 15 ... tous d'entre eux ont été courus ... si 3 seulement 1.0 et 2.0, etc ... mode binaire !!! comme le poids des bits, etc ... c'est juste pour montrer comment un code peut devenir trop compliqué ... juste parce qu'une fonction surchargée doit avoir des paramètres différents ...

Ceci n'est pas autorisé, puisque le compilateur ne sait pas lequel à appeler:

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; 

Oui, le compilateur est assez stupide ... il peut être établi que dans les cas où MyFunc est utilisé sur un assigment .... se ce code:

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

Dans de tels cas, on peut savoir lequel appeler ... le problème est avec:

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

Espérons que cela aide!