टाइप कन्वर्शन: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 10: Line 10:
[[कंप्यूटर विज्ञान]] में, प्रकार रूपांतरण,<ref name=":0" /><ref name=":3" /> कास्टिंग टाइप करें,<ref name=":0" /><ref name=":1" /> जबरदस्ती टाइप करें,<ref name=":1" />और बाजीगरी टाइप करें<ref name=":4" /><ref name=":5" /> एक [[अभिव्यक्ति (कंप्यूटर विज्ञान)]] को एक [[डेटा प्रकार]] से दूसरे में बदलने के विभिन्न तरीके हैं। एक उदाहरण एक [[पूर्णांक (कंप्यूटर विज्ञान)]] मान का एक [[तैरनेवाला स्थल]] मान या इसके टेक्स्टुअल प्रतिनिधित्व को एक [[स्ट्रिंग (कंप्यूटर विज्ञान)]] के रूप में परिवर्तित करना होगा, और इसके विपरीत। प्रकार के रूपांतरण प्रकार के पदानुक्रम या [[डेटा प्रतिनिधित्व]] की कुछ विशेषताओं का लाभ उठा सकते हैं। एक प्रकार के रूपांतरण के दो महत्वपूर्ण पहलू हैं कि क्या यह परोक्ष रूप से (स्वचालित रूप से) या स्पष्ट रूप से होता है,<ref name=":0" /><ref name=":2" /> और क्या अंतर्निहित डेटा प्रतिनिधित्व को एक प्रतिनिधित्व से दूसरे में परिवर्तित किया जाता है, या किसी दिए गए प्रतिनिधित्व को केवल अन्य डेटा प्रकार के प्रतिनिधित्व के रूप में पुनर्व्याख्या किया जाता है।<ref name=":2" /><ref name=":6" /> सामान्य तौर पर, [[आदिम डेटा प्रकार]] और [[यौगिक डेटा प्रकार]] दोनों को परिवर्तित किया जा सकता है।
[[कंप्यूटर विज्ञान]] में, प्रकार रूपांतरण,<ref name=":0" /><ref name=":3" /> कास्टिंग टाइप करें,<ref name=":0" /><ref name=":1" /> जबरदस्ती टाइप करें,<ref name=":1" />और बाजीगरी टाइप करें<ref name=":4" /><ref name=":5" /> एक [[अभिव्यक्ति (कंप्यूटर विज्ञान)]] को एक [[डेटा प्रकार]] से दूसरे में बदलने के विभिन्न तरीके हैं। एक उदाहरण एक [[पूर्णांक (कंप्यूटर विज्ञान)]] मान का एक [[तैरनेवाला स्थल]] मान या इसके टेक्स्टुअल प्रतिनिधित्व को एक [[स्ट्रिंग (कंप्यूटर विज्ञान)]] के रूप में परिवर्तित करना होगा, और इसके विपरीत। प्रकार के रूपांतरण प्रकार के पदानुक्रम या [[डेटा प्रतिनिधित्व]] की कुछ विशेषताओं का लाभ उठा सकते हैं। एक प्रकार के रूपांतरण के दो महत्वपूर्ण पहलू हैं कि क्या यह परोक्ष रूप से (स्वचालित रूप से) या स्पष्ट रूप से होता है,<ref name=":0" /><ref name=":2" /> और क्या अंतर्निहित डेटा प्रतिनिधित्व को एक प्रतिनिधित्व से दूसरे में परिवर्तित किया जाता है, या किसी दिए गए प्रतिनिधित्व को केवल अन्य डेटा प्रकार के प्रतिनिधित्व के रूप में पुनर्व्याख्या किया जाता है।<ref name=":2" /><ref name=":6" /> सामान्य तौर पर, [[आदिम डेटा प्रकार]] और [[यौगिक डेटा प्रकार]] दोनों को परिवर्तित किया जा सकता है।


