टाइप सेफ्टी

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

प्रकार प्रवर्तन स्थिर हो सकता है, संकलन समय पर संभावित त्रुटियों को पकड़ना, या गतिशील, प्रकार की जानकारी को रन टाइम (प्रोग्राम जीवनचक्र चरण) | रन-टाइम पर मूल्यों के साथ जोड़ना और आसन्न त्रुटियों का पता लगाने के लिए आवश्यकतानुसार परामर्श करना या दोनों का संयोजन। गतिशील प्रकार प्रवर्तन अक्सर उन प्रोग्रामों को चलाने की अनुमति देता है जो स्थिर प्रवर्तन के तहत अमान्य होंगे।

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

परिभाषाएँ

सहज रूप से, टाइप साउंडनेस रॉबिन मिलनर के सारगर्भित कथन द्वारा पकड़ी गई है

अच्छी तरह से टाइप किए गए प्रोग्राम गलत नहीं हो सकते।

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

एक भाषा प्रकार-सुरक्षित है यदि भाषा में डेटा पर किए जा सकने वाले एकमात्र ऑपरेशन डेटा के प्रकार द्वारा स्वीकृत हैं।

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

प्रगति

एक अच्छी तरह से टाइप किया गया प्रोग्राम कभी अटकता नहीं है: प्रत्येक अभिव्यक्ति (कंप्यूटर विज्ञान) या तो पहले से ही एक मूल्य (कंप्यूटर विज्ञान) है या किसी अच्छी तरह से परिभाषित तरीके से मूल्य की ओर कम किया जा सकता है। दूसरे शब्दों में, कार्यक्रम कभी भी एक अपरिभाषित स्थिति में नहीं आता है जहां कोई और बदलाव संभव नहीं है।

संरक्षण (या विषय में कमी)

प्रत्येक मूल्यांकन चरण के बाद, प्रत्येक अभिव्यक्ति का प्रकार समान रहता है (अर्थात, इसका प्रकार संरक्षित है)।

सांकेतिक शब्दार्थ और संरचनात्मक परिचालन शब्दार्थ के संदर्भ में टाइप साउंडनेस के कई अन्य औपचारिक उपचार भी प्रकाशित किए गए हैं।

सुरक्षा के अन्य रूपों से संबंध

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

• अवैध संचालन की रोकथाम। उदाहरण के लिए, एक प्रकार प्रणाली अभिव्यक्ति को अस्वीकार कर सकती है 3 / "Hello, World" अमान्य के रूप में, क्योंकि डिवीजन ऑपरेटर (कंप्यूटर प्रोग्रामिंग) को एक स्ट्रिंग (कंप्यूटर विज्ञान) विभाजक के लिए परिभाषित नहीं किया गया है।
• स्मृति सुरक्षा
  • टाइप सिस्टम जंगली सूचक ्स को रोक सकता है जो अन्यथा पॉइंटर से एक प्रकार की वस्तु को दूसरे प्रकार के पॉइंटर के रूप में माना जा सकता है।
  • अधिक परिष्कृत प्रकार की प्रणालियाँ, जैसे कि आश्रित प्रकार का समर्थन करने वाले, संभावित बफ़र अधिकता को रोकते हुए, आउट-ऑफ़-बाउंड एक्सेस का पता लगा सकते हैं और अस्वीकार कर सकते हैं।
• विभिन्न प्रकार के शब्दार्थों में उत्पन्न होने वाली तर्क त्रुटियाँ। उदाहरण के लिए, इंच और मिलीमीटर दोनों को पूर्णांक के रूप में संग्रहीत किया जा सकता है, लेकिन एक दूसरे के लिए प्रतिस्थापित या जोड़ा नहीं जाना चाहिए। एक प्रकार की प्रणाली उनके लिए दो अलग-अलग प्रकार के पूर्णांक लागू कर सकती है।

प्रकार-सुरक्षित और प्रकार-असुरक्षित भाषाएँ

