क्या विशिष्ट प्रकार अभी भी आवश्यक हैं?

20

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

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

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

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

मुझे यह पता चला है कि इस प्रकार की वास्तुकला को बदलने में अपार समस्या है क्योंकि यह अंतर्निहित हार्डवेयर के साथ बहुत कसकर एकीकृत है और क्रमबद्धता जैसी चीजें वास्तव में मुश्किल हो सकती हैं। लेकिन एक प्रोग्रामिंग दृष्टिकोण से यह महान नहीं होना चाहिए?

programming-languages

— Homde
स्रोत

6

PHP, रूबी, पर्ल और अन्य को आपको चर के प्रकारों को बताने की आवश्यकता नहीं है। पर्यावरण आपके लिए इसे आंकता है।

— FrustratedWithFormsDesigner

7

यूनिकोड के तारों को अतिरिक्त मेमोरी लेने की जरूरत नहीं है, जब वे एएससीआईआई (यूटीएफ -8) के लिए ही उपयोग किए जाएं।

2

लेकिन वैरिएंट और एडेप्टिव टाइप IMO में अंतर होता है। वेरिएंट को टाइप नहीं किया जाता है, लेकिन असाइन किए जाने पर टाइप हो जाता है, जबकि एडेप्टिव प्रकार टाइप किए जाएंगे, लेकिन अधिक शिथिल। (और मैं प्रकार की बाधाओं की अवधारणा को पसंद करता हूं)

— होमडे

यह मुझे इस परियोजना की याद दिलाता है: tom.lokhorst.eu/media/…

— LennyProgrammers

4

आद्या के बारे में क्या? type hour is range 0 .. 23;

— मौविसिल 21

12

मैं पूरी तरह से इस मामले को मानता हूं। सिमेंटिक बाधाएं कार्यान्वयन की बाधाओं से अधिक मूल्य की हैं। किसी वस्तु के आकार के बारे में चिंता करने से ऐसा महसूस होता है जैसे किसी वस्तु की गति के बारे में चिंता करना जब ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के बारे में आ रहा था।

इसने प्रदर्शन महत्वपूर्ण प्रोग्रामिंग को प्रतिस्थापित नहीं किया है। यह केवल गैर-प्रदर्शन महत्वपूर्ण प्रोग्रामिंग को अधिक उत्पादक बनाता है।

— मार्क कैनलास
स्रोत

1

.NET 4.0 में कोड कॉन्ट्रैक्ट देखें ।

— स्टीवन ज्यूरिस

+1 जब डेटा स्टोरेज / ट्रांसमिशन (पूर्व नेटवर्किंग) की बात आती है, तो बाधाएँ प्रोटोकॉल / कार्यान्वयन की दक्षता को बढ़ाने के लिए मौलिक होती हैं। इसके अलावा, यदि टाइप किए गए संग्रह उपलब्ध हैं, तो बहुत अधिक जमीन मिलनी चाहिए। इसके अलावा, यह मान लेना सुरक्षित है कि दक्षता बैकसीट ले सकती है (विशेषकर यदि यह शब्दार्थ त्रुटियों की संभावना कम हो जाती है)।

— इवान प्लाइस

9

अनुकूली प्रकारों का अर्थ है कि तर्क को करने के लिए तर्क का अर्थ है, उस तर्क को चलाने के लिए रनटाइम पर काम करना (अस्थायी और संकलन-समय के लिए एक विशिष्ट प्रकार की आवश्यकता होगी, प्रकारान्तर एक विशेष स्थिति होने पर जहां आपको दो दुनियाओं में से सर्वश्रेष्ठ मिलता है)। यह अतिरिक्त काम उन वातावरण में ठीक हो सकता है जहां प्रदर्शन महत्वपूर्ण नहीं है, और सिस्टम एक उचित आकार रखता है। अन्य वातावरणों में यह नहीं है (एम्बेडेड सिस्टम एक है, जहां आपको कुछ समय के लिए सीपीयू प्रदर्शन के लिए 32/64 बिट्स पूर्णांक प्रकारों का उपयोग करना पड़ता है, और स्थिर मेमोरी बैकअप अनुकूलन के लिए 8/16 बिट्स पूर्णांक प्रकार)।

