डेल्फी में फ्लोट करने के लिए एक पूर्णांक को कैसे परिवर्तित करें?

Question

डेल्फी में फ्लोट करने के लिए एक पूर्णांक को कैसे परिवर्तित करें?

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

Answer 1

i * 1.0 इसे फ़्लोटिंग पॉइंट नंबर में परिवर्तित करना चाहिए। किसी भी प्रकार की फ़्लोटिंगपॉइंट संख्याओं को शामिल करने वाली किसी भी गणना को extendend में परिवर्तित कर दिया जाता है और फिर निहित रूप से वांछित परिणाम प्रकार में असाइनमेंट पर परिवर्तित किया जाता है। सी/सी ++ के विपरीत सभी गणना विस्तारित (80 बिट फ्लोट, x87 फ़्लोटिंगपॉइंट इकाई का आंतरिक प्रारूप) में होती है और बाद में परिवर्तित हो जाती है।

असली (i) भी काम कर सकता है।

Answer 2

आप कर सकते हैं:

myFloat := myInteger; 

Answer 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 

Answer 4

पूर्णांक

सिर्फ आवंटित

Float1 := Integer1; 

आपका प्रश्न, कुछ भी कास्ट करने के लिए की जरूरत नहीं है पूर्णांक

को फ्लोट जा लगते हैं

दो विकल्प

Integer1 := Trunc(Float1); //truncate 

या

Integer1 := Round(Float1); //Round 

Answer 5

मैं इस दो (मैं और अधिक है, लेकिन उदाहरण के लिए पर्याप्त होगा) 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; 

Typecast पूर्णांक में कैसे कर सकते हैं डबल पर ? मुझे '(1.0 * वैल्यू)' या '(0.0 + वैल्यू)' डालने से नफरत है जो कम CPU समय का उपयोग करता है, इसे करने के लिए कुछ और तरीका मौजूद होना चाहिए।

सावधानी: मेरा मतलब उस कॉल पर टाइपकास्ट है !!! सावधानी: कॉल एक अधिभारित फ़ंक्शन पर है, एक अन्य

आशा करता है कि किसी को रास्ता मिल जाए, 'MyFunc ((डबल) मान डालने का कारण' अमान्य टाइपकास्ट कहता है ... क्यों नरक पर एक पूर्णांक कास्टिंग एक डबल संभव नहीं है ???? एक डबल एक पूर्णांक स्टोर कर सकता है ... और भी, इसे असाइन करते समय इसे सीधे डाला जाता है ... '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 + मूल्य)' कास्ट करने के लिए ... जब तक मैंने पाया एक बेहतर समाधान मुझे डर है कि मैं का उपयोग करेगा होना चाहिए की कोई जरूरत नहीं है, जहां यह काम करना चाहिए (लेकिन नहीं) '(डबल) मान', whe मान प्रकार इंटीजर है।

तो मेरी प्रतिक्रिया है ...कोड डालने के बजाय '(डबल) 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 अधिभारित या असली एक या डबल एक? ... एक ही है, एक Real48 गुजर और यह भी गुजर एक रियल ...

संकलक सभी में कोई त्रुटि पाई पर लागू होता है ... लेकिन मैं नहीं जानता कि जो (केवल एक हैं) के नाम से जाना जाएगा ... अनुरेखण के बिना बेशक!!! क्या आप?

ऐसी स्थितियों के लिए 4.0+ है जहां स्पष्ट डाली काम करने के लिए बहुत अच्छा होगा ...

कृपया ध्यान दें मैं 1.0+, डाल 2.0+, 8.0+ ... 2 की शक्तियों ... इसलिए किसी भी राशि उनमें से किसी एक या उनमें से कुछ देखा जा सकता है ... अगर resoult 15 है ... उन सभी को चलाया गया था ... अगर 3 केवल 1.0 और 2.0, आदि ... बाइनरी मोड !!! बिट्स वेट इत्यादि की तरह ... यह दिखाने के लिए है कि एक कोड कितना जटिल हो सकता है ... सिर्फ इसलिए कि एक ओवरलोडेड फ़ंक्शन में अलग-अलग पैराम होनी चाहिए ...

यह अनुमति नहीं है, क्योंकि संकलक को पता नहीं है कि कौन सा एक कॉल करने के लिए:

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

:

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 ऐसे मामलों में यह ज्ञात किया जा सकता है कि किसको कॉल करना है .... समस्या यह है:

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

आशा इस मदद करता है!