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

From Vigyanwiki
No edit summary
No edit summary
 
(123 intermediate revisions by 6 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}}
{{for|the aviation licensing process|Type conversion (aviation)}}
[[कंप्यूटर विज्ञान]] में, '''टाइप कन्वर्शन''',<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> सामान्यतः [[आदिम डेटा प्रकार|आदिम डेटा टाइप]] और [[यौगिक डेटा प्रकार|यौगिक डेटा टाइप]] दोनों को परिवर्तित किया जा सकता है।
{{for multi|metal casting|Casting (metalworking)#Upcasting}}
{{multiple issues|
{{More citations needed|date=May 2011}}
{{original research|date=May 2018}}
}}
[[कंप्यूटर विज्ञान]] में, प्रकार रूपांतरण,<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" /><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" /> सामान्य तौर पर, [[आदिम डेटा प्रकार]] और [[यौगिक डेटा प्रकार]] दोनों को परिवर्तित किया जा सकता है।
प्रत्येक [[प्रोग्रामिंग भाषा]] के अपने नियम होते हैं कि कैसे टाइपों को परिवर्तित किया जा सकता है। [[मजबूत टाइपिंग]] वाली भाषाएं सामान्यतः बहुत कम निहित कन्वर्शन करती हैं और अभ्यावेदन की पुनर्व्याख्या को हतोत्साहित करती हैं, जबकि [[कमजोर टाइपिंग]] वाली भाषाएं डेटा टाइपों के बीच कई अंतर्निहित कन्वर्शन करती हैं। कमजोर टाइपिंग भाषाएं अधिकांशतः [[संकलक]] को अलग-अलग प्रतिनिधित्व वाले डेटा कार्यक्रम की मनमाने ढंग से व्याख्या करने के लिए विवश करती है - यह एक गैर-स्पष्ट प्रोग्रामिंग त्रुटि हो सकती है, या अंतर्निहित हार्डवेयर से सीधे निपटने के लिए एक तकनीकी विधि हो सकती है।


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


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


अधिकतर भाषाओं में, ज़बरदस्ती शब्द का उपयोग एक निहित रूपांतरण को दर्शाने के लिए किया जाता है, या तो संकलन के दौरान या [[रन टाइम (कार्यक्रम जीवनचक्र चरण)]] के दौरान। उदाहरण के लिए, पूर्णांक और फ्लोटिंग पॉइंट नंबरों (जैसे 5 + 0.1) को मिलाकर एक अभिव्यक्ति में, संकलक स्वचालित रूप से पूर्णांक प्रतिनिधित्व को फ्लोटिंग पॉइंट प्रतिनिधित्व में बदल देगा ताकि अंश खो न जाएं।स्पष्ट प्रकार के रूपांतरण या तो अतिरिक्त कोड लिखकर संकेतित होते हैं (उदाहरण के लिए टाइप आइडेंटिफ़ायर जोड़ना या बिल्ट-इन [[सबरूटीन]] रूटीन को कॉल करना) या कंपाइलर के उपयोग के लिए कोडिंग रूपांतरण रूटीन द्वारा जब यह अन्यथा किसी प्रकार के बेमेल के साथ रुक जाएगा।
भाषाओं के सी परिवार और [[Index.php?title=अल्गोल 68|अल्गोल 68]] में, कास्ट शब्द सामान्यतः एक स्पष्ट टाइप के कन्वर्शन (एक अंतर्निहित कन्वर्शन के विपरीत) को संदर्भित करता है, जिससे कुछ अस्पष्टता पैदा होती है कि क्या यह बिट-पैटर्न या वास्तविक डेटा प्रतिनिधित्व कन्वर्शन की पुन: व्याख्या है। अधिक महत्वपूर्ण, युक्ति और नियमों का समूह है जो एक सूचक द्वारा स्थित डेटा टाइप (या कक्षा) पर लागू होता है और वस्तु (वर्ग) उत्तराधिकार जैसे मामलों में अनुभाषक द्वारा सूचक को कैसे समायोजित किया जा सकता है।
 
अधिकांश भाषाओं में, ज़बरदस्ती शब्द का उपयोग एक निहित रूपांतरण को दर्शाने के लिए किया जाता है, या तो संकलन के दौरान या [[रन टाइम (कार्यक्रम जीवनचक्र चरण)]] के दौरान। उदाहरण के लिए, पूर्णांक और फ्लोटिंग पॉइंट नंबरों (जैसे 5 + 0.1) को मिलाकर एक अभिव्यक्ति में, कंपाइलर स्वचालित रूप से पूर्णांक प्रतिनिधित्व को फ्लोटिंग पॉइंट प्रतिनिधित्व में बदल देगा ताकि अंश खो न जाएं। स्पष्ट प्रकार के रूपांतरण या तो अतिरिक्त कोड लिखकर संकेतित होते हैं (उदाहरण के लिए टाइप आइडेंटिफ़ायर जोड़ना या बिल्ट-इन [[सबरूटीन]] को कॉल करना) या कंपाइलर के उपयोग के लिए रूपांतरण रूटीन कोडिंग द्वारा जब यह अन्यथा किसी प्रकार के बेमेल के साथ रुक जाएगा।
 
अधिकांश [[ALGOL]] जैसी भाषाओं में, जैसे [[पास्कल (प्रोग्रामिंग भाषा)]], [[मॉड्यूल-2]], [[एडा (प्रोग्रामिंग भाषा)]] और [[डेल्फी (प्रोग्रामिंग भाषा)]], रूपांतरण और कास्टिंग विशिष्ट रूप से भिन्न अवधारणाएँ हैं। इन भाषाओं में, रूपांतरण या तो निहित रूप से या स्पष्ट रूप से एक डेटा प्रकार के भंडारण प्रारूप से दूसरे में मान को बदलने के लिए संदर्भित करता है, उदा। एक 16-बिट पूर्णांक से 32-बिट पूर्णांक। रूपांतरण के परिणामस्वरूप भंडारण की जरूरतें बदल सकती हैं, जिसमें परिशुद्धता या ट्रंकेशन का संभावित नुकसान भी शामिल है। दूसरी ओर, कास्ट शब्द, एक प्रकार से दूसरे प्रकार के मूल्य का प्रतिनिधित्व करने वाले बिट पैटर्न की व्याख्या को स्पष्ट रूप से बदलने को संदर्भित करता है। उदाहरण के लिए, 32 सन्निहित बिट्स को 32 बूलियन्स की एक सरणी, एक 4-बाइट स्ट्रिंग, एक अहस्ताक्षरित 32-बिट पूर्णांक या एक IEEE एकल सटीक फ़्लोटिंग पॉइंट मान के रूप में माना जा सकता है। क्योंकि संग्रहीत बिट्स कभी नहीं बदले जाते हैं, प्रोग्रामर को अर्थपूर्ण रूप से कास्ट करने के लिए निम्न स्तर के विवरण जैसे प्रतिनिधित्व प्रारूप, बाइट ऑर्डर और संरेखण आवश्यकताओं को जानना चाहिए।
 
भाषाओं के सी परिवार और [[ALGOL 68]] में, कास्ट शब्द आमतौर पर एक स्पष्ट प्रकार के रूपांतरण (एक अंतर्निहित रूपांतरण के विपरीत) को संदर्भित करता है, जिससे कुछ अस्पष्टता पैदा होती है कि क्या यह बिट-पैटर्न या वास्तविक डेटा प्रतिनिधित्व की पुन: व्याख्या है रूपांतरण। अधिक महत्वपूर्ण तरीकों और नियमों की भीड़ है जो एक सूचक द्वारा स्थित डेटा प्रकार (या कक्षा) पर लागू होती है और वस्तु (वर्ग) विरासत जैसे मामलों में कंपाइलर द्वारा सूचक को कैसे समायोजित किया जा सकता है।


== भाषा तुलना ==
== भाषा तुलना ==
Line 26: 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;
int मैं;
</syntaxhighlight>


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


यद्यपि {{mono|'''d'''}}, {{mono|'''l'''}}, और {{mono|'''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;
     int i_value   = 16777217;
     फ्लोट f_value = 16777216.0;
     float f_value = 16777216.0;
     प्रिंटफ (पूर्णांक है:% d \ n, i_value);
     printf("The integer is: %d\n", i_value);
     प्रिंटफ (फ्लोट है:% f \ n, f_value);
     printf("The float is:   %f\n", f_value);
     प्रिंटफ (उनकी समानता:% d \ n, i_value == f_value);
     printf("Their equality: %d\n", i_value == f_value);
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>


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


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


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


महत्वपूर्ण टेकअवे:
महत्वपूर्ण टेकअवे:
Line 68: Line 53:
# {{C-lang|float}} को {{C-lang|int}} [[काट-छांट]] का कारण बनता है, यानी आंशिक भाग को हटा देता है।
# {{C-lang|float}} को {{C-lang|int}} [[काट-छांट]] का कारण बनता है, यानी आंशिक भाग को हटा देता है।
# {{C-lang|double}} को {{C-lang|float}} अंक के पूर्णांकन का कारण बनता है।
# {{C-lang|double}} को {{C-lang|float}} अंक के पूर्णांकन का कारण बनता है।
# {{C-lang|long}} को {{C-lang|int}} अतिरिक्त उच्च क्रम बिट्स को छोड़ने का कारण बनता है।
# {{C-lang|long}} को {{C-lang|int}} अतिरिक्त उच्च क्रम बिट्स को छोड़ने का कारण बनता है।


==टाइप प्रमोशन ==
==टाइप प्रमोशन ==
निहित प्रकार के रूपांतरण का एक विशेष मामला प्रकार का प्रचार है, जहां एक वस्तु स्वचालित रूप से मूल प्रकार के [[सुपरसेट]] का प्रतिनिधित्व करने वाले दूसरे डेटा प्रकार में परिवर्तित हो जाती है। पदोन्नति आमतौर पर लक्ष्य प्लेटफॉर्म की [[अंकगणितीय तर्क इकाई]] (एएलयू) के मूल प्रकार से छोटे प्रकार के साथ अंकगणितीय और तार्किक संचालन से पहले, इस तरह के संचालन को संभव बनाने के लिए, या अधिक कुशल होने पर उपयोग किया जाता है यदि एएलयू एक से अधिक प्रकार के साथ काम कर सकता है। सी और सी ++ बूलियन, कैरेक्टर, वाइड कैरेक्टर, एन्यूमरेशन, और शॉर्ट इंटीजर टाइप्स के ऑब्जेक्ट्स के लिए ऐसे प्रमोशन करते हैं, जिन्हें इंट में प्रमोट किया जाता है, और टाइप फ्लोट के ऑब्जेक्ट्स के लिए, जिन्हें डबल के लिए प्रमोट किया जाता है। कुछ अन्य प्रकार के रूपांतरणों के विपरीत, प्रचार कभी भी सटीकता नहीं खोते हैं या वस्तु में संग्रहीत मूल्य को संशोधित नहीं करते हैं।
निहित टाइप के कन्वर्शन का एक विशेष उद्देश्य टाइप प्रमोशन है, जहां एक वस्तु स्वचालित रूप से मूल टाइप के [[सुपरसेट]] का प्रतिनिधित्व करने वाले दूसरे डेटा टाइप में परिवर्तित हो जाती है। लक्षित प्लेटफॉर्म की [[अंकगणितीय तर्क इकाई]] (एएलयू) के मूल टाइप से छोटे टाइप के साथ, अंकगणितीय और तार्किक संचालन से पहले, यदि एएलयू एक से अधिक टाइप के साथ काम कर सकता है तब इस तरह के संचालन को संभव बनाने के लिए, या अधिक कुशल होने पर टाइप प्रमोशन को सामान्यतः उपयोग किया जाता है। सी और सी ++ बूलियन, कैरेक्टर, वाइड कैरेक्टर, एन्यूमरेशन, और शॉर्ट इंटीजर टाइप्स के ऑब्जेक्ट्स के लिए ऐसे प्रमोशन करते हैं, जिन्हें इंट में प्रमोट किया जाता है, और टाइप फ्लोट के ऑब्जेक्ट्स के लिए, जिन्हें डबल के लिए प्रमोट किया जाता है। कुछ अन्य टाइप के कन्वर्शनों के विपरीत, प्रचार कभी भी सटीकता नहीं खोते हैं या वस्तु में संग्रहीत मूल्य को संशोधित नहीं करते हैं।
 
[[जावा (प्रोग्रामिंग भाषा)]] में:
<वाक्यविन्यास प्रकाश लैंग = जावा>
इंट एक्स = 3;
डबल वाई = 3.5;
System.out.println (x + y); // आउटपुट 6.5 होगा
</वाक्यविन्यास हाइलाइट>
 
==== स्पष्ट प्रकार रूपांतरण ====
स्पष्ट प्रकार का रूपांतरण, जिसे टाइप कास्टिंग भी कहा जाता है, एक प्रकार का रूपांतरण है जिसे एक प्रोग्राम के भीतर स्पष्ट रूप से परिभाषित किया जाता है (अंतर्निहित प्रकार के रूपांतरण के लिए भाषा के नियमों के अनुसार स्वचालित रूप से किए जाने के बजाय)। यह कार्यक्रम में उपयोगकर्ता द्वारा अनुरोध किया गया है।


<वाक्यविन्यास लैंग = सीपीपी>
[[जावा (प्रोग्रामिंग भाषा)]] में: <syntaxhighlight lang="java5">
डबल दा = 3.3;
int x = 3;
डबल डीबी = 3.3;
double y = 3.5;
डबल डीसी = 3.4;
System.out.println(x + y); // The output will be 6.5
int परिणाम = (int)da + (int)db + (int)dc; // परिणाम == 9
</syntaxhighlight>
// यदि अंतर्निहित रूपांतरण का उपयोग किया जाएगा (परिणाम = 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>कई प्रकार के स्पष्ट कन्वर्शन हैं।
; जाँच की गई: कन्वर्शन किए जाने से पहले, यह देखने के लिए एक रनटाइम जाँच की जाती है कि क्या गंतव्य टाइप स्रोत मान को धारण कर सकता है। यदि नहीं, तो एक त्रुटि स्थिति उठाई जाती है।
; अनियंत्रित: कोई जाँच नहीं की जाती है। यदि गंतव्य टाइप स्रोत मान नहीं रख सकता है, तो परिणाम अपरिभाषित है।
; बिट पैटर्न: स्रोत के अनिर्मित बिट प्रतिनिधित्व को शब्दशः कॉपी किया जाता है, और गंतव्य टाइप के अनुसार इसकी फिर से व्याख्या की जाती है। यह [[अलियासिंग (कंप्यूटिंग)]] के माध्यम से भी प्राप्त किया जा सकता है।


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


=== सी # और सी ++ ===
=== सी # और सी ++ ===
सी शार्प (प्रोग्रामिंग लैंग्वेज) | सी # में, टाइप रूपांतरण सुरक्षित या असुरक्षित (यानी, सी-लाइक) तरीके से किया जा सकता है, पूर्व में चेक्ड टाइप कास्ट कहा जाता है।<ref>
सी शार्प (प्रोग्रामिंग लैंग्वेज) C# में, टाइप कन्वर्शन सुरक्षित या असुरक्षित (यानी, सी-लाइक) विधि से किया जा सकता है, पहले वाले को चेक्ड टाइप कास्ट कहा जाता है।<ref>
{{cite web
{{cite web
| access-date = 4 August 2011
| access-date = 4 August 2011
Line 110: 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#">
<वाक्यविन्यास प्रकाश लैंग = csharp>
Animal animal = new Cat();
पशु पशु = नई बिल्ली ();
 
बुलडॉग बी = (बुलडॉग) जानवर; // अगर (पशु बुलडॉग है), stat.type(animal) बुलडॉग है, अन्यथा अपवाद
बी = जानवर बुलडॉग के रूप में; // अगर (जानवर बुलडॉग है), बी = (बुलडॉग) जानवर, और बी = शून्य


पशु = अशक्त;
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
</वाक्यविन्यास हाइलाइट>


[[C++]] में C++- स्टाइल कास्ट सिंटैक्स का उपयोग करके एक समान प्रभाव प्राप्त किया जा सकता है।
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> आधारित है।


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


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


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


         ...
         ...


             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> वर्ग का अंश है:
एफिल क्लास <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
<वाक्यविन्यास लैंग = एफिल>
    कक्षा STRING_8
         ...
         ...
     बनाएं
     create
         make_from_cil
         make_from_cil
         ...
         ...
     बदलना
     convert
         make_from_cil ({SYSTEM_STRING})
         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> टाइप की एक नई सामग्री के रूप में बनाया गया है।


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


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


== सुरक्षा मुद्दे ==
== सुरक्षा मुद्दे ==
[[हैकर (कंप्यूटर सुरक्षा)]] में, टाइपकास्टिंग एक [[चर (कंप्यूटर विज्ञान)]] के डेटा प्रकार को मूल रूप से परिभाषित करने के तरीके से अस्थायी रूप से बदलने के लिए प्रकार रूपांतरण का दुरुपयोग है।<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 250: 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’