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

From Vigyanwiki
No edit summary
 
(50 intermediate revisions by 5 users not shown)
Line 1: Line 1:
{{Short description|Changing an expression from one data type to another}}
{{Short description|Changing an expression from one data type to another}}
[[कंप्यूटर विज्ञान]] में, टाइप रूपांतरण,<ref name=":0">{{Cite book|title=S. Chand's Computer Science|year=2008|isbn=978-8121929844|pages=81–83|last1=Mehrotra|first1=Dheeraj}}</ref><ref name=":3">{{Cite book|title=Programming Languages - Design and Constructs|year=2013|isbn=978-9381159415|pages=35}}</ref> टाइप कास्टिंग,<ref name=":0" /><ref name=":1">{{Cite book|title=Concise Encyclopedia of Computer Science|last=Reilly|first=Edwin|year=2004|isbn=0470090952|pages=[https://archive.org/details/conciseencyclope0000unse_v5u2/page/82 82, 110]|url=https://archive.org/details/conciseencyclope0000unse_v5u2/page/82}}</ref> टाइप कोएर्सीओन,<ref name=":1" />और टाइप जगलिंग,<ref name=":4">{{Cite book|title=Pro TypeScript: Application-Scale JavaScript Development|last=Fenton|first=Steve|year=2017|isbn=978-1484232491|pages=xxiii}}</ref><ref name=":5">{{Cite web|url=http://php.net/manual/en/language.types.type-juggling.php|title=PHP: Type Juggling - Manual|website=php.net|access-date=2019-01-27}}</ref> एक [[अभिव्यक्ति (कंप्यूटर विज्ञान)]] को एक [[डेटा प्रकार|डेटा टाइप]] से दूसरे में परिवर्तित करने कि विभिन्न युक्ति हैं। इसका एक उदाहरण एक पूर्णांक (कंप्यूटर विज्ञान) मान का एक [[तैरनेवाला स्थल]] फ़्लोटिंग पॉइंट मान में रूपांतरण या [[स्ट्रिंग (कंप्यूटर विज्ञान)]] के रूप में इसका शाब्दिक प्रतिनिधित्व है। जिसका विपरीत भी रूपांतरण का एक उदाहरण होगा। टाइप के रूपांतरण टाइप हायरार्की या [[डेटा प्रतिनिधित्व]] की कुछ विशेषताओं का लाभ उठा सकते हैं। एक टाइप के रूपांतरण के दो महत्वपूर्ण पहलू हैं कि क्या यह परोक्ष रूप से (स्वचालित रूप से) या स्पष्ट रूप से होते है,<ref name=":0" /><ref name=":2">{{Cite book|title=C++ Quick Syntax Reference|last=Olsson|first=Mikael|year=2013|isbn=978-1430262770|pages=87–89}}</ref> और क्या अंतर्निहित डेटा प्रतिनिधित्व को एक प्रतिनिधित्व से दूसरे में परिवर्तित किया जा सकता है, या किसी दिए गए प्रतिनिधित्व की केवल दूसरे के प्रतिनिधित्व के रूप में व्याख्या की जा सकती है।<ref name=":2" /><ref name=":6">{{Cite book|title=Computational Intelligence: A Methodological Introduction|isbn=978-1447172963|pages=269|last1=Kruse|first1=Rudolf|last2=Borgelt|first2=Christian|last3=Braune|first3=Christian|last4=Mostaghim|first4=Sanaz|last5=Steinbrecher|first5=Matthias|date=16 September 2016}}</ref> सामान्यतः [[आदिम डेटा प्रकार|आदिम डेटा टाइप]] और [[यौगिक डेटा प्रकार|यौगिक डेटा टाइप]] दोनों को परिवर्तित किया जा सकता है।
[[कंप्यूटर विज्ञान]] में, '''टाइप कन्वर्शन''',<ref name=":0">{{Cite book|title=S. Chand's Computer Science|year=2008|isbn=978-8121929844|pages=81–83|last1=Mehrotra|first1=Dheeraj}}</ref><ref name=":3">{{Cite book|title=Programming Languages - Design and Constructs|year=2013|isbn=978-9381159415|pages=35}}</ref> टाइप कास्टिंग,<ref name=":0" /><ref name=":1">{{Cite book|title=Concise Encyclopedia of Computer Science|last=Reilly|first=Edwin|year=2004|isbn=0470090952|pages=[https://archive.org/details/conciseencyclope0000unse_v5u2/page/82 82, 110]|url=https://archive.org/details/conciseencyclope0000unse_v5u2/page/82}}</ref> टाइप कोएर्सीओन,<ref name=":1" />और टाइप जगलिंग,<ref name=":4">{{Cite book|title=Pro TypeScript: Application-Scale JavaScript Development|last=Fenton|first=Steve|year=2017|isbn=978-1484232491|pages=xxiii}}</ref><ref name=":5">{{Cite web|url=http://php.net/manual/en/language.types.type-juggling.php|title=PHP: Type Juggling - Manual|website=php.net|access-date=2019-01-27}}</ref> एक [[अभिव्यक्ति (कंप्यूटर विज्ञान)]] को एक [[डेटा प्रकार|डेटा टाइप]] से दूसरे में परिवर्तित करने के विभिन्न उपाय हैं। जिसका एक उदाहरण [[पूर्णांक (कंप्यूटर विज्ञान)]] मान का एक [[तैरनेवाला स्थल]] मान में कन्वर्शन या [[स्ट्रिंग (कंप्यूटर विज्ञान)]] के रूप में इसका शाब्दिक प्रतिनिधित्व होगा, और इसका विपरीत भी संभव है । टाइप के कन्वर्शन टाइप हायरार्की या [[डेटा प्रतिनिधित्व]] की कुछ विशेषताओं का लाभ उठा सकते हैं। एक टाइप के कन्वर्शन के दो महत्वपूर्ण पहलू हैं कि क्या यह परोक्ष रूप से (स्वचालित रूप से) या स्पष्ट रूप से होते है,<ref name=":0" /><ref name=":2">{{Cite book|title=C++ Quick Syntax Reference|last=Olsson|first=Mikael|year=2013|isbn=978-1430262770|pages=87–89}}</ref> और क्या अंतर्निहित डेटा प्रतिनिधित्व को एक प्रतिनिधित्व से दूसरे में परिवर्तित किया जा सकता है, या किसी दिए गए प्रतिनिधित्व की केवल दूसरे के प्रतिनिधित्व के रूप में व्याख्या की जा सकती है।<ref name=":2" /><ref name=":6">{{Cite book|title=Computational Intelligence: A Methodological Introduction|isbn=978-1447172963|pages=269|last1=Kruse|first1=Rudolf|last2=Borgelt|first2=Christian|last3=Braune|first3=Christian|last4=Mostaghim|first4=Sanaz|last5=Steinbrecher|first5=Matthias|date=16 September 2016}}</ref> सामान्यतः [[आदिम डेटा प्रकार|आदिम डेटा टाइप]] और [[यौगिक डेटा प्रकार|यौगिक डेटा टाइप]] दोनों को परिवर्तित किया जा सकता है।


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


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


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


भाषाओं के सी परिवार और [[Index.php?title=अल्गोल 68|अल्गोल 68]] में, कास्ट शब्द सामान्यतः एक स्पष्ट टाइप के रूपांतरण (एक अंतर्निहित रूपांतरण के विपरीत) को संदर्भित करता है, जिससे कुछ अस्पष्टता पैदा होती है कि क्या यह बिट-पैटर्न या वास्तविक डेटा प्रतिनिधित्व रूपांतरण की पुन: व्याख्या है। अधिक महत्वपूर्ण युक्ति और नियमों की समूह है जो एक सूचक द्वारा स्थित डेटा टाइप (या कक्षा) पर लागू होती है और वस्तु (वर्ग) उत्तराधिकार जैसे मामलों में कंपाइलर द्वारा सूचक को कैसे समायोजित किया जा सकता है।
भाषाओं के सी परिवार और [[Index.php?title=अल्गोल 68|अल्गोल 68]] में, कास्ट शब्द सामान्यतः एक स्पष्ट टाइप के कन्वर्शन (एक अंतर्निहित कन्वर्शन के विपरीत) को संदर्भित करता है, जिससे कुछ अस्पष्टता पैदा होती है कि क्या यह बिट-पैटर्न या वास्तविक डेटा प्रतिनिधित्व कन्वर्शन की पुन: व्याख्या है। अधिक महत्वपूर्ण, युक्ति और नियमों का समूह है जो एक सूचक द्वारा स्थित डेटा टाइप (या कक्षा) पर लागू होता है और वस्तु (वर्ग) उत्तराधिकार जैसे मामलों में अनुभाषक द्वारा सूचक को कैसे समायोजित किया जा सकता है।


== भाषा तुलना ==
== भाषा तुलना ==
Line 14: Line 14:
=== सी जैसी भाषाएं ===
=== सी जैसी भाषाएं ===


==== अंतर्निहित टाइप रूपांतरण ====
==== अंतर्निहित टाइप कन्वर्शन ====
अंतर्निहित टाइप का रूपांतरण, जिसे कोएर्सीओन या टाइप की जगलिंग के रूप में भी जाना जाता है, संकलक द्वारा एक स्वचालित टाइप का रूपांतरण है। कुछ प्रोग्रामिंग भाषा कंपाइलर्स को प्रवलता प्रदान करने की अनुमति देता हैं; चूँकि दूसरों को इसकी आवश्यकता होती है।
अंतर्निहित टाइप का कन्वर्शन, जिसे कोएर्सीओन या टाइप की जगलिंग के रूप में भी जाना जाता है, अनुभाषक द्वारा एक स्वचालित टाइप का कन्वर्शन है। कुछ प्रोग्रामिंग भाषा अनुभाषक को प्रवलता प्रदान करने की अनुमति देता हैं; चूँकि दूसरों को इसकी आवश्यकता होती है। मिश्रित टाइप के व्यंजक में, एक या एक से अधिक उप-टाइप के डेटा को रनटाइम पर आवश्यकतानुसार सुपरटाइप में परिवर्तित किया जा सकता है जिससे प्रोग्राम सही ढंग से चल सके। उदाहरण के लिए, निम्नलिखित लीगल [[सी (प्रोग्रामिंग भाषा)]] कोड है:<syntaxhighlight lang="c">
double  d;
long    l;
int    i;


मिश्रित टाइप के व्यंजक में, एक या एक से अधिक उप-टाइप के डेटा को रनटाइम पर आवश्यकतानुसार सुपरटाइप में परिवर्तित किया जा सकता है जिससे प्रोग्राम सही ढंग से चल सके। उदाहरण के लिए, निम्नलिखित लीगल [[सी (प्रोग्रामिंग भाषा)]] कोड है:
if (d > i)   d = i;
if (i > l)  l = i;
if (d == l)  d *= 2;
</syntaxhighlight>


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


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


<!-- an int is within - 32767(?) and 32767, isn't it ?! --> <वाक्यविन्यास प्रकाश लैंग = सी>
<!-- an int is within - 32767(?) and 32767, isn't it ?! --><syntaxhighlight lang="c">
#सम्मलित <stdio.h>
#include <stdio.h>


पूर्णांक मुख्य (शून्य) {
int main(void)
  int i_value = 16777217;
{
  फ्लोट f_value = 16777216.0;
    int i_value   = 16777217;
प्रिंटफ (पूर्णांक है:% d \ n, i_value);
    float f_value = 16777216.0;
    printf("The integer is: %d\n", i_value);
    printf("The float is:  %f\n", f_value);
    printf("Their equality: %d\n", i_value == f_value);
}
</syntaxhighlight>


  प्रिंटफ (फ्लोट है:% f \ n, f_value);
आईईईई एकल परिशुद्धता के रूप में फ्लोट को लागू करने वाले अनुभाषक पर, और कम से कम 32 बिट्स के रूप में, यह कोड इस असाधारण प्रिंट-आउट को देगा:


  प्रिंटफ (उनकी समानता:% d \ n, i_value == f_value);
The integer is: 16777217
The float is: 16777216.000000
Their equality: 1


} </वाक्यविन्यास हाइलाइट>
ध्यान दें कि 1 उपरोक्त अंतिम पंक्ति में समानता का प्रतिनिधित्व करता है। यह अनूठा व्यवहार {{C-lang|i_value}}के फ़्लोट करने के अंतर्निहित कन्वर्शन के कारण होता है जब इसकी तुलना {{C-lang|f_value}} से की जाती है। जो मूल्यों को तुलना से पहले समान बनाता है।
 
आईईईई एकल परिशुद्धता के रूप में फ्लोट को लागू करने वाले कंपाइलर्स पर, और कम से कम 32 बिट्स के रूप में, यह कोड इस असाधारण प्रिंट-आउट देगा:
 
पूर्णांक है: 16777217
फ्लोट है: 16777216.000000
उनकी समानता: 1
 
ध्यान दें कि 1 उपरोक्त अंतिम पंक्ति में समानता का प्रतिनिधित्व करता है। यह अजीब व्यवहार {{C-lang|i_value}}के फ़्लोट करने के अंतर्निहित रूपांतरण के कारण होता है जब इसकी तुलना {{C-lang|f_value}}. से की जाती है। जो मूल्यों को तुलना से पहले समान बनाता है।


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


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


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


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


<वाक्यविन्यास लैंग = सीपीपी> डबल दा = 3.3; डबल डीबी = 3.3; डबल डीसी = 3.4; int परिणाम = (int)da + (int)db + (int)dc; // परिणाम == 9 // यदि अंतर्निहित रूपांतरण का उपयोग किया जाएगा (परिणाम = da + db + dc के साथ), तो परिणाम 10 के बराबर होगा </वाक्यविन्यास हाइलाइट>
स्पष्ट टाइप का कन्वर्शन, जिसे टाइप कास्टिंग भी कहा जाता है, एक टाइप का कन्वर्शन है जिसे एक कार्यक्रम के भीतर स्पष्ट रूप से परिभाषित किया जाता है (अंतर्निहित टाइप के कन्वर्शन के लिए भाषा के नियमों के अनुसार स्वचालित रूप से किए जाने के बजाय)। यह कार्यक्रम में उपयोगकर्ता द्वारा अनुरोध किया गया है।<syntaxhighlight lang="java5">
 
double da = 3.3;
कई प्रकार के स्पष्ट रूपांतरण हैं।
double db = 3.3;
; जाँच की गई: रूपांतरण किए जाने से पहले, यह देखने के लिए एक रनटाइम जाँच की जाती है कि क्या गंतव्य टाइप स्रोत मान को धारण कर सकता है। यदि नहीं, तो एक त्रुटि स्थिति उठाई जाती है।
double dc = 3.4;
int result = (int)da + (int)db + (int)dc; // result == 9
// if implicit conversion would be used (as with "result = da + db + dc"), result would be equal to 10
</syntaxhighlight>कई प्रकार के स्पष्ट कन्वर्शन हैं।
; जाँच की गई: कन्वर्शन किए जाने से पहले, यह देखने के लिए एक रनटाइम जाँच की जाती है कि क्या गंतव्य टाइप स्रोत मान को धारण कर सकता है। यदि नहीं, तो एक त्रुटि स्थिति उठाई जाती है।
; अनियंत्रित: कोई जाँच नहीं की जाती है। यदि गंतव्य टाइप स्रोत मान नहीं रख सकता है, तो परिणाम अपरिभाषित है।
; अनियंत्रित: कोई जाँच नहीं की जाती है। यदि गंतव्य टाइप स्रोत मान नहीं रख सकता है, तो परिणाम अपरिभाषित है।
; बिट पैटर्न: स्रोत के कच्चे बिट प्रतिनिधित्व को शब्दशः कॉपी किया जाता है, और गंतव्य टाइप के अनुसार इसकी फिर से व्याख्या की जाती है। यह [[अलियासिंग (कंप्यूटिंग)]] के माध्यम से भी प्राप्त किया जा सकता है।
; बिट पैटर्न: स्रोत के अनिर्मित बिट प्रतिनिधित्व को शब्दशः कॉपी किया जाता है, और गंतव्य टाइप के अनुसार इसकी फिर से व्याख्या की जाती है। यह [[अलियासिंग (कंप्यूटिंग)]] के माध्यम से भी प्राप्त किया जा सकता है।


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


=== सी # और सी ++ ===
=== सी # और सी ++ ===
सी शार्प (प्रोग्रामिंग लैंग्वेज) C# में, टाइप रूपांतरण सुरक्षित या असुरक्षित (यानी, सी-लाइक) विधि से किया जा सकता है, पहले वाले को चेक्ड टाइप कास्ट कहा जाता है।<ref>
सी शार्प (प्रोग्रामिंग लैंग्वेज) C# में, टाइप कन्वर्शन सुरक्षित या असुरक्षित (यानी, सी-लाइक) विधि से किया जा सकता है, पहले वाले को चेक्ड टाइप कास्ट कहा जाता है।<ref>
{{cite web
{{cite web
| access-date = 4 August 2011
| access-date = 4 August 2011
Line 83: Line 90:
| title      = Advanced C#: Checked Type Casts
| title      = Advanced C#: Checked Type Casts
| url        = http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/Part2.pdf}} at [http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/ C# Tutorial]
| url        = http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/Part2.pdf}} at [http://ssw.jku.at/Teaching/Lectures/CSharp/Tutorial/ C# Tutorial]
</ref>
</ref><syntaxhighlight lang="c#">
 
Animal animal = new Cat();
<वाक्यविन्यास प्रकाश लैंग = csharp> पशु पशु = नई बिल्ली ();
 
बुलडॉग बी = (बुलडॉग) जानवर; // अगर (पशु बुलडॉग है), stat.type(animal) बुलडॉग है, अन्यथा अपवाद बी = जानवर बुलडॉग के रूप में; // अगर (जानवर बुलडॉग है), बी = (बुलडॉग) जानवर, और बी = शून्य
 
पशु = अशक्त; बी = जानवर बुलडॉग के रूप में; // बी == अशक्त </वाक्यविन्यास हाइलाइट>


[[C++]] में C++- स्टाइल कास्ट सिंटैक्स का उपयोग करके एक समान प्रभाव प्राप्त किया जा सकता है।
Bulldog b = (Bulldog) animal;  // if (animal is Bulldog), stat.type(animal) is Bulldog, else an exception
b = animal as Bulldog;        // if (animal is Bulldog), b = (Bulldog) animal, else b = null


<वाक्यविन्यास लैंग = सीपीपी> पशु * पशु = नई बिल्ली;
animal = null;
b = animal as Bulldog;        // b == null
</syntaxhighlight>[[C++]] में C++- स्टाइल कास्ट सिंटैक्स का उपयोग करके एक समान प्रभाव प्राप्त किया जा सकता है।<syntaxhighlight lang="c++">
Animal* animal = new Cat;


बुलडॉग * बी = स्टेटिक_कास्ट <बुलडॉग *> (पशु); // संकलन केवल तभी होता है जब पशु या बुलडॉग दूसरे (या समान) से प्राप्त होता है बी = डायनेमिक_कास्ट <बुलडॉग *> (पशु); // अगर (जानवर बुलडॉग है), बी = (बुलडॉग *) जानवर, और बी = नलप्टर
Bulldog* b = static_cast<Bulldog*>(animal); // compiles only if either Animal or Bulldog is derived from the other (or same)
b = dynamic_cast<Bulldog*>(animal);         // if (animal is Bulldog), b = (Bulldog*) animal, else b = nullptr


बुलडॉग और बीआर = स्टेटिक_कास्ट <बुलडॉग और> (* जानवर); // उपरोक्त के समान, लेकिन अगर एक नलप्टर वापस किया जाना था तो एक अपवाद छोड़ दिया जाएगा
Bulldog& br = static_cast<Bulldog&>(*animal); // same as above, but an exception will be thrown if a nullptr was to be returned
  // यह कोड में नहीं देखा जाता है जहां अपवाद हैंडलिंग से बचा जाता है
                                              // this is not seen in code where exception handling is avoided
पशु = अशक्त; बी = डायनेमिक_कास्ट <बुलडॉग *> (पशु); // बी == नलप्टर
animal = nullptr;
b = dynamic_cast<Bulldog*>(animal);         // b == nullptr


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


=== एफिल ===
=== एफिल ===


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


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


वर्ग सीयू पर आधारित एक टाइप एक वर्ग सीटी के आधार पर एक टाइप टी में परिवर्तित हो जाता है (और टी यू से परिवर्तित होता है) यदि या तो
वर्ग सीयू पर आधारित एक टाइप एक वर्ग सीटी के आधार पर एक टाइप टी में परिवर्तित हो जाता है (और टी यू से परिवर्तित होता है) यदि या तो
: रूपांतरण टाइप के रूप में यू का उपयोग करते हुए सीटी में एक रूपांतरण प्रक्रिया है, या
: कन्वर्शन टाइप के रूप में यू का उपयोग करते हुए सीटी में एक कन्वर्शन प्रक्रिया है, या
:सीयू के पास रूपांतरण टाइप के रूप में एक रूपांतरण क्वेरी लिस्टिंग टी है
:सीयू के पास कन्वर्शन टाइप के रूप में एक कन्वर्शन क्वेरी लिस्टिंग टी है
</ब्लॉककोट>
 
==== उदाहरण ====
==== उदाहरण ====


एफिल माइक्रोसॉफ्ट नेट फ्रेमवर्क के लिए पूरी तरह से अनुकूल भाषा है। नेट के विकास से पहले, एफिल के पास पहले से ही व्यापक श्रेणी के पुस्तकालय थे। नेट टाइप के पुस्तकालयों का उपयोग करना, विशेष रूप से सामान्यतः उपयोग किए जाने वाले टाइपों जैसे स्ट्रिंग्स के साथ, एक रूपांतरण समस्या उत्पन्न करता है। वर्तमान एफिल सॉफ्टवेयर एफिल लाइब्रेरी से स्ट्रिंग क्लासेस (जैसे <कोड लैंग= एफिल >STRING_8) का उपयोग करता है, लेकिन नेट के लिए लिखे गए एफिल सॉफ्टवेयर को नेट स्ट्रिंग क्लास (<code lang= eiffel >System. String</code>) का उपयोग करना चाहिए, उदाहरण के लिए नेट विधियों को कॉल करते समय जो आइटम की अपेक्षा करते हैं। युक्ति के रूप में पास किए जाने वाले नेट टाइप के हैं। । इसलिए, इन टाइपों का आगे और पीछे रूपांतरण जितना संभव हो उतना निर्बाध होना चाहिए।
एफिल माइक्रोसॉफ्ट नेट फ्रेमवर्क के लिए पूरी तरह से अनुकूल भाषा है। नेट के विकास से पहले, एफिल के पास पहले से ही व्यापक श्रेणी के पुस्तकालय थे। नेट टाइप के पुस्तकालयों का उपयोग करना, विशेष रूप से सामान्यतः उपयोग किए जाने वाले टाइपों जैसे स्ट्रिंग्स के साथ, एक कन्वर्शन समस्या उत्पन्न करता है। वर्तमान एफिल सॉफ्टवेयर एफिल लाइब्रेरी से स्ट्रिंग क्लासेस (जैसे <कोड लैंग= एफिल >STRING_8) का उपयोग करता है, लेकिन नेट के लिए लिखे गए एफिल सॉफ्टवेयर को नेट स्ट्रिंग क्लास (<code lang= eiffel >System. String</code>) का उपयोग करना चाहिए, उदाहरण के लिए नेट विधियों को कॉल करते समय जो आइटम की अपेक्षा करते हैं। युक्ति के रूप में पास किए जाने वाले नेट टाइप के हैं। । इसलिए, इन टाइपों का आगे और पीछे कन्वर्शन जितना संभव हो उतना निर्बाध होना चाहिए। <syntaxhighlight lang="c#">
  my_string: STRING_8 -- नेटिव एफिल स्ट्रिंग
    my_string: STRING_8                 -- Native Eiffel string
  my_system_string: SYSTEM_STRING -- नेटिव .NET स्ट्रिंग
    my_system_string: SYSTEM_STRING     -- Native .NET string


  ...
        ...


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


उपरोक्त कोड में, दो स्ट्रिंग घोषित किए गए हैं, प्रत्येक भिन्न टाइप में से एक (<code lang= eiffel >SYSTEM_STRING</code> System.String के लिए एफिल संगत उपनाम है)। चूँकि <code lang= eiffel>System.String</code> <code lang= eiffel>STRING_8</code> के अनुरूप नहीं है, तो उपरोक्त असाइनमेंट केवल तभी मान्य है जब <code lang= eiffel>System.String</code> > <code lang= eiffel >STRING_8</code> में परिवर्तित हो।
एफिल क्लास <code lang= eiffel >STRING_8</code> में <code lang= eiffel>System.String</code> टाइप के ऑब्जेक्ट के लिए <code lang= eiffel>make_from_cil</code> कन्वर्शन प्रक्रिया है। कन्वर्शन प्रक्रियाओं को भी हमेशा निर्माण प्रक्रियाओं (निर्माणकर्ताओं के समान) के रूप में निर्दिष्ट किया जाता है। निम्नलिखित <code lang= eiffel >STRING_8</code> वर्ग का अंश है:<syntaxhighlight lang="eiffel">
  class STRING_8
        ...
    create
        make_from_cil
        ...
    convert
        make_from_cil ({SYSTEM_STRING})
        ...
</syntaxhighlight>कन्वर्शन प्रक्रिया की उपस्थिति असाइनमेंट बनाती है:<syntaxhighlight lang="eiffel">
my_string := my_system_string
</syntaxhighlight>शब्दार्थ के बराबर:<syntaxhighlight lang="eiffel">
create my_string.make_from_cil (my_system_string)
</syntaxhighlight>जिसमें <code lang= eiffel>my_string को</code><code lang= eiffel>my_system_string</code><code lang="eiffel">के समतुल्य सामग्री के साथ</code> <code lang="eiffel">STRING_8</code> टाइप की एक नई सामग्री के रूप में बनाया गया है।


एफिल क्लास <code lang= eiffel >STRING_8</code> में <code lang= eiffel>System.String</code> टाइप के ऑब्जेक्ट के लिए <code lang= eiffel>make_from_cil</code> रूपांतरण प्रक्रिया है। रूपांतरण प्रक्रियाओं को भी हमेशा निर्माण प्रक्रियाओं (निर्माणकर्ताओं के समान) के रूप में निर्दिष्ट किया जाता है। निम्नलिखित <code lang= eiffel >STRING_8</code> वर्ग का अंश है:
मूल स्रोत और लक्ष्य उलटे हुए असाइनमेंट को संभालने के लिए:<syntaxhighlight lang="eiffel">
my_system_string := my_string
</syntaxhighlight>क्लास <code lang= eiffel >STRING_8</code> में एक कनवर्ज़न क्वेरी <code lang= eiffel >to_cil</code> भी सम्मलित है जो<code lang="eiffel">STRING_8</code> के उदाहरण से एक <code lang= eiffel>System.String</code> उत्पन्न करेगी।


<वाक्यविन्यास लैंग = एफिल>
<कोड लैंग= एफिल >STRING_8.<syntaxhighlight lang="eiffel">
  कक्षा STRING_8
class STRING_8
  ...
        ...
  बनाएं
    create
  make_from_cil
        make_from_cil
  ...
        ...
  बदलना
    convert
  make_from_cil ({SYSTEM_STRING})
        make_from_cil ({SYSTEM_STRING})
  ...
        to_cil: {SYSTEM_STRING}
</वाक्यविन्यास हाइलाइट>
        ...
 
</syntaxhighlight>सौंपा गया काम:<syntaxhighlight lang="eiffel">
रूपांतरण प्रक्रिया की उपस्थिति असाइनमेंट बनाती है:
my_system_string := my_string
 
</syntaxhighlight>फिर, इसके बराबर हो जाता है:<syntaxhighlight lang="eiffel">
<वाक्यविन्यास लैंग = एफिल>
my_system_string := my_string.to_cil
  my_string: = my_system_string
</syntaxhighlight>एफिल में, टाइप कन्वर्शन के लिए सेटअप वर्ग कोड में सम्मलित है, लेकिन फिर क्लाइंट कोड में स्पष्ट टाइप के कन्वर्शन के रूप में स्वचालित रूप से होने लगता है। इसमें केवल असाइनमेंट ही नहीं बल्कि अन्य टाइप के अटैचमेंट भी सम्मलित हैं, जैसे तर्क (पैरामीटर) प्रतिस्थापन।
</वाक्यविन्यास हाइलाइट>
 
शब्दार्थ के बराबर:
 
<वाक्यविन्यास लैंग = एफिल>
  my_string.make_from_cil (my_system_string) बनाएं
</वाक्यविन्यास हाइलाइट>
 
जिसमें <code lang= eiffel>my_string को</code><code lang= eiffel>my_system_string</code><code lang="eiffel">के समतुल्य सामग्री के साथ</code> <code lang="eiffel">STRING_8</code> टाइप की एक नई सामग्री के रूप में बनाया गया है।
 
मूल स्रोत और लक्ष्य उलटे हुए असाइनमेंट को संभालने के लिए:
 
<वाक्यविन्यास लैंग = एफिल>
  my_system_string := my_string
</वाक्यविन्यास हाइलाइट>
 
क्लास <code lang= eiffel >STRING_8</code> में एक कनवर्ज़न क्वेरी <code lang= eiffel >to_cil</code> भी सम्मलित है जो STRING_8 के उदाहरण से एक <code lang= eiffel>System.String</code> उत्पन्न करेगी।
 
<कोड लैंग= एफिल >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
</वाक्यविन्यास हाइलाइट>
 
एफिल में, टाइप रूपांतरण के लिए सेटअप वर्ग कोड में सम्मलित है, लेकिन फिर क्लाइंट कोड में स्पष्ट टाइप के रूपांतरण के रूप में स्वचालित रूप से होने लगता है। इसमें केवल असाइनमेंट ही नहीं बल्कि अन्य टाइप के अटैचमेंट भी सम्मलित हैं, जैसे तर्क (पैरामीटर) प्रतिस्थापन।


=== जंग ===
=== जंग ===
[[जंग (प्रोग्रामिंग भाषा)]] आदिम टाइपों के बीच कोई अंतर्निहित टाइप रूपांतरण (नियंत्रण) प्रदान नहीं करता है। लेकिन, as कीवर्ड का उपयोग करके स्पष्ट टाइप रूपांतरण (कास्टिंग) किया जा सकता है।<ref>{{cite web |title=Casting - Rust By Example |url=https://doc.rust-lang.org/rust-by-example/types/cast.html |website=doc.rust-lang.org}}</ref>
[[जंग (प्रोग्रामिंग भाषा)]] प्राचीन टाइपों के बीच कोई अंतर्निहित टाइप कन्वर्शन (नियंत्रण) प्रदान नहीं करता है। लेकिन, as कीवर्ड का उपयोग करके स्पष्ट टाइप कन्वर्शन (कास्टिंग) किया जा सकता है।<ref>{{cite web |title=Casting - Rust By Example |url=https://doc.rust-lang.org/rust-by-example/types/cast.html |website=doc.rust-lang.org}}</ref><syntaxhighlight lang="eiffel">
 
println!("1000 as a u16 is: {}", 1000 as u16);
<वाक्यविन्यास प्रकाश लैंग = जंग>
</syntaxhighlight>
println! (1000 एक u16 के रूप में है: {}, 1000 u16 के रूप में);
 
</वाक्यविन्यास हाइलाइट>


== सुरक्षा मुद्दे ==
== सुरक्षा मुद्दे ==
[[हैकर (कंप्यूटर सुरक्षा)]] में,टाइपकास्टिंग टाइप रूपांतरण का दुरुपयोग है जो अस्थायी रूप से [[चर (कंप्यूटर विज्ञान)]] के डेटा टाइप को मूल रूप से परिभाषित करने के तरीके से बदल देता है।<ref>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 ..."</ref> यह हैकर्स के लिए अवसर प्रदान करता है क्योंकि एक भिन्न डेटा टाइप बनने के लिए एक चर "टाइपकास्ट" होने के बाद टाइप रूपांतरण में, संकलक उस हैक किए गए चर को उस विशिष्ट ऑपरेशन के लिए नए डेटा टाइप के रूप में मानेगा।<ref>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 ..."</ref>
[[हैकर (कंप्यूटर सुरक्षा)]] में,टाइपकास्टिंग टाइप कन्वर्शन का दुरुपयोग है जो अस्थायी रूप से [[चर (कंप्यूटर विज्ञान)]] के डेटा टाइप को मूल रूप से परिभाषित करने के तरीके से बदल देता है।<ref>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 ..."</ref> यह हैकर्स के लिए अवसर प्रदान करता है क्योंकि एक भिन्न डेटा टाइप बनने के लिए एक चर "टाइपकास्ट" होने के बाद टाइप कन्वर्शन में, संकलक उस हैक किए गए चर को उस विशिष्ट ऑपरेशन के लिए नए डेटा टाइप के रूप में मानेगा।<ref>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 ..."</ref>
 
 
== यह भी देखें ==
== यह भी देखें ==
* डाउनकास्टिंग
* डाउनकास्टिंग
Line 221: Line 187:


== बाहरी संबंध ==
== बाहरी संबंध ==
* [http://www.adapower.com/index.php?Command=Class&ClassID=FAQ&CID=354 Casting in Ada]
* [http://www.adapower.com/index.php?Command=Class&ClassID=FAQ&CID=354 एडा में कास्टिंग]
* [[Wikibooks:C++ Programming/Programming Languages/C++/Code/Statements/Variables/Type Casting|Casting in C++]]
* [[Wikibooks:C++ Programming/Programming Languages/C++/Code/Statements/Variables/Type Casting|सी ++ में कास्टिंग]]
* [https://web.archive.org/web/20160709112746/http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=285 C++ Reference Guide] Why I hate C++ Cast Operators, by Danny Kalev
* [https://web.archive.org/web/20160709112746/http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=285 सी ++ संदर्भ गाइड] मुझे डैनी कालेव द्वारा C++ कास्ट ऑपरेटर्स से द्वेष क्यों है
* [https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.5 Casting in Java]
* [https://docs.oracle.com/javase/specs/jls/se7/html/jls-5.html#jls-5.5 जावा में कास्टिंग]
* [http://msdn.microsoft.com/en-us/library/aa691280(v=vs.71).aspx Implicit Conversions in C#]
* [http://msdn.microsoft.com/en-us/library/aa691280(v=vs.71).aspx सी # में अंतर्निहित कन्वर्शन]
* [http://cppreference.com/wiki/language/implicit_cast Implicit Type Casting at Cppreference.com]
* [http://cppreference.com/wiki/language/implicit_cast Cppreference.com पर इंप्लिसिट टाइप कास्टिंग]
* [http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/BitOp/cast.html Static and Reinterpretation castings in C++]
* [http://www.cs.umd.edu/class/sum2003/cmsc311/Notes/BitOp/cast.html सी ++ में स्टेटिक और रीइंटरप्रिटेशन कास्टिंग]
* [[Wikibooks:F Sharp Programming/Inheritance#Up-casting and Down-casting|Upcasting and Downcasting in F#]]
* [[Wikibooks:F Sharp Programming/Inheritance#Up-casting and Down-casting|F# में अपकास्टिंग और डाउनकास्टिंग]]
 
{{Data types}}
 
{{DEFAULTSORT:Type Conversion}}[[Category: डेटा के प्रकार]] [[Category: ऑपरेटर्स (प्रोग्रामिंग)]] [[Category: प्रकार सिद्धांत]] [[Category: एकात्मक संचालन]]
 


{{DEFAULTSORT:Type Conversion}}


[[Category: Machine Translated Page]]
[[Category:Articles with example C code|Type Conversion]]
[[Category:Created On 16/02/2023]]
[[Category:Collapse templates|Type Conversion]]
[[Category:Created On 16/02/2023|Type Conversion]]
[[Category:Lua-based templates|Type Conversion]]
[[Category:Machine Translated Page|Type Conversion]]
[[Category:Navigational boxes| ]]
[[Category:Navigational boxes without horizontal lists|Type Conversion]]
[[Category:Pages with script errors|Type Conversion]]
[[Category:Short description with empty Wikidata description|Type Conversion]]
[[Category:Sidebars with styles needing conversion|Type Conversion]]
[[Category:Template documentation pages|Documentation/doc]]
[[Category:Templates Vigyan Ready|Type Conversion]]
[[Category:Templates generating microformats|Type Conversion]]
[[Category:Templates that add a tracking category|Type Conversion]]
[[Category:Templates that are not mobile friendly|Type Conversion]]
[[Category:Templates that generate short descriptions|Type Conversion]]
[[Category:Templates using TemplateData|Type Conversion]]
[[Category:Wikipedia metatemplates|Type Conversion]]
[[Category:एकात्मक संचालन|Type Conversion]]
[[Category:ऑपरेटर्स (प्रोग्रामिंग)|Type Conversion]]
[[Category:डेटा के प्रकार|Type Conversion]]
[[Category:प्रकार सिद्धांत|Type Conversion]]

Latest revision as of 17:25, 12 September 2023

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

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

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

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

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

भाषा तुलना

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

अंतर्निहित टाइप कन्वर्शन

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

double  d;
long    l;
int     i;

if (d > i)   d = i;
if (i > l)   l = i;
if (d == l)  d *= 2;


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

#include <stdio.h>

int main(void)
{
    int i_value   = 16777217;
    float f_value = 16777216.0;
    printf("The integer is: %d\n", i_value);
    printf("The float is:   %f\n", f_value);
    printf("Their equality: %d\n", i_value == f_value);
}

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

The integer is: 16777217
The float is: 16777216.000000
Their equality: 1

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

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

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

टाइप प्रमोशन

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

जावा (प्रोग्रामिंग भाषा) में: 

int x = 3;
double y = 3.5;
System.out.println(x + y); // The output will be 6.5

स्पष्ट प्रकार कन्वर्शन

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

double da = 3.3;
double db = 3.3;
double dc = 3.4;
int result = (int)da + (int)db + (int)dc; // result == 9
// if implicit conversion would be used (as with "result = da + db + dc"), result would be equal to 10

कई प्रकार के स्पष्ट कन्वर्शन हैं।

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

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

सी # और सी ++

सी शार्प (प्रोग्रामिंग लैंग्वेज) C# में, टाइप कन्वर्शन सुरक्षित या असुरक्षित (यानी, सी-लाइक) विधि से किया जा सकता है, पहले वाले को चेक्ड टाइप कास्ट कहा जाता है।[8]

Animal animal = new Cat();

Bulldog b = (Bulldog) animal;  // if (animal is Bulldog), stat.type(animal) is Bulldog, else an exception
b = animal as Bulldog;         // if (animal is Bulldog), b = (Bulldog) animal, else b = null

animal = null;
b = animal as Bulldog;         // b == null

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

Animal* animal = new Cat;

Bulldog* b = static_cast<Bulldog*>(animal); // compiles only if either Animal or Bulldog is derived from the other (or same)
b = dynamic_cast<Bulldog*>(animal);         // if (animal is Bulldog), b = (Bulldog*) animal, else b = nullptr

Bulldog& br = static_cast<Bulldog&>(*animal); // same as above, but an exception will be thrown if a nullptr was to be returned
                                              // this is not seen in code where exception handling is avoided
animal = nullptr;
b = dynamic_cast<Bulldog*>(animal);         // b == nullptr

delete animal; // always free resources

एफिल

एफिल (प्रोग्रामिंग लैंग्वेज) में टाइप कन्वर्शन की धारणा को टाइप सिस्टम के नियमों में एकीकृत किया गया है। असाइनमेंट नियम कहता है कि एक असाइनमेंट, जैसे कि:

x := y

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

एफिल में टाइप कन्वर्शन की परिभाषा

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

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

कन्वर्शन टाइप के रूप में यू का उपयोग करते हुए सीटी में एक कन्वर्शन प्रक्रिया है, या
सीयू के पास कन्वर्शन टाइप के रूप में एक कन्वर्शन क्वेरी लिस्टिंग टी है

उदाहरण

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

    my_string: STRING_8                 -- Native Eiffel string
    my_system_string: SYSTEM_STRING     -- Native .NET string

        ...

            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 वर्ग का अंश है:

  class STRING_8
        ...
    create
        make_from_cil
        ...
    convert
        make_from_cil ({SYSTEM_STRING})
        ...

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

my_string := my_system_string

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

create my_string.make_from_cil (my_system_string)

जिसमें my_string कोmy_system_stringके समतुल्य सामग्री के साथ STRING_8 टाइप की एक नई सामग्री के रूप में बनाया गया है। मूल स्रोत और लक्ष्य उलटे हुए असाइनमेंट को संभालने के लिए:

 my_system_string := my_string

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

 class STRING_8
        ...
    create
        make_from_cil
        ...
    convert
        make_from_cil ({SYSTEM_STRING})
        to_cil: {SYSTEM_STRING}
        ...

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

my_system_string := my_string

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

 my_system_string := my_string.to_cil

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

जंग

जंग (प्रोग्रामिंग भाषा) प्राचीन टाइपों के बीच कोई अंतर्निहित टाइप कन्वर्शन (नियंत्रण) प्रदान नहीं करता है। लेकिन, as कीवर्ड का उपयोग करके स्पष्ट टाइप कन्वर्शन (कास्टिंग) किया जा सकता है।[9]

println!("1000 as a u16 is: {}", 1000 as u16);

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

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

यह भी देखें

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

संदर्भ

  1. ↑ 1.0 1.1 1.2 Mehrotra, Dheeraj (2008). S. Chand's Computer Science. pp. 81–83. ISBN 978-8121929844.
  2. ↑ Programming Languages - Design and Constructs. 2013. p. 35. ISBN 978-9381159415.
  3. ↑ 3.0 3.1 Reilly, Edwin (2004). Concise Encyclopedia of Computer Science. pp. 82, 110. ISBN 0470090952.
  4. ↑ Fenton, Steve (2017). Pro TypeScript: Application-Scale JavaScript Development. pp. xxiii. ISBN 978-1484232491.
  5. ↑ "PHP: Type Juggling - Manual". php.net. Retrieved 2019-01-27.
  6. ↑ 6.0 6.1 Olsson, Mikael (2013). C++ Quick Syntax Reference. pp. 87–89. ISBN 978-1430262770.
  7. ↑ 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=256977’