अकादमिक प्रोग्रामिंग भाषा अनुसंधान में प्रस्तावित किसी भी खिलौना भाषा (यानी गूढ़ भाषा) के लिए प्रकार की सुरक्षा आमतौर पर एक आवश्यकता है। दूसरी ओर, कई भाषाएँ मानव-निर्मित प्रकार के सुरक्षा प्रमाणों के लिए बहुत बड़ी हैं, क्योंकि उन्हें अक्सर हजारों मामलों की जाँच करने की आवश्यकता होती है। फिर भी, कुछ भाषाएँ जैसे कि मानक एमएल, जिसमें शब्दार्थ को कड़ाई से परिभाषित किया गया है, एक प्रकार की सुरक्षा की परिभाषा को पूरा करने के लिए सिद्ध हुई हैं। कुछ अन्य भाषाओं जैसे हास्केल (प्रोग्रामिंग भाषा) को माना जाता है प्रकार की सुरक्षा की कुछ परिभाषा को पूरा करने के लिए, बशर्ते कि कुछ एस्केप सुविधाओं का उपयोग न किया जाए (उदाहरण के लिए Haskell's unsafePerformIO, सामान्य प्रतिबंधित वातावरण से बचने के लिए उपयोग किया जाता है जिसमें I/O संभव है, टाइप सिस्टम को दरकिनार करता है और इसलिए इसका उपयोग टाइप सुरक्षा को तोड़ने के लिए किया जा सकता है।) पनिंग टाइप करें इस तरह के एस्केप फीचर का एक और उदाहरण है। भाषा परिभाषा के गुणों के बावजूद, रन टाइम (कार्यक्रम जीवनचक्र चरण) पर कुछ त्रुटियां हो सकती हैं। कार्यान्वयन में बग के कारण रन-टाइम, या अन्य भाषाओं में लिखी गई लिंक्ड पुस्तकालय (कंप्यूटर विज्ञान) में; ऐसी त्रुटियां कुछ परिस्थितियों में दिए गए कार्यान्वयन प्रकार को असुरक्षित बना सकती हैं। सन की जावा वर्चुअल मशीन का प्रारंभिक संस्करण इस प्रकार की समस्या के प्रति संवेदनशील था।

मजबूत और कमजोर टाइपिंग

Main article: Strong and weak typing

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

स्मृति प्रबंधन और प्रकार की सुरक्षा

प्रकार की सुरक्षा स्मृति सुरक्षा से निकटता से जुड़ी हुई है। उदाहरण के लिए, किसी भाषा के कार्यान्वयन में जिसका कोई प्रकार है $t$ जो कुछ बिट पैटर्न की अनुमति देता है लेकिन दूसरों की नहीं, एक लटकने वाला सूचक मेमोरी एरर थोड़ा पैटर्न लिखने की अनुमति देता है जो एक वैध सदस्य का प्रतिनिधित्व नहीं करता है $t$ प्रकार के एक मृत चर (प्रोग्रामिंग) में $t$, जब चर पढ़ा जाता है तो एक प्रकार की त्रुटि उत्पन्न होती है। इसके विपरीत, यदि भाषा मेमोरी-सुरक्षित है, तो यह एक मनमाना पूर्णांक को सूचक (कंप्यूटर प्रोग्रामिंग) के रूप में उपयोग करने की अनुमति नहीं दे सकती है, इसलिए एक अलग सूचक या संदर्भ प्रकार होना चाहिए।

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

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

वस्तु उन्मुख भाषाओं में टाइप सुरक्षा

वस्तु उन्मुख भाषाओं में प्रकार की सुरक्षा आमतौर पर इस तथ्य में आंतरिक होती है कि एक प्रकार की प्रणाली मौजूद है। यह वर्ग परिभाषाओं के संदर्भ में व्यक्त किया गया है।

एक वर्ग (कंप्यूटर विज्ञान) अनिवार्य रूप से इन वस्तुओं को संभालने के लिए एक अनुबंध के रूप में वस्तु-उन्मुख भाषाओं में इससे प्राप्त वस्तुओं की संरचना और एक एपीआई#एपीआई को परिभाषित करता है। हर बार जब कोई नई वस्तु बनाई जाती है तो वह उस अनुबंध का पालन करेगी।

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

विशिष्ट भाषाओं में टाइप सुरक्षा मुद्दे

=== वहाँ === है

एडीए प्रोग्रामिंग भाषा को अंतः स्थापित प्रणाली , डिवाइस ड्राइवर्स और सिस्टम प्रोग्रामिंग के अन्य रूपों के लिए उपयुक्त होने के लिए डिज़ाइन किया गया था, लेकिन टाइप-सेफ प्रोग्रामिंग को प्रोत्साहित करने के लिए भी। इन परस्पर विरोधी लक्ष्यों को हल करने के लिए, Ada प्रकार-असुरक्षा को विशेष निर्माणों के एक निश्चित सेट तक सीमित करता है, जिनके नाम आमतौर पर स्ट्रिंग से शुरू होते हैं Unchecked_. आवेदन करके Ada टेक्स्ट की एक इकाई से Unchecked_Deallocation प्रभावी रूप से प्रतिबंधित किया जा सकता है pragma Pure इस इकाई के लिए। यह उम्मीद की जाती है कि प्रोग्रामर उपयोग करेंगे Unchecked_ बहुत सावधानी से और केवल तभी बनाता है जब आवश्यक हो; प्रोग्राम जो उनका उपयोग नहीं करते हैं वे टाइप-सेफ हैं।

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

Ada2012 अनुबंध द्वारा भाषा में ही डिजाइन जोड़ता है (पूर्व- और बाद की स्थितियों के साथ-साथ टाइप इनवेरिएंट के रूप में)।

सी

सी (प्रोग्रामिंग भाषा) सीमित संदर्भों में टाइप-सुरक्षित है; उदाहरण के लिए, एक संकलन-समय त्रुटि तब उत्पन्न होती है जब एक पॉइंटर को एक प्रकार की संरचना में एक पॉइंटर को दूसरे प्रकार की संरचना में बदलने का प्रयास किया जाता है, जब तक कि एक स्पष्ट कास्ट का उपयोग नहीं किया जाता है। हालाँकि, बहुत से सामान्य ऑपरेशन गैर-प्रकार-सुरक्षित हैं; उदाहरण के लिए, पूर्णांक को प्रिंट करने का सामान्य तरीका कुछ इस प्रकार है printf("%d", 12), जहां %d कहता है printf पूर्णांक तर्क की अपेक्षा करने के लिए रन-टाइम पर। (कुछ इस तरह printf("%s", 12), जो फ़ंक्शन को एक वर्ण-स्ट्रिंग के लिए एक सूचक की अपेक्षा करने के लिए कहता है और फिर भी एक पूर्णांक तर्क प्रदान करता है, जिसे संकलक द्वारा स्वीकार किया जा सकता है, लेकिन अपरिभाषित परिणाम उत्पन्न करेगा।) यह कुछ संकलक (जैसे जीसीसी) द्वारा आंशिक रूप से कम किया जाता है, जो बीच के प्रकार के पत्राचार की जाँच करता है। printf तर्क और प्रारूप तार।

इसके अलावा, C, Ada की तरह, अनिर्दिष्ट या अपरिभाषित स्पष्ट रूपांतरण प्रदान करता है; और एडा के विपरीत, इन रूपांतरणों का उपयोग करने वाले मुहावरे बहुत आम हैं, और सी को एक प्रकार-असुरक्षित प्रतिष्ठा देने में मदद की है। उदाहरण के लिए, हीप पर मेमोरी आवंटित करने का मानक तरीका एक मेमोरी आवंटन फ़ंक्शन को कॉल करना है, जैसे कि malloc, एक तर्क के साथ कि कितने बाइट्स की आवश्यकता है। फ़ंक्शन एक अनटाइप्ड पॉइंटर लौटाता है (टाइप void *), जिसे कॉलिंग कोड को स्पष्ट रूप से या निहित रूप से उचित सूचक प्रकार में डाला जाना चाहिए। सी के पूर्व-मानकीकृत कार्यान्वयन के लिए ऐसा करने के लिए एक स्पष्ट कलाकार की आवश्यकता होती है, इसलिए कोड (struct foo *) malloc(sizeof(struct foo)) स्वीकृत प्रथा बन गई।

सी ++

C++ की कुछ विशेषताएं जो अधिक टाइप-सुरक्षित कोड को बढ़ावा देती हैं:

• नया (सी ++) ऑपरेटर ऑपरेंड के आधार पर प्रकार का सूचक देता है, जबकि malloc एक शून्य सूचक देता है।
• सी ++ कोड शून्य पॉइंटर्स के बिना बहुरूपता प्राप्त करने के लिए आभासी कार्यों और टेम्पलेट (प्रोग्रामिंग) का उपयोग कर सकता है।
• सुरक्षित कास्टिंग ऑपरेटर, जैसे गतिशील कास्ट जो रन-टाइम टाइप चेकिंग करता है।
• C++11# जोरदार टाइप की गई गणना |
• C++11#स्पष्ट रूपांतरण ऑपरेटर|C++ स्पष्ट कंस्ट्रक्टर और C++11 स्पष्ट रूपांतरण ऑपरेटर अंतर्निहित प्रकार के रूपांतरण को रोकते हैं।

सी#

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

सी शार्प सिंटैक्स # ऑब्जेक्ट क्लास टाइप (जिससे अन्य सभी प्रकार व्युत्पन्न होते हैं) पर अनुचित निर्भरता सी # टाइप सिस्टम के उद्देश्य को पराजित करने का जोखिम उठाती है। आमतौर पर .NET में जेनेरिक प्रोग्रामिंग#जेनेरिक प्रोग्रामिंग के पक्ष में वस्तु संदर्भों को छोड़ना बेहतर अभ्यास है, C++ में टेम्प्लेट और Java में जेनरिक के समान।

जावा

जावा प्रोग्रामिंग भाषा को प्रकार की सुरक्षा को लागू करने के लिए डिज़ाइन किया गया है। जावा में कुछ भी एक वस्तु (कंप्यूटर विज्ञान) के अंदर होता है और प्रत्येक वस्तु एक वर्ग (कंप्यूटर प्रोग्रामिंग) का एक उदाहरण है।

प्रकार के सुरक्षा प्रवर्तन को लागू करने के लिए, उपयोग से पहले प्रत्येक वस्तु को मेमोरी आवंटन की आवश्यकता होती है। जावा आदिम डेटा प्रकार के उपयोग की अनुमति देता है लेकिन केवल ठीक से आवंटित वस्तुओं के अंदर।

कभी-कभी प्रकार की सुरक्षा का एक हिस्सा अप्रत्यक्ष रूप से कार्यान्वित किया जाता है: उदा। वर्ग BigDecimal मनमाना परिशुद्धता के एक फ़्लोटिंग पॉइंट संख्या का प्रतिनिधित्व करता है, लेकिन केवल उन संख्याओं को संभालता है जिन्हें परिमित प्रतिनिधित्व के साथ व्यक्त किया जा सकता है। ऑपरेशन BigDecimal.divide () BigDecimal के रूप में व्यक्त दो संख्याओं के विभाजन के रूप में एक नई वस्तु की गणना करता है।

इस मामले में यदि विभाजन का कोई परिमित प्रतिनिधित्व नहीं है, जैसे कि जब कोई गणना करता है उदा। 1/3 = 0.33333 ..., ऑपरेशन के लिए कोई राउंडिंग मोड परिभाषित नहीं होने पर डिवाइड () विधि अपवाद उठा सकती है। इसलिए पुस्तकालय, भाषा के बजाय, यह गारंटी देता है कि वस्तु वर्ग परिभाषा में निहित अनुबंध का सम्मान करती है।

मानक एमएल

मानक एमएल ने शब्दार्थ को कड़ाई से परिभाषित किया है और इसे टाइप-सेफ के रूप में जाना जाता है। हालांकि, न्यू जर्सी के मानक एमएल (SML/NJ), इसके सिंटैक्टिक वैरिएंट Mythryl और MLton सहित कुछ कार्यान्वयन, पुस्तकालय प्रदान करते हैं जो असुरक्षित संचालन प्रदान करते हैं। इन सुविधाओं का उपयोग अक्सर गैर-एमएल कोड (जैसे सी पुस्तकालयों) के साथ बातचीत करने के लिए उन कार्यान्वयनों के विदेशी फ़ंक्शन इंटरफ़ेस के संयोजन के साथ किया जाता है, जिन्हें विशिष्ट तरीकों से निर्धारित डेटा की आवश्यकता हो सकती है। एक अन्य उदाहरण स्वयं SML/NJ रीड-इवल-प्रिंट लूप है, जिसे उपयोगकर्ता द्वारा दर्ज किए गए ML कोड को निष्पादित करने के लिए असुरक्षित संचालन का उपयोग करना चाहिए।

मोडुला -2

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

<वाक्यविन्यास लैंग = मॉड्यूल 2> आयात प्रणाली; (* कुछ असुरक्षित सुविधाओं के उपयोग की अनुमति देता है: *) वर शब्द : प्रणाली। शब्द; पता: सिस्टम.एड्रेस; Addr := SYSTEM.ADR(शब्द);

(* लेकिन टाइप कास्ट सिंटैक्स का उपयोग ऐसे आयात के बिना किया जा सकता है *) वर मैं : पूर्णांक; n : कार्डिनल; एन: = कार्डिनल (i); (* या *) मैं := पूर्णांक (एन); </वाक्यविन्यास हाइलाइट>

आईएसओ मोडुला-2 मानक ने टाइप कास्ट सिंटैक्स को CAST नामक फ़ंक्शन में बदलकर टाइप कास्ट सुविधा के लिए इसे सही किया, जिसे स्यूडो-मॉड्यूल सिस्टम से आयात किया जाना है। हालांकि, अन्य असुरक्षित सुविधाएं जैसे वेरिएंट रिकॉर्ड छद्म-मॉड्यूल सिस्टम से किसी आयात के बिना उपलब्ध रहीं। <वाक्यविन्यास लैंग = मॉड्यूल 2> आयात प्रणाली; वर मैं : पूर्णांक; n : कार्डिनल; i := सिस्टम.कास्ट (इंटीजर, एन); (*ISO Modula-2* में टाइप कास्ट) </वाक्यविन्यास हाइलाइट>

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

<वाक्यविन्यास लैंग = मॉड्यूल 2> असुरक्षित आयात करें; वर मैं : पूर्णांक; n : कार्डिनल; मैं := असुरक्षित कास्ट (पूर्णांक, एन); (*मोडुला-2 संशोधन 2010 में टाइप कास्ट*)

असुरक्षित आयात एफएफआई से; (* विदेशी फ़ंक्शन इंटरफ़ेस सुविधा के लिए पहचानकर्ता को सक्षम करना *) <*FFI= C *> (* विदेशी फ़ंक्शन इंटरफ़ेस के लिए C * के लिए pragma) </वाक्यविन्यास हाइलाइट>

पास्कल

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

type
  TwoTypes = record
     I: Integer;
     Q: Real;
  end;

  DualTypes = record
    I: Integer;
    Q: Real;
  end;

var
  T1, T2:  TwoTypes;
  D1, D2:  DualTypes;

सख्त टाइपिंग के तहत, एक चर के रूप में परिभाषित किया गया TwoTypes के साथ संगत नहीं है DualTypes (क्योंकि वे समान नहीं हैं, भले ही उस उपयोगकर्ता परिभाषित प्रकार के घटक समान हों) और का असाइनमेंट T1 := D2; अवैध है। का एक कार्य T1 := T2; कानूनी होगा क्योंकि जिन उपप्रकारों को परिभाषित किया गया है वे समान हैं। हालाँकि, एक असाइनमेंट जैसे T1.Q := D1.Q; कानूनी होगा।

सामान्य लिस्प

आम तौर पर, सामान्य लिस्प एक प्रकार की सुरक्षित भाषा है। एक सामान्य लिस्प संकलक संचालन के लिए गतिशील जांच डालने के लिए जिम्मेदार होता है जिसकी प्रकार की सुरक्षा को स्थिर रूप से सिद्ध नहीं किया जा सकता है। हालांकि, एक प्रोग्रामर संकेत दे सकता है कि एक प्रोग्राम को गतिशील टाइप-चेकिंग के निम्न स्तर के साथ संकलित किया जाना चाहिए। ऐसे मोड में संकलित प्रोग्राम को टाइप-सेफ नहीं माना जा सकता है।

सी ++ उदाहरण

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

#include <iostream>
using namespace std;

int main () {
    int   ival = 5;                              // integer value
    float fval = reinterpret_cast<float&>(ival); // reinterpret bit pattern
    cout << fval << endl;                        // output integer as float
    return 0;
}

इस उदाहरण में, reinterpret_cast स्पष्ट रूप से संकलक को पूर्णांक से फ़्लोटिंग-पॉइंट मान में सुरक्षित रूपांतरण करने से रोकता है। जब प्रोग्राम चलता है तो यह कचरा फ़्लोटिंग-पॉइंट वैल्यू आउटपुट करेगा। इसके बजाय लिखने से समस्या से बचा जा सकता था float fval = ival; अगला उदाहरण दिखाता है कि कैसे वस्तु संदर्भों को गलत तरीके से डाउनकास्ट किया जा सकता है:

#include <iostream>
using namespace std;

class Parent {
public:
    virtual ~Parent() {} // virtual destructor for RTTI
};

class Child1 : public Parent {
public:
    int a;
};

class Child2 : public Parent {
public:
    float b;
};

int main () {
    Child1 c1;
    c1.a = 5;
    Parent & p = c1;                     // upcast always safe
    Child2 & c2 = static_cast<Child2&>(p); // invalid downcast
    cout << c2.b << endl;          // will output garbage data
    return 0;
}

दो बाल वर्गों में विभिन्न प्रकार के सदस्य होते हैं। चाइल्ड क्लास पॉइंटर को पैरेंट क्लास पॉइंटर को डाउनकास्ट करते समय, परिणामी पॉइंटर सही प्रकार की वैध वस्तु को इंगित नहीं कर सकता है। उदाहरण में, इससे गारबेज वैल्यू प्रिंट हो जाती है। बदलने से समस्या से बचा जा सकता था static_cast साथ dynamic_cast जो अमान्य जातियों पर अपवाद फेंकता है।

यह भी देखें

• प्रकार सिद्धांत

संदर्भ

• Pierce, Benjamin C. (2002). Types and Programming Languages. MIT Press. ISBN 978-0-262-16209-8.
• "Type Safe". Portland Pattern Repository Wiki.
• Wright, Andrew K.; Matthias Felleisen (1994). "A Syntactic Approach to Type Soundness". Information and Computation. 115 (1): 38–94. doi:10.1006/inco.1994.1093.
• Macrakis, Stavros (April 1982). "Safety and power". ACM SIGSOFT Software Engineering Notes. 7 (2): 25–26. doi:10.1145/1005937.1005941. S2CID 10426644.