प्रत्येक [[प्रोग्रामिंग भाषा]] के अपने नियम होते हैं कि कैसे प्रकारों को परिवर्तित किया जा सकता है। [[मजबूत टाइपिंग]] वाली भाषाएं सामान्यतः बहुत कम अंतर्निहित रूपांतरण करती हैं और अभ्यावेदन की पुनर्व्याख्या को हतोत्साहित करती हैं, जबकि [[कमजोर टाइपिंग]] वाली भाषाएं डेटा प्रकारों के बीच कई अंतर्निहित रूपांतरण करती हैं। कमजोर टाइपिंग लैंग्वेज अक्सर [[संकलक]] को अलग-अलग प्रतिनिधित्व वाले डेटा आइटम की मनमाने ढंग से व्याख्या करने के लिए मजबूर करती है - यह एक गैर-स्पष्ट प्रोग्रामिंग त्रुटि हो सकती है, या अंतर्निहित हार्डवेयर से सीधे निपटने के लिए एक तकनीकी विधि हो सकती है।
प्रत्येक [[प्रोग्रामिंग भाषा]] के अपने नियम होते हैं कि कैसे प्रकारों को परिवर्तित किया जा सकता है। [[मजबूत टाइपिंग]] वाली भाषाएं सामान्यतः बहुत कम अंतर्निहित रूपांतरण करती हैं और अभ्यावेदन की पुनर्व्याख्या को हतोत्साहित करती हैं, जबकि [[कमजोर टाइपिंग]] वाली भाषाएं डेटा प्रकारों के बीच कई अंतर्निहित रूपांतरण करती हैं। कमजोर टाइपिंग लैंग्वेज अक्सर [[संकलक]] को अलग-अलग प्रतिनिधित्व वाले डेटा आइटम की मनमाने ढंग से व्याख्या करने के लिए मजबूर करती है - यह एक गैर-स्पष्ट प्रोग्रामिंग गलती हो सकती है, या अंतर्निहित हार्डवेयर से सीधे निपटने के लिए एक तकनीकी विधि हो सकती है।


प्रत्येक [[प्रोग्रामिंग भाषा]] के अपने नियम होते हैं कि कैसे प्रकारों को परिवर्तित किया जा सकता है। [[मजबूत टाइपिंग]] वाली भाषाएं आमतौर पर बहुत कम निहित रूपांतरण करती हैं और अभ्यावेदन की पुनर्व्याख्या को हतोत्साहित करती हैं, जबकि [[कमजोर टाइपिंग]] वाली भाषाएं डेटा प्रकारों के बीच कई अंतर्निहित रूपांतरण करती हैं। कमजोर टाइपिंग लैंग्वेज अक्सर [[संकलक]] को अलग-अलग प्रतिनिधित्व वाले डेटा आइटम की मनमाने ढंग से व्याख्या करने के लिए मजबूर करती है - यह एक गैर-स्पष्ट प्रोग्रामिंग त्रुटि हो सकती है, या अंतर्निहित हार्डवेयर से सीधे निपटने के लिए एक तकनीकी विधि हो सकती है।
प्रत्येक [[प्रोग्रामिंग भाषा]] के अपने नियम होते हैं कि कैसे प्रकारों को परिवर्तित किया जा सकता है। [[मजबूत टाइपिंग]] वाली भाषाएं आमतौर पर बहुत कम निहित रूपांतरण करती हैं और अभ्यावेदन की पुनर्व्याख्या को हतोत्साहित करती हैं, जबकि [[कमजोर टाइपिंग]] वाली भाषाएं डेटा प्रकारों के बीच कई अंतर्निहित रूपांतरण करती हैं। कमजोर टाइपिंग लैंग्वेज अक्सर [[संकलक]] को अलग-अलग प्रतिनिधित्व वाले डेटा आइटम की मनमाने ढंग से व्याख्या करने के लिए मजबूर करती है - यह एक गैर-स्पष्ट प्रोग्रामिंग त्रुटि हो सकती है, या अंतर्निहित हार्डवेयर से सीधे निपटने के लिए एक तकनीकी विधि हो सकती है।

Revision as of 15:48, 20 February 2023

For the aviation licensing process, see Type conversion (aviation).
For metal casting, see Casting (metalworking) § Upcasting.

कंप्यूटर विज्ञान में, प्रकार रूपांतरण,[1][2] टाइप कास्टिंग,[1][3] टाइप ज़बरदस्ती,[3]और टाइप बाजीगरी,[4][5] एक अभिव्यक्ति (कंप्यूटर विज्ञान) को एक डेटा प्रकार से दूसरे में बदलने के विभिन्न तरीके हैं। एक उदाहरण एक पूर्णांक (कंप्यूटर विज्ञान) मान का एक तैरनेवाला स्थल फ़्लोटिंग पॉइंट मान में रूपांतरण या स्ट्रिंग (कंप्यूटर विज्ञान) के रूप में इसका शाब्दिक प्रतिनिधित्व होगा, और इसके विपरीत।, प्रकार के रूपांतरण प्रकार पदानुक्रम या डेटा प्रतिनिधित्वअभ्यावेदन की कुछ विशेषताओं का लाभ उठा सकते हैं। एक प्रकार के रूपांतरण के दो महत्वपूर्ण पहलू हैं कि क्या यह परोक्ष रूप से (स्वचालित रूप से) या स्पष्ट रूप से होता है,[1][6] और क्या अंतर्निहित डेटा प्रतिनिधित्व को एक प्रतिनिधित्व से दूसरे में परिवर्तित किया जाता है, या किसी दिए गए प्रतिनिधित्व को केवल अन्य डेटा प्रकार के प्रतिनिधित्व के रूप में पुनर्व्याख्या किया जाता है।[6][7] सामान्यतः पर, आदिम डेटा प्रकार और यौगिक डेटा प्रकार दोनों को परिवर्तित किया जा सकता है।

