फ्लोट मध्ये इंट रूपांतर कसे करावे


उत्तर 1:

प्रथम, जर फ्लोटचा अपूर्णांक नसलेला भाग इंट म्हणून दर्शविला गेला तर "शून्याच्या दिशेने गोल" (म्हणजे विभाजन थेंब) अस्तित्त्वात असलेले अंतर्भूत रूपांतरण:

इंट आर (फ्लोट एफ) { इंट परिणाम = फ;परतीचा निकाल; // आपण फक्त "रिटर्न एफ" लिहू शकता त्याऐवजी}

लक्षात घ्या की जर इन्ट परिणाम दर्शवू शकत नाही, तर "वर्तन अपरिभाषित आहे" (याचा अर्थ असा आहे की आपल्या प्रोग्रामला मानक संबंधित आहे म्हणून काहीही करण्यास परवानगी आहे).

आपल्याला पाहिजे असलेली ती फेरी नाही तर बर्‍याच प्रमाणित लायब्ररीची कार्ये घोषित केली आहेत हे युक्ती करू शकते. प्रथम सर्वात सोपी:

  • अनुक्रमे चांदी / मजला गोल वर किंवा खाली परिणाम अद्याप फ्लोट आहे, इंट मिळविण्यासाठी आपण वर वर्णन केलेले अंतर्निहित रूपांतरण वापरू शकता.
  • राउंडफ, जे सर्वात जवळच्या पूर्णांक मूल्यावर गोल करते, त्याशिवाय .5 केस शून्यापासून दूर आहे (म्हणून 1.5 एफ गोलाकार 2.0 एफ पर्यंत आहे, परंतु -3.5 एफ गोल -4.0 एफ पर्यंत आहे).
  • ग्राउंडफ आणि ललग्राऊंड, जे राऊंडफसारखेच असतात, परंतु अनुक्रमे एक लांब किंवा लांब लांबीचे परिणाम देतात. जर सैद्धांतिक निकाल निकाल प्रकाराद्वारे दर्शविला जाऊ शकत नाही तर वास्तविक परिणाम अनिर्दिष्ट आहे (म्हणजेच त्या प्रकाराचे "काहीही" असू शकते). एरनो एडीओएम किंवा एरेंजवर सेट केले जाऊ शकते.
  • ट्रंकफ, जो वरील वर्णन केलेल्या निहित रूपांतरणासारखेच आहे, परिणाम वगळता अद्याप एक फ्लोट नाही.

अतिरिक्त फेरी कार्ये आहेत (देखील यात) ) ज्यांचे गोल वागणूक फेसटाऊंड टू कॉलद्वारे स्थापित "चालू गोल दिशा" द्वारे निश्चित केली जाते (एक फंक्शन ज्यामध्ये घोषित केली जाते) , "फ्लोटिंग पॉइंट वातावरण" मधील विविध सेटींग्जसह व्यवहार करणारा एक शीर्षलेख). या फंक्शनचा युक्तिवाद एक मानक मॅक्रोस FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO किंवा FE_UPWARD पैकी एकाचे मूल्य असले पाहिजे, परंतु संबंधित राउंडिंग मोड अनुपलब्ध असल्यास त्यापैकी कोणतेही मॅक्रो अपरिभाषित केले जाऊ शकतात. आपण फेज ग्राउंड () सह वर्तमान राउंडिंग मोड पुनर्प्राप्त करू शकता. ती विचारात घेणारी कार्येः

  • पासंटिंटफ आणि रिंटफ, जे गोलाकाराप्रमाणे असतात. case केस सध्याच्या राउंडिंग दिशानिर्देशानुसार (आणि रंटफ एक "अपुरा" परिणाम दर्शविणारा फ्लोटिंग पॉईंट अपवाद वाढवू शकतो).
  • लिंट्राफ आणि लिलिंटफ जे जवळपासच्या सारख्याच असतात परंतु अनुक्रमे दीर्घ किंवा लांब लांब परिणाम देतात. जर सैद्धांतिक निकाल निकाल प्रकाराद्वारे दर्शविला जाऊ शकत नाही तर वास्तविक परिणाम अनिर्दिष्ट आहे (म्हणजेच त्या प्रकाराचे "काहीही" असू शकते). एरनो एडीओएम किंवा एरेंजवर सेट केले जाऊ शकते.