सामान्य प्रयोजन की भाषाएं जो देर से बाध्यकारी का समर्थन करती हैं (रनटाइम के प्रकारों का समाधान, जैसे VB6) अब मजबूत टाइपिंग को बढ़ावा देती हैं (VB.NET), प्रदर्शन हिट के कारण जो देर से बाध्यकारी के दुरुपयोग के समय उत्पन्न होता था, और क्योंकि आप अक्सर प्रकार स्पष्ट नहीं होने पर बदसूरत कोड के साथ समाप्त ( विज़ुअल बेसिक में संदर्भ / व्यावसायिक संदर्भ - Danijel Arsenovski )।

— माथीउ
स्रोत

कृपया "ऑटो-टाइपिंग" को परिभाषित करें।

@ डायलेन: लेट बाइंडिंग के साथ ऑटो-टाइपिंग को बदल दिया, जो मेरा मतलब है :)

— मैथ्यू 20

सामान्य उद्देश्य वाली बहुत सी भाषाएँ हैं जो रनटाइम के प्रकारों को हल करती हैं, कॉमन लिस्प को सिर्फ एक नाम देना है। (प्रदर्शन उद्देश्यों के लिए, आप आम लिस्प में प्रकारों की घोषणा कर सकते हैं, इसलिए आप केवल प्रदर्शन-महत्वपूर्ण खंडों में ही ऐसा कर सकते हैं।)

— डेविड थॉर्नले 20

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

— मैथ्यू 21

4

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

एक सरणी और एक वेक्टर (या लिंक की गई सूची) के बीच ट्रेडऑफ़ के बारे में सोचें। एक सरणी के साथ, एक विशिष्ट स्थिति की तलाश करना, आरंभिक स्थिति प्राप्त करने और मेमोरी पॉइंटर x रिक्त स्थान को स्थानांतरित करने का एक सरल मामला है कि स्मृति में उस नई स्थिति का पता लगाना। एक इंट को बिट के रूप में समझें [32] एक इंट को पढ़ने के लिए सभी बिट मान प्राप्त करने के लिए उस एरे से चलना शामिल है।

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

निर्णय लिया गया था कि सिस्टम के प्रदर्शन को प्रभावित करने की तुलना में आकार को जांचने और सत्यापित करने के लिए डेवलपर पर ओनस लगाना एक छोटा सा व्यापार है।

— माइकल ब्राउन
स्रोत

1

अन्य विकल्प है, संख्या के लिए लागू करने के लिए, जहां सरणी फिर से आबंटित होती है, जहाँ संख्या मौजूदा आकार को बढ़ा देती है। इसके अलावा, आपको उस मामले के लिए भी ध्यान देना होगा जहां उपयोगकर्ता लूप के लिए अतिप्रवाह करता है।

— माइकल ब्राउन

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

— २३:४६ बजे होमड

निष्पक्ष होना, यह उतना क्रूर नहीं है जितना आप बाहर करते हैं। मेरे आगामी उत्तर को सीएफ।

— पॉल नाथन

3

हार्डवेयर केंद्रित भाषाओं और परियोजनाओं के लिए विशिष्ट प्रकार की आवश्यकता होती है। एक उदाहरण ऑन-द-वायर नेटवर्क प्रोटोकॉल है।

लेकिन आइए बनाएँ - मनोरंजन के लिए - C ++ जैसी भाषा में एक प्रकार का संस्करण। इसे new'डी अर्ट्स ऑफ इन्ट' से बनाएँ ।

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

गुणन इसी तरह से होता है; जोड़ने / स्थानांतरण का उपयोग करें। हमेशा की तरह, आपकी पूंछ में असली मोड़ विभाजन [*] है।

जब ऐसा होता है तो आप क्या खोते हैं?

