Come convertire un intero in float in Delphi?

Question

Come convertire un numero intero in float in Delphi?

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

Answer 1

i * 1.0 deve convertirlo in un numero in virgola mobile. Qualsiasi calcolo che coinvolga numeri in virgola mobile di qualsiasi tipo viene convertito implicitamente in extendend e convertito implicitamente nel tipo di risultato desiderato all'assegnazione. A differenza di C/C++, tutti i calcoli si verificano in Extended (80 bit float, il formato interno dell'unità xxx in virgola mobile) e vengono convertiti più tardi.

reale (i) potrebbe funzionare anche.

Answer 2

si può fare:

myFloat := myInteger; 

Answer 3

3 modi possibili, a seconda del tipo di espressioni che avete.

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. 

uscita:

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

Answer 4

Integer galleggiare

Non v'è bisogno di lanciare qualsiasi cosa, basta assegnare

Float1 := Integer1; 

La tua domanda sembra essere galleggiante in numero intero

Due opzioni

Integer1 := Trunc(Float1); //truncate 

o

Integer1 := Round(Float1); //Round 

Answer 5

ho questo due (ho più, ma per esempio potrebbe essere sufficiente) oveloaded funzioni:

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; 

Come può in Typecast Integer Onto doppio ? Detesto mettere '(1.0 * Value)' o '(0.0 + Value)' che utilizza meno tempo di CPU, deve esistere un altro modo per farlo.

ATTENZIONE: intendo typecast su quella chiamata !!! ATTENZIONE: la chiamata è in una funzione sovraccaricata, una chiama l'altra

Spero che qualcuno trovi un modo, perché inserire "MioFunc ((Doppio) Valore)" dice typecast non valido ... perché diavolo lanciare un numero intero a un doppio non è possibile ???? un doppio può memorizzare un intero ... inoltre, quando lo si assegna, lo cast direttamente ... 'MyVarOfTypeDouble: = MyvarOfTypeInteger;' funziona perfettamente.

Il problema è dotato di funzioni di overload ... non sai che io voglio chiamare per doppia versione uno ... è per questo che è necessario un cast ...

In altre parole ... questa volontà lavorare come un fascino:

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; 

Sede, se le funzioni nomi sono diversi, non c'è bisogno di lanciare ... finché non ho trovato una soluzione migliore che deve essere paura che userò '(0.0 + Value)' dove dovrebbe funzionare (ma non lo fa) '(Double) value', whe Value è di tipo Integer.

Quindi la mia risposta è ...invece di inserire il codice '(Double) SomethingOfTypeInteger' (che dovrebbe funzionare, ma il compilatore non gli piace) ... metti questo altro codice' (0.0 + SomethingOfTypeInteger) ', io raccomando di non usare' (1.0 * SomethingOfTypeInteger) 'poiché è molto meno efficiente ...

mai e poi mai pensare alla creazione di una funzione come questo (che è anche peggiore di 1,0 * Valore):

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

tale funzione è conforme grande ... ma prende un sacco , molto più tempo di mettere '0.0 + valore'.

Ora per molto, molto ... un sacco di persone molto intelligenti ... vedi questo codice (molto brutta):

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; 

Ora provate ad indovinare i valori ... la lettura del codice non è chiaro che cosa le chiamate devono andare ... passo un intero, poi dentro la versione del caricamento intero di Integer ... quale si chiama ... Real48 sovraccaricato o Real one o Double one? ... lo stesso vale per passare un Real48 e anche passare un Real ...

Il compilatore non ha rilevato alcun errore ... ma non so quale (se solo uno) sarà chiamato ... senza tracciamento, ovviamente!!! Puoi?

Per tali situazioni è dove cast esplicito sarebbe bello lavorare ...

Si prega di notare ho messo 1.0+, 2.0+, 4.0+, 8.0+ ... potenze di 2 ... in modo che qualsiasi somma di alcuni o di alcuni di essi può essere visto ... se resoult è 15 ... tutti sono stati eseguiti ... se 3 solo 1.0 e 2.0, ecc ... modalità binaria !!! come peso di bit, ecc ... è solo per mostrare come un codice può diventare troppo complicato ... solo perché una funzione sovraccaricata deve avere parametri diversi ...

Questo non è consentito, poiché il compilatore non sa quale uno a chiamare:

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; 

Sì, compilatore è piuttosto stupido ... può essere compilato solo nei casi in cui MyFunc viene utilizzato su un assigment .... se questo codice:

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

In questi casi si può sapere quale chiamare .... il problema è con:

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

Spero che questo aiuti!