उत्तर 2:

सर्वात सोपा मार्ग म्हणजे इंट x = (इंट) (एफ + 0.5); हे बहुतेक वेळेस सकारात्मक संख्येसाठी कार्य करते. नकारात्मक संख्येसाठी आपण 0.5 वजा करू शकता. किंवा

परिपूर्ण मूल्य कार्य आणि एक गोल फंक्शन परिभाषित करा:

# परिभाषित एबीएस (एक्स) ((एक्स> = ०)? एक्स: - (एक्स))# डेफ राउंड (एक्स) (एक्स> = 0)? (इंट) (एक्स + ०.)): (इंट) - (एबीएस (एक्स) + ०..5)इंट x = राउंड (फ);

अल्गोरिदम

गणिताचे गोल करण्याचा अल्गोरिदम मार्ग खालीलप्रमाणे आहे: 1. किती दशांश स्थाने घ्यावीत हे ठरवा (एन) 2. संख्या 10 ^ {- n by ने विभाजित करा. (एम) nearest. जवळचा संपूर्ण क्रमांक निकाल घ्या. (गोल फ्लोट 1 च्या जागी). (प्रश्न) m. गोलाकार क्रमांक मिळविण्यासाठी एम * क्यूचे गुणाकार करा. (झेड) inte. पूर्णांकात रूपांतरित करा: जर भागांचा भाग> ०. 0.5 असेल तर विभागीय भाग छाटून १ जोडा. अन्यथा भागांचा भाग कापून घ्या.

हे का करतात? कारण सी साठी डीफॉल्ट म्हणजे विभागीय भागाचे गोल भाग करणे, ते जवळ जवळ कितीही फरक पडत नाही. म्हणून महत्त्वाचे अंक विचारात घेण्यासाठी आपणास त्या संख्येस लहान प्रमाणात विभाजित करावे लागेल. दरम्यानच्या निकालाचे गोल करून आपण गोल त्रुटींची काळजी घ्याल.

साधारणपणे: सकारात्मक संख्या: जर दशांश (दहावा स्थान) च्या उजवीकडील संख्या> = = 5 पुढील उच्च अंकांपर्यंत गोल असेल तर अन्यथा छाटली जाईल. negativeण संख्या: दशांश च्या उजवीकडे (दहावा स्थान) संख्या <= 5 लहान असल्यास अन्यथा पुढील नकारात्मक अंकांपर्यंत पूर्णांक संख्‍या. हे अगदी .5 सकारात्मक किंवा नकारात्मक च्या धारदार केसांची काळजी घेते.

/ * उदाहरणे, चांगली आणि वाईट * /इंट एक्स;फ्लोट एफ, एम, एन, पी, झेड; // चांगले एफ = -13.486;n = .01; // दोन जागामी = एफ / एन; // मी = -1348.6मी = सीलिफ (मी); // मी = -1348.0z = मी / एन; // झेड = -13.48x = (इंट) z; // एक्स = -13// चांगलेf = 0.501; n = 0.1; // एक ठिकाणमी = एफ / एन; // मी = 5.01मी = सीलिफ (मी); // मी = 6.0z = मी / एन; // झेड = .6x = (इंट) z; // x = 1// वाईट एफ = 13.486;एन = सीलिफ (फ); // एन = 14.000// वाईटएफ = -13.486;एन = फ्लोरफ (एफ); // एन = -14.000// विसंगतीमुळे खराबf = 0.50; एन = सीलिफ (फ); // एन = 1.0एन = फ्लोरफ (एफ); // एन = 0.0f = -0.50; एन = सीलिफ (फ); // एन = 0.0एन = फ्लोरफ (एफ); // एन = -1.0// अद्याप काही चांगले नाही f = 0.50;n = 0.1; // 1 स्थानमी = एफ / एन; // मी = 5.0मी = सेलिफ (मी); // मी = 5.0z = मी / एन; // झेड = 0.5x = (इंट) z; // x = 0 इतके चांगले नाही// राउंड ट्राय करा f = 0.5;मी = राउंडफ (एफ); // मी = 1.0पी = राउंडफ (-फ) // मी = -1.0f = -0.5;मी = राउंडफ (एफ); // मी = -1.0पी = राउंडफ (-फ) // मी = 1.0

उत्तर 3:

प्रकार कास्टिंगचा वापर करून आपण हे करू शकता. वाक्यरचना म्हणजे-

उदाहरणः

फ्लोट एक्स;

x = 3.14;

इंट y;

y = (इंट) x;

printf (“% d”, y);

आउटपुटः

3

खरोखर काय झाले? मी एक प्रसिद्ध उपमा घेऊन ते स्पष्ट करीन.

पूर्णपणे पाण्याने भरलेल्या बादलीचा विचार करा. समजा आपल्याकडे एक घोकंपट्टी आहे. बादलीमधून तुम्ही घेऊ शकता जास्तीत जास्त पाणी किती आहे? उत्तर- एक घोकंपट्टी

येथे बादली फ्लोट (4 बाइट) आहे, आणि घोकंपट्टी (2 बाइट) आहे. टाइप कास्टिंग ही भरण्याची प्रक्रिया आहे आणि असे करताना पाणी (डेटा) गमावला आहे.

आशा आहे की हे मदत करते;)