नियत समय। आपके पास एक syscall ( new) है जो उन बिंदुओं पर ट्रिगर हो सकता है जो आवश्यक रूप से नियंत्रणीय नहीं हैं।
नियत स्थान।
अर्ध-सॉफ्टवेयर गणित धीमा है।

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

[*] Cf हार्डवेयर गणित एल्गोरिदम इसे करने के तेज़ तरीकों के लिए - आमतौर पर ट्रिक समानांतर ऑपरेशन है।

— पॉल नाथन
स्रोत

2

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

यूनिकोड के लिए, UTF-8 एन्कोडिंग (जो यूनिकोड का हिस्सा है) केवल ASCII वर्णों के लिए एकल वर्ण का उपयोग करता है, इसलिए यह उतना बुरा नहीं है।

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

— एरिक ओ लेबिगॉट
स्रोत

1

भाषा-सिद्धांत के आधार पर आप सही हैं। प्रकार कानूनी राज्यों के एक सेट पर आधारित होना चाहिए, उन राज्यों के लिए उपलब्ध परिवर्तन, और उन राज्यों पर प्रदर्शन करने योग्य संचालन।

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

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

— jprete
स्रोत

मुझे एहसास है कि कुछ प्रकार के गतिशील / अनुकूली टाइपिंग हमें अब क्या है की तुलना में महंगा और कम प्रदर्शनकारी लगता है, और वर्तमान संकलक का उपयोग करके वे निश्चित रूप से होंगे। लेकिन क्या हम 100% सुनिश्चित हैं कि यदि आप जमीन से एक भाषा और संकलक का निर्माण करते हैं, तो आप उन्हें नहीं बना सकते, यदि तेजी से टाइप नहीं किया जाता है, तो कम से कम इसके लायक होने के लिए तेजी से।

— होमड्यू

1

@MKO: आप इसे आज़माकर क्यों नहीं देखते?

— आनन।

1

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

— jprete

के रूप में सभी प्रोग्रामर निश्चित रूप से मैं किसी दिन अपनी भाषा बनाने का सपना देखता हूं;)

— होमडे

@jprete: मैं असहमत हूं; अधिकांश लोग संभावित बड़े मध्यवर्ती परिणामों से अनजान हैं। ऐसी भाषा को अधिकांश उद्देश्यों के लिए पर्याप्त रूप से तेज किया जा सकता है।

— डेविड थॉर्नले 21

1

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

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

इसमें short, अधिक विशिष्ट प्रकारों के लिए अभी भी एक जगह है, लेकिन कई विकास समस्याओं के लिए उस सटीकता की आवश्यकता नहीं है।

— बेरिन लोरिट्श
स्रोत

0

मैंने हाल ही में एक लैडर लॉजिक एडिटर और रनटाइम बनाया है और मैंने बहुत ही सीमित प्रकारों के साथ निर्णय लिया है:

बूलियन
संख्या
तार
दिनांक और समय

मेरा मानना है कि इसने इसे उपयोगकर्ता के लिए अधिक सहज बना दिया। यह अधिकांश पीएलसी से एक कट्टरपंथी प्रस्थान है जिसमें सभी प्रकार के "सामान्य" प्रकार हैं जिन्हें आप सी जैसी भाषा में देखेंगे।

— स्कॉट व्हिटलॉक
स्रोत

0

प्रोग्रामिंग भाषाएँ उस दिशा में आगे बढ़ रही हैं। उदाहरण के लिए तार लें। पुरानी भाषाओं में आपको स्ट्रिंग का आकार घोषित करना होगा, जैसे PIC X(42)कि COBOL में, DIM A$(42)BASIC के कुछ संस्करणों में या SQL में [ VAR] CHAR(42)। आधुनिक भाषाओं में आपके पास बस एक गतिशील रूप से आवंटित stringप्रकार है और आकार के बारे में सोचने की आवश्यकता नहीं है।

इंटीजर अलग हैं, हालांकि:

मेरा मतलब है: क्या हमें वास्तव में शॉर्ट, इंट, लॉन्ग, बिगिंट आदि की आवश्यकता है।