कंप्यूटर विज्ञान में, प्रकार रूपांतरण,[1][2] कास्टिंग टाइप करें,[1][3] जबरदस्ती टाइप करें,[3]और बाजीगरी टाइप करें[4][5] एक अभिव्यक्ति (कंप्यूटर विज्ञान) को एक डेटा प्रकार से दूसरे में बदलने के विभिन्न तरीके हैं। एक उदाहरण एक पूर्णांक (कंप्यूटर विज्ञान) मान का एक तैरनेवाला स्थल मान या इसके टेक्स्टुअल प्रतिनिधित्व को एक स्ट्रिंग (कंप्यूटर विज्ञान) के रूप में परिवर्तित करना होगा, और इसके विपरीत। प्रकार के रूपांतरण प्रकार के पदानुक्रम या डेटा प्रतिनिधित्व की कुछ विशेषताओं का लाभ उठा सकते हैं। एक प्रकार के रूपांतरण के दो महत्वपूर्ण पहलू हैं कि क्या यह परोक्ष रूप से (स्वचालित रूप से) या स्पष्ट रूप से होता है,[1][6] और क्या अंतर्निहित डेटा प्रतिनिधित्व को एक प्रतिनिधित्व से दूसरे में परिवर्तित किया जाता है, या किसी दिए गए प्रतिनिधित्व को केवल अन्य डेटा प्रकार के प्रतिनिधित्व के रूप में पुनर्व्याख्या किया जाता है।[6][7] सामान्य तौर पर, आदिम डेटा प्रकार और यौगिक डेटा प्रकार दोनों को परिवर्तित किया जा सकता है।

प्रत्येक प्रोग्रामिंग भाषा के अपने नियम होते हैं कि कैसे प्रकारों को परिवर्तित किया जा सकता है। मजबूत टाइपिंग वाली भाषाएं सामान्यतः बहुत कम अंतर्निहित रूपांतरण करती हैं और अभ्यावेदन की पुनर्व्याख्या को हतोत्साहित करती हैं, जबकि कमजोर टाइपिंग वाली भाषाएं डेटा प्रकारों के बीच कई अंतर्निहित रूपांतरण करती हैं। कमजोर टाइपिंग लैंग्वेज अक्सर संकलक को अलग-अलग प्रतिनिधित्व वाले डेटा आइटम की मनमाने ढंग से व्याख्या करने के लिए मजबूर करती है - यह एक गैर-स्पष्ट प्रोग्रामिंग गलती हो सकती है, या अंतर्निहित हार्डवेयर से सीधे निपटने के लिए एक तकनीकी विधि हो सकती है।

प्रत्येक प्रोग्रामिंग भाषा के अपने नियम होते हैं कि कैसे प्रकारों को परिवर्तित किया जा सकता है। मजबूत टाइपिंग वाली भाषाएं आमतौर पर बहुत कम निहित रूपांतरण करती हैं और अभ्यावेदन की पुनर्व्याख्या को हतोत्साहित करती हैं, जबकि कमजोर टाइपिंग वाली भाषाएं डेटा प्रकारों के बीच कई अंतर्निहित रूपांतरण करती हैं। कमजोर टाइपिंग लैंग्वेज अक्सर संकलक को अलग-अलग प्रतिनिधित्व वाले डेटा आइटम की मनमाने ढंग से व्याख्या करने के लिए मजबूर करती है - यह एक गैर-स्पष्ट प्रोग्रामिंग त्रुटि हो सकती है, या अंतर्निहित हार्डवेयर से सीधे निपटने के लिए एक तकनीकी विधि हो सकती है।

अधिकांश भाषाओं में, ज़बरदस्ती शब्द का उपयोग एक निहित रूपांतरण को दर्शाने के लिए किया जाता है, या तो संकलन के दौरान या रन टाइम (कार्यक्रम जीवनचक्र चरण) के दौरान। उदाहरण के लिए, पूर्णांक और फ्लोटिंग पॉइंट नंबरों (जैसे 5 + 0.1) को मिलाकर एक अभिव्यक्ति में, कंपाइलर स्वचालित रूप से पूर्णांक प्रतिनिधित्व को फ्लोटिंग पॉइंट प्रतिनिधित्व में बदल देगा ताकि अंश खो न जाएं। स्पष्ट प्रकार के रूपांतरण या तो अतिरिक्त कोड लिखकर संकेतित होते हैं (उदाहरण के लिए टाइप आइडेंटिफ़ायर जोड़ना या बिल्ट-इन सबरूटीन को कॉल करना) या कंपाइलर के उपयोग के लिए रूपांतरण रूटीन कोडिंग द्वारा जब यह अन्यथा किसी प्रकार के बेमेल के साथ रुक जाएगा।