उत्तर 4:

कोणतीही फ्लोट नंबर पूर्णांकात रूपांतरित केली जाऊ शकत नाही. परंतु पूर्णांक त्याचे स्वरूप वापरुन फ्लोटमध्ये रूपांतरित केले जाऊ शकते

स्पेसिफायर.ए.एस.

खाली दिलेल्या उदाहरणात दाखवले की फ्लोट पूर्णांक प्रकारात बदलता येते. नंतर मूल्य पूर्णांक व्हेरिएबलमध्ये जाते नंतर ते फ्लोट व्हॅल्यूमध्ये रूपांतरित होते.

# समाविष्ट करा

शून्य संख्या (इंट ई)

{

printf ("% d", e);

}

मुख्य मुख्य ()

{

फ्लोट सी = 9.0000;

संख्या (सी);

}

वरील उदाहरणामध्ये आपण फ्लोट व्हॅल्यू पूर्णांक व्हेरिएबलला दिले आहे. वरील प्रोग्रामचे आउटपुट 9 होईल.


उत्तर 5:

फेरीसाठी अनेक पध्दती आहेत. या लायब्ररीची कार्ये पहा, जी सी 99 पासून उपलब्ध आहेतः

  • अर्धवेळ प्रकरणे शून्यापासून दूर केल्याने राउंडफ, जो वितरणास सर्वात जवळील अविभाज्य मूल्य असल्याचे फ्लोट परत करतो.
  • फ्लोरफ, जो खाली गोल करते, सर्वात मोठा अविभाज्य मूल्य मिळविते जे वितर्कापेक्षा मोठे नाही.
  • वाटाघाटीपेक्षा कमी न होणारे सर्वात लहान अविभाज्य मूल्य परत करणारी सीलिफ.
  • फेजग्राउंडद्वारे निर्दिष्ट गोल फेरी (जी सध्याच्या फ्लोटिंग पॉइंट वातावरणात निर्दिष्ट केल्यानुसार गोल दिशानिर्देश मोड दर्शविणारे मूल्य परत करते) वापरून एक अविभाज्य मूल्यासाठी गोल करते.

यापैकी प्रत्येक फंक्शनला एक फ्लोट वितर्क प्राप्त होईल आणि फ्लोट निकाल मिळेल, जो आपण नंतर अंतर्ज्ञानाने टाकू शकता.


उत्तर 6:

गणितातील राऊंड () फंक्शन कार्य करेल. खालील संकलित करणे आणि कार्य करणे आवश्यक आहे (जरी मी प्रत्यक्षात ते संकलित केले नाही):