अजगर को देखो। यह मशीन-आकार ( int) और मनमाने आकार ( long) पूर्णांकों के बीच अंतर करता था । 3.x में पूर्व चला गया है (पुराना longनया है int) और कोई भी इसे याद नहीं करता है।

लेकिन अभी भी और के रूप में 8-बिट पूर्णांक के दृश्यों के लिए एक विशेष प्रकार है । क्रमशः एक या पूर्णांक का उपयोग क्यों नहीं करते हैं? सच है, इसमें अतिरिक्त स्ट्रिंग जैसी विधियां नहीं हैं, लेकिन निश्चित रूप से दक्षता इसके साथ बहुत कुछ थी।bytesbytearraytuplelistbytestuple

फ्लोट, रियल और डबल एक बिट ट्रिकियर हैं क्योंकि टाइप इस बात पर निर्भर करता है कि आपको किस परिशुद्धता की आवश्यकता है।

ज़रुरी नहीं। "सब कुछ डबल-सटीक है" दृष्टिकोण बहुत आम है।

— dan04
स्रोत

1

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

— होमडे

@konrad: IMHO, कारण "अहस्ताक्षरित" पूर्णांक सी में ऐसे सिरदर्द का कारण बनता है कि वे कभी-कभी संख्याओं का प्रतिनिधित्व करने के लिए उपयोग किए जाते हैं और कभी-कभी रैपिंग अमूर्त बीजगणितीय रिंग के सदस्यों का प्रतिनिधित्व करते थे। अलग-अलग "रिंग" और "अहस्ताक्षरित संख्या" प्रकार यह सुनिश्चित कर सकते हैं कि कोड unum64 += ring32a-ring32bहमेशा सही व्यवहार देगा, भले ही डिफ़ॉल्ट पूर्णांक प्रकार 16 बिट या 64 [ध्यान दें कि का उपयोग +=आवश्यक है; एक अभिव्यक्ति unum64a = unum64b + (ring32a-ring32b);को अस्पष्ट के रूप में खारिज कर दिया जाना चाहिए।]

— सुपरकैट

0

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

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

फोरट्रान में भी कुछ ऐसा ही था (मुझे नहीं पता कि क्या आप वास्तव में इसका मतलब है, क्योंकि मैं वास्तव में दो सवाल देख रहा हूं)। उदाहरण के लिए, F90 में ऊपर की ओर आपको स्पष्ट रूप से एक प्रकार के आकार को परिभाषित करने की आवश्यकता नहीं है , इसलिए कहने के लिए। यह अच्छा है, क्योंकि न केवल यह आपको अपने डेटा प्रकारों को परिभाषित करने के लिए एक केंद्रीय स्थान देता है, बल्कि उन्हें परिभाषित करने का एक पोर्टेबल तरीका भी है। REAL * 4 सभी प्रोसेसर पर सभी कार्यान्वयन में समान नहीं है (और प्रोसेसर से मेरा मतलब सीपीयू + कंपाइलर है), लॉन्गशॉट द्वारा नहीं।

चयनित_real_kind (p, r) वास्तविक डेटा प्रकार के वास्तविक मान के साथ कम से कम p अंक और घातांक श्रेणी के अधिक से अधिक r कम से कम r लौटाते हैं।

तो तुम जाओ, उदाहरण के लिए;

program real_kinds
integer,parameter :: p6 = selected_real_kind(6)
integer,parameter :: p10r100 = selected_real_kind(10,100) !p is precision, r is range
integer,parameter :: r400 = selected_real_kind(r=400)
real(kind=p6) :: x
real(kind=p10r100) :: y
real(kind=r400) :: z

print *, precision(x), range(x)
print *, precision(y), range(y)
print *, precision(z), range(z)
end program real_kinds

(मुझे लगता है कि यह एक आत्म-व्याख्यात्मक उदाहरण है)।

अभी भी नहीं पता है कि क्या मैं आपके सवाल को सही ढंग से समझ पाया हूं, और यह वही है जो आप जानते हैं।

— कौआ
स्रोत