अधिकांश ALGOL जैसी भाषाओं में, जैसे पास्कल (प्रोग्रामिंग भाषा), मॉड्यूल-2, एडा (प्रोग्रामिंग भाषा) और डेल्फी (प्रोग्रामिंग भाषा), रूपांतरण और कास्टिंग विशिष्ट रूप से भिन्न अवधारणाएँ हैं। इन भाषाओं में, रूपांतरण या तो निहित रूप से या स्पष्ट रूप से एक डेटा प्रकार के भंडारण प्रारूप से दूसरे में मान को बदलने के लिए संदर्भित करता है, उदा। एक 16-बिट पूर्णांक से 32-बिट पूर्णांक। रूपांतरण के परिणामस्वरूप भंडारण की जरूरतें बदल सकती हैं, जिसमें परिशुद्धता या ट्रंकेशन का संभावित नुकसान भी शामिल है। दूसरी ओर, कास्ट शब्द, एक प्रकार से दूसरे प्रकार के मूल्य का प्रतिनिधित्व करने वाले बिट पैटर्न की व्याख्या को स्पष्ट रूप से बदलने को संदर्भित करता है। उदाहरण के लिए, 32 सन्निहित बिट्स को 32 बूलियन्स की एक सरणी, एक 4-बाइट स्ट्रिंग, एक अहस्ताक्षरित 32-बिट पूर्णांक या एक IEEE एकल सटीक फ़्लोटिंग पॉइंट मान के रूप में माना जा सकता है। क्योंकि संग्रहीत बिट्स कभी नहीं बदले जाते हैं, प्रोग्रामर को अर्थपूर्ण रूप से कास्ट करने के लिए निम्न स्तर के विवरण जैसे प्रतिनिधित्व प्रारूप, बाइट ऑर्डर और संरेखण आवश्यकताओं को जानना चाहिए।

भाषाओं के सी परिवार और ALGOL 68 में, कास्ट शब्द आमतौर पर एक स्पष्ट प्रकार के रूपांतरण (एक अंतर्निहित रूपांतरण के विपरीत) को संदर्भित करता है, जिससे कुछ अस्पष्टता पैदा होती है कि क्या यह बिट-पैटर्न या वास्तविक डेटा प्रतिनिधित्व की पुन: व्याख्या है रूपांतरण। अधिक महत्वपूर्ण तरीकों और नियमों की भीड़ है जो एक सूचक द्वारा स्थित डेटा प्रकार (या कक्षा) पर लागू होती है और वस्तु (वर्ग) विरासत जैसे मामलों में कंपाइलर द्वारा सूचक को कैसे समायोजित किया जा सकता है।

भाषा तुलना

सी जैसी भाषाएं

अंतर्निहित प्रकार रूपांतरण

अंतर्निहित प्रकार का रूपांतरण, जिसे ज़बरदस्ती या प्रकार की बाजीगरी के रूप में भी जाना जाता है, संकलक द्वारा एक स्वचालित प्रकार का रूपांतरण है। कुछ प्रोग्रामिंग लैंग्वेज कंपाइलर्स को ज़बरदस्ती प्रदान करने की अनुमति देती हैं; दूसरों को इसकी आवश्यकता होती है।

मिश्रित-प्रकार की अभिव्यक्ति में, एक या अधिक उपप्रकारों का डेटा सी और सी ++ में ऑपरेटरों को रन टाइम (प्रोग्राम लाइफसाइकिल चरण) पर आवश्यकतानुसार एक सुपरटाइप में ऑपरेटर हो सकता है ताकि प्रोग्राम सही ढंग से चल सके। उदाहरण के लिए, निम्नलिखित कानूनी सी (प्रोग्रामिंग भाषा) कोड है:

<वाक्यविन्यास प्रकाश लैंग = सी> डबल डी; लंबा एल; int मैं;

अगर (डी> मैं) डी = मैं; अगर (i> एल) एल = मैं; अगर (डी == एल) डी * = 2; </वाक्यविन्यास हाइलाइट>

यद्यपि d, l, और i विभिन्न डेटा प्रकारों से संबंधित हैं, हर बार तुलना या असाइनमेंट निष्पादित होने पर वे स्वचालित रूप से समान डेटा प्रकारों में परिवर्तित हो जाएंगे। इस व्यवहार का सावधानी से उपयोग किया जाना चाहिए, क्योंकि अनपेक्षित परिणाम उत्पन्न हो सकते हैं। फ़्लोटिंग-पॉइंट से पूर्णांक में प्रस्तुतियों को परिवर्तित करते समय डेटा खो सकता है, क्योंकि फ़्लोटिंग-पॉइंट मानों के भिन्नात्मक घटकों को छोटा कर दिया जाएगा (शून्य की ओर गोल)। इसके विपरीत, पूर्णांक से फ़्लोटिंग-पॉइंट में प्रस्तुतियों को परिवर्तित करते समय सटीकता खो सकती है, क्योंकि फ़्लोटिंग-पॉइंट प्रकार कुछ पूर्णांक प्रकार के सभी संभावित मानों का सटीक रूप से प्रतिनिधित्व करने में असमर्थ हो सकता है। उदाहरण के लिए, float एक आईईईई 754 एकल सटीक प्रकार हो सकता है, जो पूर्णांक 16777217 का सटीक रूप से प्रतिनिधित्व नहीं कर सकता है, जबकि 32-बिट पूर्णांक प्रकार कर सकता है। जैसा कि निम्नलिखित कोड द्वारा प्रदर्शित किया गया है, यह अनैच्छिक व्यवहार का कारण बन सकता है: 