# समाविष्ट करा / * गणित पासून गोल () साठी प्रोटोटाइप आयात करा * दुहेरी फेरी (दुहेरी); * /# समाविष्ट करा इंट मेन () { फ्लोट मी = 5.4, जे = 5.6; / * पुढीलपैकी प्रत्येकजण फ्लोटला दुप्पट बनवितो * पॅरामीटरसाठी आणि नंतर डबल निकाल सुरक्षितपणे मिळू शकेल* अचूकतेशिवाय नुकसान नक्कीच, आपण * कदाचित इंट च्या ऐवजी लांब वापरायचे असेल पण ते अवलंबून असेल * आपल्या अपेक्षित श्रेणीवर * /इंट ii = (इंट) फेरी (i); / * हॉरिड चल नावे परंतु ते फक्त एक उदाहरण आहे. * / इंट जेजे = (इंट) गोल (जे);/ * आता व्हॅल्यूज प्रिंट करा. * / printf ("% f ची फेरी% f आहे जी% d \ n देखील आहे", i, राउंड (i), ii); printf ("% f ची फेरी% f आहे जी% d \ n देखील आहे", j, राउंड (j), jj); रिटर्न 0;}

उदाहरण यातून सुधारित केले आहे:

सी - गोल () फंक्शन

.


उत्तर 7:

फ्लोट नंबरला पूर्णांक संख्येमध्ये रूपांतरित करण्यासाठी, आपल्याला टाइप कास्टिंग (टाईपकास्टिंग, किंवा रूपांतरण टाइप करणे ही एक डेटा प्रकारातून दुसर्‍या घटकामध्ये बदलण्याची पद्धत आहे) वापरावी लागेल.

# समाविष्ट करा शून्य मुख्य () { फ्लोट वर 1 = 3.141592653589793238; इंट व्हर् 2;var2 = (पूर्ण) var1; // टाइपकास्टिंग (फ्लोट पूर्णांकात रूपांतरित करत आहे) printf ("पूर्णांक मूल्य:% d", var2);}

आउटपुट


उत्तर 8:

उत्तर: (अंतः)

फ्लोट पूर्णांकात रूपांतरित करण्यासाठी आपण फक्त कास्ट (इंट) वापरू शकता.

हे आवडले

your_variable = (int) your_variable

हे (इंट) काय कार्य करते?

हे कंपाईलरला सांगते की आपण मालोकद्वारे मिळविलेले मूल्य पूर्णांकातील पॉईंटर म्हणून मानू इच्छितो.


उत्तर 9:
फ्लोट ए = 2.33;इंट बी = (इंट) अ;प्रिंटएफ ("% d", बी);

आउटपुट असेल: 2


उत्तर 10:

स्वयंचलित प्रकार कास्टिंग घडते तेव्हा,

  • दोन प्रकार सुसंगत आहेत
  • लक्ष्य प्रकार स्त्रोत प्रकारापेक्षा मोठा आहे

उदाहरणः

सार्वजनिक वर्ग चाचणी{ सार्वजनिक स्टॅटिक शून्य मुख्य (स्ट्रिंग [] आर्क) { इंट i = 100; लांब l = i; // कोणतेही स्पष्ट प्रकार कास्टिंग आवश्यक नाहीफ्लोट एफ = एल; // कोणतेही स्पष्ट प्रकार कास्टिंग आवश्यक नाही सिस्टम.आउट.प्रिंटलन ("इंट व्हॅल्यू" + आय); सिस्टम.आउट.प्रिंटलन ("दीर्घ मूल्य" + एल); सिस्टम.आउट.प्रिंटलन ("फ्लोट व्हॅल्यू" + एफ); } }

आउटपुटः

इंट मूल्य 100दीर्घ मूल्य 100फ्लोट मूल्य 100.0

उत्तर 11:

बरं, तुम्ही फ्लोट व्हॅल्यू पूर्णांकीत रुपांतरित करण्यासाठी 2 फंक्शन्स, “फ्लोर ()” आणि “सील ()” वापरू शकता. उदाहरणः

फ्लोट ए = 3.5;

इंट बी = फ्लोर (अ); // हे “b” ते 3 सेट करेल

इंट बी = सील (अ); // हे “b” ते 4 सेट करेल