एक सख्त भाषा का उपयोग करने से कार्यान्वयन के सही होने के आस-पास के लक्ष्य पोस्टों को स्थानांतरित करने का अधिकार नहीं मिलता है। ऐसा कुछ करना कठिन है जो तार्किक रूप से बहुत गलत हो, लेकिन अभी तक लगातार नहीं है; यही कारण है कि संकलक इतने कीड़े पकड़ते हैं।
पॉइंटर अंकगणित जैसा कि सामान्य रूप से तैयार किया गया है, यह निराधार है क्योंकि प्रकार प्रणाली वास्तव में इसका मतलब नहीं है कि इसका क्या मतलब है। आप कचरा एकत्र भाषा (सामान्य दृष्टिकोण जो आपको अमूर्तता के लिए भी भुगतान करता है) में काम करके इस समस्या से पूरी तरह से बच सकते हैं। या आप इस बारे में अधिक विशिष्ट हो सकते हैं कि आप किस प्रकार के पॉइंटर्स का उपयोग कर रहे हैं, ताकि कंपाइलर किसी भी चीज को अस्वीकार कर सके जो असंगत है या सिर्फ लिखित रूप में सही साबित नहीं हो सकती है। यह रुस्त जैसी कुछ भाषाओं का दृष्टिकोण है।
निर्मित प्रकार सबूतों के बराबर होते हैं, इसलिए यदि आप एक प्रकार की प्रणाली लिखते हैं जो यह भूल जाती है, तो सभी प्रकार की चीजें गलत हो जाती हैं। कुछ समय के लिए मान लें कि जब हम एक प्रकार की घोषणा करते हैं, तो हम वास्तव में इसका मतलब है कि हम चर में क्या है के बारे में सच्चाई का आश्वासन दे रहे हैं।
- int * x; // एक असत्य कथन। एक्स मौजूद है और एक इंट की ओर इशारा नहीं करता है
- int * y = z; // केवल सच अगर z एक इंट को इंगित करता है
- * (x + 3) = 5; // केवल सच है अगर (x + 3) x के समान सरणी में एक इंट को इंगित करता है
- int c = a / b; // केवल सच है अगर बी नॉनज़रो है, जैसे: "नॉनज़रो इंट बी = ...;"
- अशक्त int * z = NULL; // nullable int * एक int * के समान नहीं है
- int d = * z; // झूठा दावा, क्योंकि z अशक्त है
- if (z! = NULL) {int * e = z; } // ठीक है क्योंकि z शून्य नहीं है
- नि: शुल्क (y); int w = * y; // गलत दावा, क्योंकि y अब w पर मौजूद नहीं है
इस दुनिया में, संकेत शून्य नहीं हो सकते। NullPointer dereferences मौजूद नहीं है, और संकेत कहीं भी अशक्तता के लिए जाँच करने के लिए नहीं है। इसके बजाय, एक "अशक्त int *" एक अलग प्रकार है जिसका मान या तो नल या पॉइंटर में निकाला जा सकता है। इसका मतलब यह है कि उस बिंदु पर जहां गैर-अशक्त धारणा शुरू होती है आप या तो अपने अपवाद को लॉग इन करें या एक शून्य शाखा के नीचे जाएं।
इस दुनिया में, सीमा त्रुटियों से बाहर सरणी या तो मौजूद नहीं है। यदि संकलक साबित नहीं कर सकता है कि यह सीमा में है, तो फिर से लिखने का प्रयास करें ताकि संकलक इसे साबित कर सके। यदि यह नहीं हो सकता है, तो आपको उस स्थान पर मैन्युअल रूप से मान लेना होगा; संकलक को बाद में इस पर विरोधाभास मिल सकता है।
इसके अलावा, यदि आपके पास एक पॉइंटर नहीं है जो कि इनिशियलाइज़ नहीं है, तो आपके पास अनइंस्टाल्ड मेमोरी के लिए पॉइंटर्स नहीं होंगे। यदि आपके पास मुक्त मेमोरी के लिए एक संकेतक है, तो इसे संकलक द्वारा अस्वीकार कर दिया जाना चाहिए। जंग में, इन प्रकार के साक्ष्यों को अपेक्षा के अनुकूल बनाने के लिए अलग-अलग सूचक प्रकार हैं। विशेष रूप से स्वामित्व वाले संकेत (यानी: कोई उपनाम नहीं), गहरी अपरिवर्तनीय संरचनाओं के संकेत हैं। डिफ़ॉल्ट भंडारण प्रकार अपरिवर्तनीय है, आदि।
प्रोटोकॉल सतह पर एक वास्तविक अच्छी तरह से परिभाषित व्याकरण लागू करने का मुद्दा भी है (जिसमें इंटरफ़ेस सदस्य शामिल हैं), इनपुट सतह क्षेत्र को ठीक से अनुमानित करने के लिए सीमित करने के लिए। "शुद्धता" के बारे में बात यह है: 1) सभी अपरिभाषित राज्यों से छुटकारा पाएं 2) तार्किक स्थिरता सुनिश्चित करें । वहाँ होने की कठिनाई का बहुत बुरा टूलींग (शुद्धता के दृष्टिकोण से) का उपयोग करने के साथ बहुत कुछ करना है।
यही कारण है कि दो सबसे खराब अभ्यास वैश्विक चर और गोटो हैं। ये चीजें किसी भी चीज के आसपास पूर्व / पोस्ट / अपरिवर्तनीय स्थितियां डालने से रोकती हैं। यह भी है कि प्रकार इतने प्रभावी क्यों हैं। जैसे-जैसे प्रकार मजबूत होते जाते हैं (अंततः वास्तविक मूल्य को ध्यान में रखने के लिए डिपेंडेंट प्रकारों का उपयोग करते हैं), वे स्वयं में रचनात्मक शुद्धता प्रमाण प्राप्त करते हैं; असंगत कार्यक्रमों को संकलन विफल करना।
ध्यान रखें कि यह केवल गूंगा गलतियों के बारे में नहीं है। यह चतुर घुसपैठियों से कोड आधार का बचाव करने के बारे में भी है। ऐसे मामले होंगे जहां आपको "औपचारिक रूप से निर्दिष्ट प्रोटोकॉल का पालन करना" जैसे महत्वपूर्ण गुणों के एक ठोस मशीन-जनित प्रमाण के बिना एक सबमिशन को अस्वीकार करना होगा।