<वाक्यविन्यास प्रकाश लैंग = सी>
  1. शामिल <stdio.h>

पूर्णांक मुख्य (शून्य) { 

   int i_value = 16777217;
   फ्लोट f_value = 16777216.0;
   प्रिंटफ (पूर्णांक है:% d \ n, i_value);
   प्रिंटफ (फ्लोट है:% f \ n, f_value);
   प्रिंटफ (उनकी समानता:% d \ n, i_value == f_value);

} </वाक्यविन्यास हाइलाइट>

आईईईई एकल परिशुद्धता के रूप में फ्लोट को लागू करने वाले कंपाइलर्स पर, और कम से कम 32 बिट्स के रूप में, यह कोड इस असाधारण प्रिंट-आउट देगा: 

पूर्णांक है: 16777217
फ्लोट है: 16777216.000000
उनकी समानता: 1

ध्यान दें कि 1 उपरोक्त अंतिम पंक्ति में समानता का प्रतिनिधित्व करता है। यह अजीब व्यवहार के निहित रूपांतरण के कारण होता है i_value तैरने के लिए जब इसकी तुलना की जाती है f_value. रूपांतरण से परिशुद्धता का नुकसान होता है, जो मूल्यों को तुलना से पहले समान बनाता है।

महत्वपूर्ण टेकअवे:

  1. float को int काट-छांट का कारण बनता है, यानी आंशिक भाग को हटा देता है।
  2. double को float अंक के पूर्णांकन का कारण बनता है।
  3. long को int अतिरिक्त उच्च क्रम बिट्स को छोड़ने का कारण बनता है।

टाइप प्रमोशन

निहित प्रकार के रूपांतरण का एक विशेष मामला प्रकार का प्रचार है, जहां एक वस्तु स्वचालित रूप से मूल प्रकार के सुपरसेट का प्रतिनिधित्व करने वाले दूसरे डेटा प्रकार में परिवर्तित हो जाती है। पदोन्नति आमतौर पर लक्ष्य प्लेटफॉर्म की अंकगणितीय तर्क इकाई (एएलयू) के मूल प्रकार से छोटे प्रकार के साथ अंकगणितीय और तार्किक संचालन से पहले, इस तरह के संचालन को संभव बनाने के लिए, या अधिक कुशल होने पर उपयोग किया जाता है यदि एएलयू एक से अधिक प्रकार के साथ काम कर सकता है। सी और सी ++ बूलियन, कैरेक्टर, वाइड कैरेक्टर, एन्यूमरेशन, और शॉर्ट इंटीजर टाइप्स के ऑब्जेक्ट्स के लिए ऐसे प्रमोशन करते हैं, जिन्हें इंट में प्रमोट किया जाता है, और टाइप फ्लोट के ऑब्जेक्ट्स के लिए, जिन्हें डबल के लिए प्रमोट किया जाता है। कुछ अन्य प्रकार के रूपांतरणों के विपरीत, प्रचार कभी भी सटीकता नहीं खोते हैं या वस्तु में संग्रहीत मूल्य को संशोधित नहीं करते हैं।

जावा (प्रोग्रामिंग भाषा) में: <वाक्यविन्यास प्रकाश लैंग = जावा> इंट एक्स = 3; डबल वाई = 3.5; System.out.println (x + y); // आउटपुट 6.5 होगा </वाक्यविन्यास हाइलाइट>

स्पष्ट प्रकार रूपांतरण

स्पष्ट प्रकार का रूपांतरण, जिसे टाइप कास्टिंग भी कहा जाता है, एक प्रकार का रूपांतरण है जिसे एक प्रोग्राम के भीतर स्पष्ट रूप से परिभाषित किया जाता है (अंतर्निहित प्रकार के रूपांतरण के लिए भाषा के नियमों के अनुसार स्वचालित रूप से किए जाने के बजाय)। यह कार्यक्रम में उपयोगकर्ता द्वारा अनुरोध किया गया है।

