टाइप कन्वर्शन

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

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

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

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

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

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

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

<वाक्यविन्यास प्रकाश लैंग = सी>

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

अगर (डी> मैं) डी = मैं; अगर (i> एल) एल = मैं; अगर (डी == एल) डी * = 2; 

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

<वाक्यविन्यास प्रकाश लैंग = सी>
 * 1) सम्मलित 

पूर्णांक मुख्य (शून्य) { int i_value = 16777217; फ्लोट f_value = 16777216.0;

प्रिंटफ (पूर्णांक है:% d \ n, i_value);

प्रिंटफ (फ्लोट है:% f \ n, f_value);

प्रिंटफ (उनकी समानता:% d \ n, i_value == f_value); } 

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

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

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

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


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

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

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

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

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

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

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

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

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

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

पशु = अशक्त; बी = जानवर बुलडॉग के रूप में; // बी == अशक्त 

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

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

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

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

जानवर को हटाओ; // हमेशा मुक्त संसाधन 

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

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

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

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



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



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

<वाक्यविन्यास लैंग = एफिल> my_string: STRING_8 -- नेटिव एफिल स्ट्रिंग my_system_string: SYSTEM_STRING -- नेटिव .NET स्ट्रिंग

...

my_string: = my_system_string 

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

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

<वाक्यविन्यास लैंग = एफिल> कक्षा STRING_8 ... बनाएं make_from_cil ... बदलना make_from_cil ({SYSTEM_STRING}) ... 

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

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

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

<वाक्यविन्यास लैंग = एफिल> my_string.make_from_cil (my_system_string) बनाएं 

जिसमें      टाइप की एक नई सामग्री के रूप में बनाया गया है।

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

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

क्लास  में एक कनवर्ज़न क्वेरी   भी सम्मलित है जो STRING_8 के उदाहरण से एक   उत्पन्न करेगी।

<कोड लैंग= एफिल >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 कीवर्ड का उपयोग करके स्पष्ट टाइप रूपांतरण (कास्टिंग) किया जा सकता है।

<वाक्यविन्यास प्रकाश लैंग = जंग> println! (1000 एक u16 के रूप में है: {}, 1000 u16 के रूप में); </वाक्यविन्यास हाइलाइट>

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

यह भी देखें

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

बाहरी संबंध

 * Casting in Ada
 * Casting in C++
 * C++ Reference Guide Why I hate C++ Cast Operators, by Danny Kalev
 * Casting in Java
 * Implicit Conversions in C#
 * Implicit Type Casting at Cppreference.com
 * Static and Reinterpretation castings in C++
 * Upcasting and Downcasting in F#