<वाक्यविन्यास लैंग = सीपीपी> डबल दा = 3.3; डबल डीबी = 3.3; डबल डीसी = 3.4; int परिणाम = (int)da + (int)db + (int)dc; // परिणाम == 9 // यदि अंतर्निहित रूपांतरण का उपयोग किया जाएगा (परिणाम = da + db + dc के साथ), तो परिणाम 10 के बराबर होगा </वाक्यविन्यास हाइलाइट>

कई प्रकार के स्पष्ट रूपांतरण हैं।

जाँच की गई
रूपांतरण किए जाने से पहले, यह देखने के लिए एक रनटाइम जाँच की जाती है कि क्या गंतव्य प्रकार स्रोत मान को धारण कर सकता है। यदि नहीं, तो एक त्रुटि स्थिति उठाई जाती है।
अनियंत्रित
कोई जाँच नहीं की जाती है। यदि गंतव्य प्रकार स्रोत मान नहीं रख सकता है, तो परिणाम अपरिभाषित है।
बिट पैटर्न
स्रोत के कच्चे बिट प्रतिनिधित्व को शब्दशः कॉपी किया जाता है, और गंतव्य प्रकार के अनुसार इसकी फिर से व्याख्या की जाती है। यह अलियासिंग (कंप्यूटिंग) के माध्यम से भी प्राप्त किया जा सकता है।

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग लैंग्वेज में, ऑब्जेक्ट्स डाउनकास्टिंग भी हो सकते हैं: बेस क्लास का एक संदर्भ इसके व्युत्पन्न वर्गों में से एक में डाला जाता है।

सी # और सी ++

सी शार्प (प्रोग्रामिंग लैंग्वेज) | सी # में, टाइप रूपांतरण सुरक्षित या असुरक्षित (यानी, सी-लाइक) तरीके से किया जा सकता है, पूर्व में चेक्ड टाइप कास्ट कहा जाता है।[8] <वाक्यविन्यास प्रकाश लैंग = csharp> पशु पशु = नई बिल्ली ();

बुलडॉग बी = (बुलडॉग) जानवर; // अगर (पशु बुलडॉग है), stat.type(animal) बुलडॉग है, अन्यथा अपवाद बी = जानवर बुलडॉग के रूप में; // अगर (जानवर बुलडॉग है), बी = (बुलडॉग) जानवर, और बी = शून्य

पशु = अशक्त; बी = जानवर बुलडॉग के रूप में; // बी == अशक्त </वाक्यविन्यास हाइलाइट>

C++ में C++- स्टाइल कास्ट सिंटैक्स का उपयोग करके एक समान प्रभाव प्राप्त किया जा सकता है।

<वाक्यविन्यास लैंग = सीपीपी> पशु * पशु = नई बिल्ली;

बुलडॉग * बी = स्टेटिक_कास्ट <बुलडॉग *> (पशु); // संकलन केवल तभी होता है जब पशु या बुलडॉग दूसरे (या समान) से प्राप्त होता है बी = डायनेमिक_कास्ट <बुलडॉग *> (पशु); // अगर (जानवर बुलडॉग है), बी = (बुलडॉग *) जानवर, और बी = नलप्टर

बुलडॉग और बीआर = स्टेटिक_कास्ट <बुलडॉग और> (* जानवर); // उपरोक्त के समान, लेकिन अगर एक नलप्टर वापस किया जाना था तो एक अपवाद फेंक दिया जाएगा 

                                             // यह कोड में नहीं देखा जाता है जहां अपवाद हैंडलिंग से बचा जाता है

पशु = अशक्त; बी = डायनेमिक_कास्ट <बुलडॉग *> (पशु); // बी == नलप्टर

जानवर को हटाओ; // हमेशा मुक्त संसाधन </वाक्यविन्यास हाइलाइट>

एफिल

एफिल (प्रोग्रामिंग लैंग्वेज) में टाइप रूपांतरण की धारणा को टाइप सिस्टम के नियमों में एकीकृत किया गया है। असाइनमेंट नियम कहता है कि एक असाइनमेंट, जैसे कि: <वाक्यविन्यास लैंग = एफिल> एक्स := य </वाक्यविन्यास हाइलाइट> मान्य है अगर और केवल अगर इसकी स्रोत अभिव्यक्ति का प्रकार, y इस मामले में, इसकी लक्ष्य इकाई के प्रकार के साथ संगत है, x इस मामले में। इस नियम में, के साथ संगत का अर्थ है कि स्रोत अभिव्यक्ति का प्रकार या तो लक्ष्य के अनुरूप या परिवर्तित हो जाता है। वस्तु-उन्मुख प्रोग्रामिंग में बहुरूपता के लिए परिचित नियमों द्वारा प्रकारों के अनुरूपता को परिभाषित किया गया है। उदाहरण के लिए, ऊपर दिए गए असाइनमेंट में y का प्रकार x के प्रकार के अनुरूप होता है यदि वह वर्ग जिस पर y आधारित है उस पर आधारित है जिस पर x आधारित है।

एफिल में प्रकार रूपांतरण की परिभाषा

एफिल में प्रकार रूपांतरण की क्रियाएं, विशेष रूप से परिवर्तित और से परिवर्तित होती हैं, उन्हें इस प्रकार परिभाषित किया गया है:

<ब्लॉककोट> वर्ग सीयू पर आधारित एक प्रकार एक वर्ग सीटी के आधार पर एक प्रकार टी में परिवर्तित हो जाता है (और टी यू से परिवर्तित होता है) यदि या तो

सीटी में एक रूपांतरण प्रकार के रूप में यू का उपयोग करके एक रूपांतरण प्रक्रिया है, या
CU में रूपांतरण प्रकार के रूप में रूपांतरण क्वेरी लिस्टिंग T है

</ब्लॉककोट>

उदाहरण

एफिल माइक्रोसॉफ्ट .नेट फ्रेमवर्क के लिए सीएलआई भाषाओं की पूरी तरह से अनुपालन सूची है। .NET के विकास से पहले, एफिल के पास पहले से ही व्यापक श्रेणी के पुस्तकालय थे। .NET प्रकार के पुस्तकालयों का उपयोग करना, विशेष रूप से आमतौर पर उपयोग किए जाने वाले प्रकारों जैसे स्ट्रिंग्स के साथ, एक रूपांतरण समस्या उत्पन्न करता है। मौजूदा एफिल सॉफ्टवेयर एफिल लाइब्रेरी से स्ट्रिंग क्लासेस (जैसे <कोड लैंग= एफिल >STRING_8) का उपयोग करता है, लेकिन .NET के लिए लिखे गए एफिल सॉफ्टवेयर को .NET स्ट्रिंग क्लास (System. String) कई मामलों में, उदाहरण के लिए .NET विधियों को कॉल करते समय जो .NET प्रकार की वस्तुओं को तर्क के रूप में पारित करने की अपेक्षा करते हैं। इसलिए, इन प्रकारों का आगे और पीछे रूपांतरण जितना संभव हो उतना निर्बाध होना चाहिए।

<वाक्यविन्यास लैंग = एफिल> 

   my_string: STRING_8 -- नेटिव एफिल स्ट्रिंग
   my_system_string: SYSTEM_STRING -- नेटिव .NET स्ट्रिंग

       ...

           my_string: = my_system_string

</वाक्यविन्यास हाइलाइट>

उपरोक्त कोड में, दो स्ट्रिंग घोषित किए गए हैं, प्रत्येक भिन्न प्रकार में से एक (SYSTEM_STRING System.String के लिए एफिल संगत उपनाम है)। चूँकि System.String STRING_8 के अनुरूप नहीं है, तो उपरोक्त असाइनमेंट केवल तभी मान्य है जब System.String > STRING_8 में बदल जाता है.

एफिल क्लास STRING_8 में System.String प्रकार के ऑब्जेक्ट के लिए make_from_cil रूपांतरण प्रक्रिया है। रूपांतरण प्रक्रियाओं को भी हमेशा निर्माण प्रक्रियाओं (निर्माणकर्ताओं के समान) के रूप में निर्दिष्ट किया जाता है। निम्नलिखित STRING_8 वर्ग का अंश है:

<वाक्यविन्यास लैंग = एफिल> 

   कक्षा STRING_8
       ...
   बनाएं
       make_from_cil
       ...
   बदलना
       make_from_cil ({SYSTEM_STRING})
       ...

</वाक्यविन्यास हाइलाइट>

रूपांतरण प्रक्रिया की उपस्थिति असाइनमेंट बनाती है:

<वाक्यविन्यास लैंग = एफिल> 

           my_string: = my_system_string

</वाक्यविन्यास हाइलाइट>

शब्दार्थ के बराबर:

<वाक्यविन्यास लैंग = एफिल> 

           my_string.make_from_cil (my_system_string) बनाएं

</वाक्यविन्यास हाइलाइट>

जिसमें my_string को STRING_8 प्रकार के एक नए ऑब्जेक्ट के रूप में बनाया गया है, जिसमें my_system_string के बराबर सामग्री है।

मूल स्रोत और लक्ष्य उलटे हुए असाइनमेंट को संभालने के लिए:

<वाक्यविन्यास लैंग = एफिल> 

           my_system_string := my_string

</वाक्यविन्यास हाइलाइट>

क्लास STRING_8 में एक कनवर्ज़न क्वेरी to_cil भी शामिल है जो निम्न के उदाहरण से एक System.String उत्पन्न करेगी <कोड लैंग= एफिल >STRING_8.

<वाक्यविन्यास लैंग = एफिल> 

   कक्षा STRING_8
       ...
   बनाएं
       make_from_cil
       ...
   बदलना
       make_from_cil ({SYSTEM_STRING})
       to_cil: {SYSTEM_STRING}
       ...

</वाक्यविन्यास हाइलाइट>

सौंपा गया काम:

<वाक्यविन्यास लैंग = एफिल> 

           my_system_string := my_string

</वाक्यविन्यास हाइलाइट>

फिर, इसके बराबर हो जाता है:

<वाक्यविन्यास लैंग = एफिल> 

           my_system_string := my_string.to_cil

</वाक्यविन्यास हाइलाइट>

एफिल में, प्रकार रूपांतरण के लिए सेटअप वर्ग कोड में शामिल है, लेकिन फिर क्लाइंट कोड में #Explicit प्रकार रूपांतरण के रूप में स्वचालित रूप से होने लगता है। इसमें केवल असाइनमेंट ही नहीं बल्कि अन्य प्रकार के अटैचमेंट भी शामिल हैं, जैसे तर्क (पैरामीटर) प्रतिस्थापन।

जंग

जंग (प्रोग्रामिंग भाषा) आदिम प्रकारों के बीच कोई अंतर्निहित प्रकार रूपांतरण (ज़बरदस्ती) प्रदान नहीं करता है। लेकिन, स्पष्ट प्रकार के रूपांतरण (कास्टिंग) का उपयोग करके किया जा सकता है as कीवर्ड।[9] <वाक्यविन्यास प्रकाश लैंग = जंग> println! (1000 एक u16 के रूप में है: {}, 1000 u16 के रूप में); </वाक्यविन्यास हाइलाइट>

सुरक्षा मुद्दे

हैकर (कंप्यूटर सुरक्षा) में, टाइपकास्टिंग एक चर (कंप्यूटर विज्ञान) के डेटा प्रकार को मूल रूप से परिभाषित करने के तरीके से अस्थायी रूप से बदलने के लिए प्रकार रूपांतरण का दुरुपयोग है।[10] यह हैकर्स के लिए अवसर प्रदान करता है क्योंकि एक चर के टाइपकास्ट होने के बाद एक भिन्न डेटा प्रकार बनने के बाद, संकलक उस हैक किए गए चर को उस विशिष्ट ऑपरेशन के लिए नए डेटा प्रकार के रूप में मानेगा।[11]


यह भी देखें

  • डाउनकास्टिंग
  • रन-टाइम प्रकार की जानकारी # डायनेमिक कास्ट और जावा कास्ट
  • पनिंग टाइप करें

संदर्भ

  1. ↑ 1.0 1.1 1.2 1.3 1.4 1.5 Mehrotra, Dheeraj (2008). S. Chand's Computer Science. pp. 81–83. ISBN 978-8121929844.
  2. ↑ 2.0 2.1 Programming Languages - Design and Constructs. 2013. p. 35. ISBN 978-9381159415.
  3. ↑ 3.0 3.1 3.2 3.3 Reilly, Edwin (2004). Concise Encyclopedia of Computer Science. pp. 82, 110. ISBN 0470090952.
  4. ↑ 4.0 4.1 Fenton, Steve (2017). Pro TypeScript: Application-Scale JavaScript Development. pp. xxiii. ISBN 978-1484232491.
  5. ↑ 5.0 5.1 "PHP: Type Juggling - Manual". php.net. Retrieved 2019-01-27.
  6. ↑ 6.0 6.1 6.2 6.3 Olsson, Mikael (2013). C++ Quick Syntax Reference. pp. 87–89. ISBN 978-1430262770.
  7. ↑ 7.0 7.1 Kruse, Rudolf; Borgelt, Christian; Braune, Christian; Mostaghim, Sanaz; Steinbrecher, Matthias (16 September 2016). Computational Intelligence: A Methodological Introduction. p. 269. ISBN 978-1447172963.
  8. ↑ Mössenböck, Hanspeter (25 March 2002). "Advanced C#: Checked Type Casts" (PDF). Institut für Systemsoftware, Johannes Kepler Universität Linz, Fachbereich Informatik. p. 5. Retrieved 4 August 2011. at C# Tutorial
  9. ↑ "Casting - Rust By Example". doc.rust-lang.org.
  10. ↑ Jon Erickson Hacking, 2nd Edition: The Art of Exploitation 2008 1593271441 p51 "Typecasting is simply a way to temporarily change a variable's data type, despite how it was originally defined. When a variable is typecast into a different type, the compiler is basically told to treat that variable as if it were the new data type, but only for that operation. The syntax for typecasting is as follows: (typecast_data_type) variable ..."
  11. ↑ Arpita Gopal Magnifying C 2009 8120338618 p. 59 "From the above, it is clear that the usage of typecasting is to make a variable of one type, act like another type for one single operation. So by using this ability of typecasting it is possible for create ASCII characters by typecasting integer to its ..."


बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=टाइप_कन्वर्शन&oldid=107152’