इम्पेरेटिव प्रोग्रामिंग: Difference between revisions

From Vigyanwiki
(Created page with "{{Short description|Type of programming paradigm in computer science}} {{more citations needed|date=October 2011}} {{Programming paradigms}}[[कंप्यूटर व...")
 
 
(10 intermediate revisions by 5 users not shown)
Line 1: Line 1:
{{Short description|Type of programming paradigm in computer science}}
{{Programming paradigms}}
{{more citations needed|date=October 2011}}
[[कंप्यूटर]] विज्ञान में, '''इम्पेरेटिव प्रोग्रामिंग''' [[सॉफ़्टवेयर]] का एक [[प्रोग्रामिंग प्रतिमान|प्रोग्रामिंग सिंटेक्स]] है जो प्रोग्राम की स्थिति को परिवर्तित करने वाले सिंटेक्स का उपयोग करता है। उसी प्रकार जिस प्रकार से प्राकृतिक भाषाए इम्पेरेटिव [[कमांड (कंप्यूटिंग)]] को व्यक्त करती है एक इम्पेरेटिव प्रोग्रामिंग में कंप्यूटर के प्रदर्शन के लिए [[कमांड (कंप्यूटिंग)|कमांड]] होते हैं। इम्पेरेटिव प्रोग्रामिंग यह वर्णन करने पर केंद्रित होती है कि एक प्रोग्राम अपने अपेक्षित परिणामों के उच्च-स्तरीय विवरणों के अतिरिक्त चरण दर को कैसे संचालित करता है।<ref>{{Cite web |last=Jain |first=Anisha |date=2022-12-10 |title=Javascript Promises— Is There a Better Approach? |url=https://medium.datadriveninvestor.com/javascript-promises-is-there-a-better-approach-dd6a0a329131 |access-date=2022-12-20 |website=Medium |language=en}}</ref>
{{Programming paradigms}}[[[[कंप्यूटर]] विज्ञान]] में, अनिवार्य प्रोग्रामिंग [[सॉफ़्टवेयर]] का एक [[प्रोग्रामिंग प्रतिमान]] है जो स्टेटमेंट (कंप्यूटर विज्ञान) का उपयोग करता है जो प्रोग्राम की स्थिति (कंप्यूटर विज्ञान) को बदलता है। लगभग उसी तरह जिस तरह से [[प्राकृतिक भाषा]]ओं में अनिवार्य मनोदशा कमांड को व्यक्त करती है, एक अनिवार्य कार्यक्रम में कंप्यूटर के प्रदर्शन के लिए [[कमांड (कंप्यूटिंग)]] होते हैं। अनिवार्य प्रोग्रामिंग 'कैसे' का वर्णन करने पर केंद्रित है, एक कार्यक्रम चरण दर चरण संचालित होता है,<ref>{{Cite web |last=Jain |first=Anisha |date=2022-12-10 |title=Javascript Promises— Is There a Better Approach? |url=https://medium.datadriveninvestor.com/javascript-promises-is-there-a-better-approach-dd6a0a329131 |access-date=2022-12-20 |website=Medium |language=en}}</ref> इसके अपेक्षित परिणामों के उच्च-स्तरीय विवरणों के बजाय।


इस शब्द का प्रयोग अक्सर [[घोषणात्मक प्रोग्रामिंग]] के विपरीत किया जाता है, जो इस बात पर ध्यान केंद्रित करता है कि प्रोग्राम को परिणाम कैसे प्राप्त करना चाहिए, इसके सभी विवरणों को निर्दिष्ट किए बिना प्रोग्राम को पूरा करना चाहिए।<ref>{{Cite web |title=Imperative programming: Overview of the oldest programming paradigm |url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ |access-date=2022-05-03 |website=IONOS Digitalguide |language=en}}</ref>
इस शब्द का प्रयोग प्रायः [[घोषणात्मक प्रोग्रामिंग|निर्दिष्ट प्रोग्रामिंग]] के विपरीत किया जाता है जो इस विषय पर ध्यान केंद्रित करती है कि प्रोग्राम को परिणाम कैसे प्राप्त करना चाहिए और इसके सभी विवरणों को निर्दिष्ट किए बिना प्रोग्राम को कैसे पूर्ण जा सकता है।<ref>{{Cite web |title=Imperative programming: Overview of the oldest programming paradigm |url=https://www.ionos.com/digitalguide/websites/web-development/imperative-programming/ |access-date=2022-05-03 |website=IONOS Digitalguide |language=en}}</ref>
== इम्पेरेटिव और [[प्रक्रियात्मक प्रोग्रामिंग]] ==
प्रक्रियात्मक प्रोग्रामिंग एक प्रकार की इम्पेरेटिव प्रोग्रामिंग है जिसमें प्रोग्राम एक या एक से अधिक प्रक्रियाओं (जिसे सबरूटीन्स या फ़ंक्शंस भी कहा जाता है) से डिज़ाइन किया गया है। शब्दों को प्रायः समानार्थक शब्द के रूप में उपयोग किया जाता है, लेकिन प्रक्रियाओं के उपयोग का प्रक्रियात्मक प्रभाव पड़ता है कि इम्पेरेटिव प्रोग्रामिंग कैसे कार्य करती हैं और उनका निर्माण कैसे किया जाता है। प्रक्रियात्मक प्रोग्रामिंग, जिसमें फंक्शन परिवर्तन प्रक्रियाओं के लिए स्थानीय प्रोग्राम होते हैं या स्पष्ट तर्कों और प्रक्रियाओं से वापस तक सीमित होते हैं यह संरचित प्रोग्रामिंग का एक रूप है। 1960 के दशक से, [[संरचित प्रोग्रामिंग]] और [[मॉड्यूलर प्रोग्रामिंग]] को इम्पेरेटिव प्रोग्रामिंग की स्थिरता और समग्र गुणवत्ता में संशोधन करने के लिए तकनीकों के रूप में प्रचारित किया गया है। वस्तु-उन्मुख प्रोग्रामिंग के पीछे की अवधारणा इस दृष्टिकोण का विस्तार करने का प्रयास करती है।


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


== अनिवार्य और [[प्रक्रियात्मक प्रोग्रामिंग]] ==
== तर्काधार (रेशनल) और इम्पेरेटिव प्रोग्रामिंग की नींव ==
प्रक्रियात्मक प्रोग्रामिंग एक प्रकार की अनिवार्य प्रोग्रामिंग है जिसमें प्रोग्राम एक या एक से अधिक प्रक्रियाओं (जिसे [[सबरूटीन]]्स या फ़ंक्शंस भी कहा जाता है) से बनाया गया है। शब्दों को अक्सर समानार्थक शब्द के रूप में उपयोग किया जाता है, लेकिन प्रक्रियाओं के उपयोग का नाटकीय प्रभाव पड़ता है कि अनिवार्य कार्यक्रम कैसे प्रकट होते हैं और उनका निर्माण कैसे किया जाता है। भारी प्रक्रियात्मक प्रोग्रामिंग, जिसमें राज्य (कंप्यूटर विज्ञान) परिवर्तन प्रक्रियाओं के लिए स्थानीय हैं या स्पष्ट तर्कों और प्रक्रियाओं से रिटर्न तक सीमित हैं, [[संरचित प्रोग्रामिंग]] का एक रूप है। 1960 के दशक के बाद से, सामान्य रूप से संरचित प्रोग्रामिंग और [[मॉड्यूलर प्रोग्रामिंग]] को अनिवार्य कार्यक्रमों की स्थिरता और समग्र गुणवत्ता में सुधार के लिए तकनीक के रूप में बढ़ावा दिया गया है। वस्तु-उन्मुख प्रोग्रामिंग के पीछे की अवधारणा इस दृष्टिकोण का विस्तार करने का प्रयास करती है।
लगभग सभी कंप्यूटरों मे प्रोग्राम बनाने के लिए उपयोग किए जाने वाले प्रोग्रामिंग सिंटेक्स समान्यतः एक इम्पेरेटिव मॉडल का अनुसरण करते हैं।<ref group="note">[[Reconfigurable computing]] is a notable exception.</ref> डिजिटल कंप्यूटर हार्डवेयर को मशीन कोड मे निष्पादित करने के लिए डिज़ाइन किया गया है जो कंप्यूटर के लिए मूल सिंटेक्स है जो समान्यतः इम्पेरेटिव प्रोग्रामिंग भाषा में लिखा जाता है, हालांकि अन्य सिंटेक्स का उपयोग करने वाले निम्न-स्तरीय कंपाइलर कुछ संरचनात्मक [[लिस्प मशीन]] मे सम्मिलित हैं।


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


== तर्काधार और अनिवार्य प्रोग्रामिंग की नींव ==
उच्च-स्तरीय इम्पेरेटिव भाषाएं, इसके अतिरिक्त, जटिल प्रोग्रामिंग के मूल्यांकन की स्वीकृति देती हैं, जिसमें अंकगणितीय संचालन और फ़ंक्शन मूल्यांकन का संयोजन सम्मिलित हो सकता है और मेमोरी के परिणामी मान का असाइनमेंट हो सकता है। लूपिंग स्टेटमेंट (जैसा कि व्हिल लूप, डू व्हिल लूप और [[लूप करते समय करें|फार-लूप]] के लिए) स्टेटमेंट के अनुक्रम को कई बार निष्पादित करने की स्वीकृति देता है। लूप या तो उन सिंटेक्स को निष्पादित कर सकते हैं जिनमें वे पूर्वनिर्धारित संख्या में होते हैं या वे उन्हें बार-बार निष्पादित कर सकते हैं जब तक कि कुछ शर्त पूर्ण नहीं हो जाती है कंडिशनल-ब्रांचिंग स्टेटमेंट के अनुक्रम को केवल तभी निष्पादित करने की स्वीकृति देते हैं जब कुछ शर्त पूर्ण होती है। अन्यथा, सिंटेक्स को छोड़ दिया जाता है और उनके बाद के सिंटेक्स से निष्पादन क्रम प्रारम्भ रहता है। अतिरिक्त [[ब्रांच (कंप्यूटर साइंस)|ब्रांच]]-स्टेटमेंट एक निष्पादन अनुक्रम को प्रोग्राम के दूसरे भाग में स्थानांतरित करने की स्वीकृति देते हैं। इनमें सम्मिलित (कई भाषाओं में गो-टू स्टेटमेंट कहा जाता है) स्विच और सबप्रोग्राम, सबरूटीन या प्रोसीजर कॉल जो समान्यतः कॉल के बाद [[स्विच स्टेटमेंट|"स्विच स्टेटमेंट]]" मे सम्मिलित होता हैं। [[उच्च स्तरीय प्रोग्रामिंग भाषा|उच्च स्तरीय प्रोग्रामिंग भाषाओं]] के विकास के प्रारंभ में, [[ब्लॉक (प्रोग्रामिंग)]] के प्रारम्भ मे उन प्रोग्रामों के निर्माण को सक्षम किया जिसमें सिंटेक्स और स्टेटमेंट के एक समूह को एक सिंटेक्स के रूप में माना जा सकता था। यह प्रक्रिया प्रारम्भ मे जटिल संरचनाओं को सरल प्रक्रियात्मक संरचनाओं में पदानुक्रमित सिंटेक्स द्वारा व्यक्त करने में सक्षम बनाती है। कई इम्पेरेटिव प्रोग्रामिंग भाषाए जैसे [[फोरट्रान]], [[बुनियादी|बेसिक]] [[सी (प्रोग्रामिंग भाषा)|(प्रोग्रामिंग भाषा)]], [[सी (प्रोग्रामिंग भाषा)|सी]] और [[सभा की भाषा|असेंबली भाषाए]] हैं।<ref name=":0">{{cite book|author=Bruce Eckel|title=Thinking in Java|url=https://books.google.com/books?id=bQVvAQAAQBAJ&q=imperative&pg=PA24|publisher=[[Pearson Education]]|year=2006|isbn=978-0-13-187248-6|page=24}}</ref>
लगभग सभी कंप्यूटरों के लिए प्रोग्राम बनाने के लिए इस्तेमाल किया जाने वाला प्रोग्रामिंग प्रतिमान आमतौर पर एक अनिवार्य मॉडल का अनुसरण करता है।<ref group=note>[[Reconfigurable computing]] is a notable exception.</ref> डिजिटल कंप्यूटर हार्डवेयर को [[मशीन कोड]] को निष्पादित करने के लिए डिज़ाइन किया गया है, जो कंप्यूटर के लिए मूल है और आमतौर पर अनिवार्य शैली में लिखा जाता है, हालांकि अन्य प्रतिमानों का उपयोग करने वाले निम्न-स्तरीय संकलक और दुभाषिए कुछ आर्किटेक्चर जैसे [[लिस्प मशीन]]ों के लिए मौजूद हैं।
== इम्पेरेटिव और वस्तु-उन्मुख भाषाओं का इतिहास ==
प्रारंभिक इम्पेरेटिव भाषाएँ मूल कंप्यूटरों की मशीनी भाषाएँ थीं। इन भाषाओं में सिंटेक्स बहुत सरल थे, जो हार्डवेयर कार्यान्वयन को आसान बनाते थे लेकिन जटिल प्रोग्रामों के निर्माण में अवरोध उत्पन्न करते थे। 1954 में [[अंतर्राष्ट्रीय व्यवसाय तंत्र|अंतर्राष्ट्रीय व्यवसाय मशीन]] (आईबीएम) में [[जॉन बैकस]] द्वारा विकसित [[फोरट्रान]], जटिल प्रोग्रामों के निर्माण में मशीन कोड द्वारा प्रस्तुत अवरोधों को दूर करने वाली पहली प्रमुख प्रोग्रामिंग भाषा थी। फोरट्रान एक संकलित भाषा थी जो नामांकित वेरिएबल, जटिल प्रोग्राम और कई अन्य विशेषताओं की स्वीकृति देती थी जो अब इम्पेरेटिव भाषाओं में सामान्य हैं। अगले दो दशकों में कई अन्य प्रमुख उच्च-स्तरीय इम्पेरेटिव प्रोग्रामिंग भाषाओं का विकास हुआ। 1950 और 1960 के दशक के अंत में, [[ALGOL|ऐल्गॉल]] को गणितीय एल्गोरिदम को अधिक आसानी से अभिव्यक्त करने की स्वीकृति देने के लिए विकसित किया गया था और यहां तक ​​कि कुछ कंप्यूटरों के लिए [[ऑपरेटिंग सिस्टम]] की लक्ष्य भाषा के रूप में भी कार्य किया गया था। [[MUMPS|एमयूएमपीएस]] (1966) ने इम्पेरेटिव सिंटेक्स को एक तार्किक रूप तक प्रदर्शित किया था जो किसी भी प्रकार के सिंटेक्स न देकर, पूर्ण रूप से कमांड पर निर्धारित थे यहाँ तक कि <code>IF</code> और <code>ELSE</code>कमांड को एक दूसरे से स्वतंत्र बनाने की सीमा तक, केवल $ नाम के एक आंतरिक वेरिएबल से जुड़ा हुआ है। [[COBOL|कोबोल]] (1960) और बेसिक (1964) दोनों प्रोग्रामिंग सिंटैक्स को अंग्रेजी की तरह बनाने के प्रयास थे। 1970 के दशक में, [[पास्कल (प्रोग्रामिंग भाषा)]] [[निकोलस विर्थ]] द्वारा विकसित किया गया था और C को [[डेनिस रिची]] द्वारा बनाया गया था, जब वह [[बेल प्रयोगशालाओं]] में कार्य कर रहे थे। तब विर्थ ने मोडुला-2 और ओबेरोन को डिजाइन किया। संयुक्त राज्य अमेरिका के सुरक्षा विभाग की आवश्यकताओ के लिए, [[जीन इचबियाह]] और [[हनीवेल]] के समूह ने भाषा के लिए आवश्यकताओं को परिभाषित करने के लिए 4 साल की परियोजना के बाद 1978 में [[एडा (प्रोग्रामिंग भाषा)]] को डिजाइन करना प्रारम्भ किया। विनिर्देश पहली बार 1983 में 1995, 2005 और 2012 में संशोधन के साथ प्रकाशित हुआ था।


इस निम्न-स्तरीय दृष्टिकोण से, प्रोग्राम की स्थिति को स्मृति की सामग्री द्वारा परिभाषित किया जाता है, और [[मतिहीनता (कंप्यूटर विज्ञान)]] मूल मशीन भाषा में निर्देश होते हैं। उच्च-स्तरीय अनिवार्य भाषाएँ [[चर (प्रोग्रामिंग)]] और अधिक जटिल कथनों का उपयोग करती हैं, लेकिन फिर भी उसी प्रतिमान का पालन करती हैं। व्यंजनों और प्रक्रिया [[जांच सूची]], जबकि [[कंप्यूटर प्रोग्राम]] नहीं, परिचित अवधारणाएं भी हैं जो शैली में अनिवार्य प्रोग्रामिंग के समान हैं; प्रत्येक चरण एक निर्देश है, और भौतिक दुनिया स्थिति रखती है। चूंकि अनिवार्य प्रोग्रामिंग के मूल विचार अवधारणात्मक रूप से परिचित और हार्डवेयर में सीधे सन्निहित हैं, अधिकांश कंप्यूटर भाषाएं अनिवार्य शैली में हैं।
1980 के दशक में वस्तु-उन्मुख प्रोग्रामिंग में रुचि में तीव्रता से वृद्धि देखी गई। ये भाषाएँ शैली में इम्पेरेटिव थीं, लेकिन वस्तुओं का समर्थन करने के लिए इसमे अन्य सुविधाएँ संबद्ध की गईं थी। 20वीं शताब्दी के अंतिम दो दशकों में ऐसी कई भाषाओं का विकास हुआ। स्मॉलटाक -80, मूल रूप से 1969 में एलन के द्वारा परिकल्पित, 1980 में ज़ेरॉक्स पालो ऑल्टो शोध संस्थान (पीएआरसी) द्वारा प्रारम्भ किया गया था। एक अन्य [[वस्तु-उन्मुख प्रोग्रामिंग भाषा]] में अवधारणाओं से आरेखण "सिमुला" जिसे विश्व की पहली वस्तु-उन्मुख प्रोग्रामिंग भाषा माना जाता है, जिसे 1960 के दशक में विकसित किया गया था -[[बज़्ने स्ट्रॉस्ट्रुप]] ने C ++ पर आधारित एक वस्तु-उन्मुख भाषा C ++ को डिजाइन किया था। C++ का डिजाइन 1979 में प्रारम्भ हुआ था। और पहला कार्यान्वयन 1983 में पूर्ण हुआ।


विनाशकारी असाइनमेंट, अनिवार्य प्रतिमान में, स्मृति में स्थित जानकारी पर एक ऑपरेशन करता है और बाद में उपयोग के लिए परिणामों को स्मृति में संग्रहीत करता है। इसके अलावा, उच्च-स्तरीय अनिवार्य भाषाएं, जटिल [[अभिव्यक्ति (प्रोग्रामिंग)]] के [[मूल्यांकन (बहुविकल्पी)]] की अनुमति देती हैं, जिसमें अंकगणित#अंकगणित संचालन और कार्य (गणित) मूल्यांकन का संयोजन शामिल हो सकता है, और स्मृति के परिणामी मूल्य का असाइनमेंट हो सकता है। लूपिंग स्टेटमेंट (जैसा कि लूप करते समय, [[लूप करते समय करें]], [[पाश के लिए]] के लिए) स्टेटमेंट के अनुक्रम को कई बार निष्पादित करने की अनुमति देता है। लूप या तो उन बयानों को निष्पादित कर सकते हैं जिनमें वे पूर्वनिर्धारित संख्या में होते हैं, या वे उन्हें बार-बार निष्पादित कर सकते हैं जब तक कि कुछ शर्त पूरी नहीं हो जाती। कंडिशनल (प्रोग्रामिंग) [[ब्रांच (कंप्यूटर साइंस)]] स्टेटमेंट कुछ शर्तों को पूरा करने पर ही स्टेटमेंट्स के अनुक्रम को निष्पादित करने की अनुमति देते हैं। अन्यथा, बयानों को छोड़ दिया जाता है और उनके बाद के बयान से निष्पादन क्रम जारी रहता है। बिना शर्त ब्रांचिंग स्टेटमेंट एक निष्पादन अनुक्रम को प्रोग्राम के दूसरे भाग में स्थानांतरित करने की अनुमति देते हैं। इनमें जंप (कई भाषाओं में [[के लिए जाओ]] कहा जाता है), [[स्विच स्टेटमेंट]], और सबप्रोग्राम, सबरूटीन, या प्रोसीजर कॉल (जो आमतौर पर कॉल के बाद अगले स्टेटमेंट पर लौटता है) शामिल हैं।
1980 और 1990 के दशक के अंत में, वस्तु-उन्मुख अवधारणाओं पर चित्रित उल्लेखनीय इम्पेरेटिव भाषा पर्ल प्रोग्रामिंग भाषा थीं जिसे 1987 में [[लैरी वॉल]] द्वारा प्रारम्भ किया गया था पायथन को 1990 में [[गुइडो वैन रोसुम]] द्वारा प्रारम्भ किया गया था [[विजुअल बेसिक (क्लासिक)|विजुअल बेसिक]] और विजुअल [[सी ++|C ++]] जिसमें [[माइक्रोसॉफ्ट]] फाउंडेशन क्लास लाइब्रेरी (एमएफसी) 2.0 सम्मिलित है, जिसको माइक्रोसॉफ्ट द्वारा क्रमशः 1991 और 1993 में प्रारम्भ किया गया था 1994 में [[रासमस लेर्डोर्फ]] द्वारा प्रारम्भ [[PHP|पीएचपी]], [[जावा (प्रोग्रामिंग भाषा)]] 1995 में [[जेम्स गोस्लिंग]] ([[सन माइक्रोसिस्टम्स]]) द्वारा,[[जावास्क्रिप्ट]], [[ब्रेंडन ईच]] ([[नेटस्केप]]) द्वारा और [[रूबी (प्रोग्रामिंग भाषा)]], युकीहिरो "मैट्ज़" मात्सुमोतो द्वारा, दोनों 1995 में प्रारम्भ की गयी थी माइक्रोसॉफ्ट का डॉटनेट फ्रेमवर्क (2002) इसके मूल में इम्पेरेटिव है, क्योंकि इसकी मुख्य लक्ष्य भाषाएँ हैं, वीबी डॉटनेट और C# जो माइक्रोसॉफ्ट डॉटनेट पर आधारित हैं हालाँकि माइक्रोसॉफ्ट की एफ#, एक कार्यात्मक भाषा भी इस पर आधारित है।
 
[[उच्च स्तरीय प्रोग्रामिंग भाषा]] विकास के प्रारंभ में, [[ब्लॉक (प्रोग्रामिंग)]] की शुरूआत ने उन कार्यक्रमों के निर्माण को सक्षम किया जिसमें बयानों और घोषणाओं के एक समूह को एक बयान के रूप में माना जा सकता था। यह, उपनेमकाओं की शुरूआत के साथ, जटिल संरचनाओं को सरल प्रक्रियात्मक संरचनाओं में पदानुक्रमित अपघटन द्वारा व्यक्त करने में सक्षम बनाता है।
 
कई अनिवार्य प्रोग्रामिंग लैंग्वेज (जैसे [[फोरट्रान]], [[बुनियादी]], और [[सी (प्रोग्रामिंग भाषा)]]) [[सभा की भाषा]] के एब्स्ट्रक्शन (कंप्यूटर साइंस) हैं।<ref name=":0">{{cite book|author=Bruce Eckel|title=Thinking in Java|url=https://books.google.com/books?id=bQVvAQAAQBAJ&q=imperative&pg=PA24|publisher=[[Pearson Education]]|year=2006|isbn=978-0-13-187248-6|page=24}}</ref>
 
 
== अनिवार्य और वस्तु-उन्मुख भाषाओं का इतिहास ==
प्रारंभिक अनिवार्य भाषाएँ मूल कंप्यूटरों की मशीनी भाषाएँ थीं। इन भाषाओं में, निर्देश बहुत सरल थे, जो हार्डवेयर कार्यान्वयन को आसान बनाते थे लेकिन जटिल प्रोग्रामों के निर्माण में बाधा डालते थे। 1954 में [[अंतर्राष्ट्रीय व्यवसाय तंत्र]] (आईबीएम) में [[जॉन बैकस]] द्वारा विकसित [[फोरट्रान]], जटिल कार्यक्रमों के निर्माण में मशीन कोड द्वारा प्रस्तुत बाधाओं को दूर करने वाली पहली प्रमुख प्रोग्रामिंग भाषा थी। फोरट्रान एक [[संकलित भाषा]] थी जो नामांकित चर, जटिल अभिव्यक्ति, उपप्रोग्राम और कई अन्य विशेषताओं की अनुमति देती थी जो अब अनिवार्य भाषाओं में आम हैं। अगले दो दशकों में कई अन्य प्रमुख उच्च-स्तरीय अनिवार्य प्रोग्रामिंग भाषाओं का विकास हुआ। 1950 और 1960 के दशक के अंत में, [[ALGOL]] को गणितीय एल्गोरिदम को अधिक आसानी से अभिव्यक्त करने की अनुमति देने के लिए विकसित किया गया था और यहां तक ​​कि कुछ कंप्यूटरों के लिए [[ऑपरेटिंग सिस्टम]] की लक्ष्य भाषा के रूप में भी कार्य किया गया था। [[MUMPS]] (1966) ने अनिवार्य प्रतिमान को एक तार्किक चरम तक पहुँचाया, किसी भी तरह के बयान न देकर, पूरी तरह से कमांड पर भरोसा करते हुए, यहाँ तक कि IF और ELSE कमांड को एक दूसरे से स्वतंत्र बनाने की सीमा तक, केवल $ नाम के एक आंतरिक चर से जुड़ा हुआ है। परीक्षा। [[COBOL]] (1960) और BASIC (1964) दोनों प्रोग्रामिंग सिंटैक्स को अंग्रेजी की तरह बनाने के प्रयास थे। 1970 के दशक में [[पास्कल (प्रोग्रामिंग भाषा)]] [[निकोलस विर्थ]] द्वारा विकसित की गई थी, और सी (प्रोग्रामिंग लैंग्वेज) [[डेनिस रिची]] द्वारा बनाई गई थी, जब वह [[बेल प्रयोगशालाओं]] में काम कर रहे थे। Wirth ने [[Modula-2]] और Oberon (प्रोग्रामिंग लैंग्वेज) को डिजाइन किया। संयुक्त राज्य अमेरिका के रक्षा विभाग की जरूरतों के लिए, [[जीन इचबियाह]] और [[हनीवेल]] की एक टीम ने 1978 में भाषा की आवश्यकताओं को परिभाषित करने के लिए 4 साल की परियोजना के बाद [[एडा (प्रोग्रामिंग भाषा)]] को डिजाइन करना शुरू किया। विनिर्देश पहली बार 1983 में 1995, 2005 और 2012 में संशोधन के साथ प्रकाशित हुआ था।
 
1980 के दशक में वस्तु-उन्मुख प्रोग्रामिंग में रुचि में तेजी से वृद्धि देखी गई। ये भाषाएँ शैली में अनिवार्य थीं, लेकिन [[वस्तु (कंप्यूटिंग)]] का समर्थन करने के लिए अतिरिक्त सुविधाएँ। 20वीं शताब्दी के अंतिम दो दशकों में ऐसी कई भाषाओं का विकास हुआ। स्मॉलटाक -80, मूल रूप से 1969 में [[अब कश्मीर]] द्वारा परिकल्पित, 1980 में ज़ेरॉक्स पालो ऑल्टो रिसर्च सेंटर (PARC (कंपनी)) द्वारा जारी किया गया था। एक अन्य वस्तु-उन्मुख भाषा में अवधारणाओं से आरेखण- [[शुरुआत]] (जिसे दुनिया की पहली [[वस्तु-उन्मुख प्रोग्रामिंग भाषा]] माना जाता है, जिसे 1960 के दशक में विकसित किया गया था) - [[बज़्ने स्ट्रॉस्ट्रुप]] ने C ++, C (प्रोग्रामिंग भाषा) पर आधारित एक वस्तु-उन्मुख भाषा डिज़ाइन की। C++ का डिज़ाइन 1979 में शुरू हुआ और पहला कार्यान्वयन 1983 में पूरा हुआ। 1980 के दशक के अंत और 1990 के दशक में, ऑब्जेक्ट-ओरिएंटेड अवधारणाओं पर चित्रित उल्लेखनीय अनिवार्य भाषाएं [[पर्ल]] थीं, जिन्हें 1987 में [[लैरी वॉल]] द्वारा जारी किया गया था; पायथन (प्रोग्रामिंग लैंग्वेज), 1990 में [[गुइडो वैन रोसुम]] द्वारा जारी; [[विजुअल बेसिक (क्लासिक)]] और [[विजुअल [[सी ++]]]] (जिसमें [[माइक्रोसॉफ्ट]] फाउंडेशन क्लास लाइब्रेरी (एमएफसी) 2.0 शामिल है), माइक्रोसॉफ्ट द्वारा क्रमशः 1991 और 1993 में जारी किया गया; 1994 में [[रासमस लेर्डोर्फ]] द्वारा जारी [[PHP]]; [[जावा (प्रोग्रामिंग भाषा)]], 1995 में [[जेम्स गोस्लिंग]] ([[सन माइक्रोसिस्टम्स]]) द्वारा, [[जावास्क्रिप्ट]], [[ब्रेंडन ईच]] ([[नेटस्केप]]) द्वारा, और [[रूबी (प्रोग्रामिंग भाषा)]], युकिहिरो मात्ज़ मात्सुमोतो द्वारा, दोनों को 1995 में रिलीज़ किया गया। माइक्रोसॉफ्ट का .NET फ्रेमवर्क (2002) है इसके मूल में अनिवार्य, जैसा कि इसकी मुख्य लक्षित भाषाएं हैं, VB.NET और C Sharp (प्रोग्रामिंग भाषा)|C# जो इस पर चलती हैं; हालाँकि Microsoft की F Sharp (प्रोग्रामिंग भाषा)|F#, एक कार्यात्मक भाषा, भी इस पर चलती है।


== उदाहरण ==
== उदाहरण ==


=== फोरट्रान ===
=== फोरट्रान ===
फोरट्रान (1958) को आईबीएम मैथमेटिकल फॉर्मूला ट्रांसलेटिंग सिस्टम के रूप में पेश किया गया था। यह [[स्ट्रिंग (कंप्यूटर विज्ञान)]] हैंडलिंग सुविधाओं के बिना, वैज्ञानिक गणनाओं के लिए डिज़ाइन किया गया था। [[घोषणा (कंप्यूटर प्रोग्रामिंग)]], [[अभिव्यक्ति (कंप्यूटर विज्ञान)]], और वक्तव्य (कंप्यूटर विज्ञान) के साथ, यह समर्थित है:
फोरट्रान (1958) को "आईबीएम गणितीय सूत्र अनुवाद प्रणाली" के रूप में प्रस्तुत किया गया था। इसको [[स्ट्रिंग (कंप्यूटर विज्ञान)]] सुविधाओं के अतिरिक्त, वैज्ञानिक गणनाओं के लिए डिज़ाइन किया गया था। [[घोषणा (कंप्यूटर प्रोग्रामिंग)|निर्दिष्ट (कंप्यूटर प्रोग्रामिंग)]], [[अभिव्यक्ति (कंप्यूटर विज्ञान)|प्रक्रियात्मक]] [[घोषणा (कंप्यूटर प्रोग्रामिंग)|प्रोग्रामिंग]] और स्टेटमेंट (कंप्यूटर विज्ञान) के साथ, यह समर्थित है:
* [[सरणी डेटा संरचना]]
* [[सरणी डेटा संरचना]]
* सबरूटीन्स
* सबरूटीन्स
* पाश के लिए | लूप करो
* "डू" लूप


यह सफल हुआ क्योंकि:
यह सफल हुआ क्योंकि:
* प्रोग्रामिंग और डिबगिंग लागत कंप्यूटर चलाने की लागत से कम थी
* प्रोग्रामिंग और डिबगिंग (दोष मार्जन) लागत कंप्यूटर की लागत से कम थी।
* यह आईबीएम द्वारा समर्थित था
* यह आईबीएम द्वारा समर्थित था।
* उस समय के अनुप्रयोग वैज्ञानिक थे।<ref name="cpl_3rd-ch2-16">{{cite book
* उस समय के अनुप्रयोग वैज्ञानिक द्वारा किए जाते थे।
*[[अमेरिकी रक्षा विभाग|अमेरिकी सुरक्षा विभाग]] ने कोबोल के विकास को प्रभावित किया था जिसमें [[ग्रेस हूपर]] का प्रमुख योगदान था। हालांकि, गैर आईबीएम विक्रेताओं ने भी फोरट्रान कंपाइलर प्रोग्राम लिखे, लेकिन एक सिंटैक्स के साथ जो संभवतः आईबीएम के कंपाइलर को विफल कर डेटा था अमेरिकी राष्ट्रीय मानक संस्थान (एएनएसआई) ने 1966 में पहला फोरट्रान मानक विकसित किया। और 1978 में, फोरट्रान-77 फोरट्रान 90 समर्थन करता था।<ref name="cpl_3rd-ch2-16">{{cite book
   | last = Wilson
   | last = Wilson
   | first = Leslie B.
   | first = Leslie B.
Line 48: Line 42:
}}</रेफरी>
}}</रेफरी>


हालांकि, गैर आईबीएम विक्रेताओं ने फोरट्रान कंपाइलर्स भी लिखे, लेकिन एक सिंटैक्स के साथ जो संभवतः आईबीएम के कंपाइलर को विफल कर देगा।<ref name="cpl_3rd-ch2-16"/>अमेरिकी राष्ट्रीय मानक संस्थान (एएनएसआई) ने 1966 में पहला फोरट्रान मानक विकसित किया। 1978 में, फोरट्रान 77 1991 तक मानक बन गया। फोरट्रान 90 समर्थन करता है:
हालांकि, गैर आईबीएम विक्रेताओं ने फोरट्रान कंपाइलर्स भी लिखे, लेकिन एक सिंटैक्स के साथ जो संभवतः आईबीएम के कंपाइलर को विफल कर देगा।अमेरिकी राष्ट्रीय मानक संस्थान (एएनएसआई) ने 1966 में पहला फोरट्रान मानक विकसित किया। 1978 में, फोरट्रान 77 1991 तक मानक बन गया। फोरट्रान 90 समर्थन करता है:
* [[रिकॉर्ड (कंप्यूटर विज्ञान)]]
*[[रिकॉर्ड (कंप्यूटर विज्ञान)]]
* [[सूचक (कंप्यूटर प्रोग्रामिंग)]] सरणियों के लिए
*[[सूचक (कंप्यूटर प्रोग्रामिंग)]] सरणियों के लिए


=== कोबोल ===
===कोबोल===
कोबोल (1959) कॉमन बिजनेस ओरिएंटेड लैंग्वेज के लिए खड़ा है। फोरट्रान ने प्रतीकों में हेरफेर किया। जल्द ही यह महसूस किया गया कि प्रतीकों को संख्या होने की आवश्यकता नहीं है, इसलिए तार पेश किए गए।<ref name="cpl_3rd-ch2-24">{{cite book
कोबोल (1959) कॉमन बिजनेस ओरिएंटेड लैंग्वेज के लिए खड़ा है। फोरट्रान ने प्रतीकों में हेरफेर किया। जल्द ही यह महसूस किया गया कि प्रतीकों को संख्या होने की आवश्यकता नहीं है, इसलिए तार पेश किए गए।<nowiki><ref name="cpl_3rd-ch2-24"></nowiki>{{cite book
   | last = Wilson
   | last = Wilson
   | first = Leslie B.
   | first = Leslie B.
Line 60: Line 54:
   | page = 24
   | page = 24
   | isbn = 0-201-71012-9
   | isbn = 0-201-71012-9
}}</ref> [[अमेरिकी रक्षा विभाग]] ने COBOL के विकास को प्रभावित किया, जिसमें [[ग्रेस हूपर]] का प्रमुख योगदान था। बयान अंग्रेजी की तरह और वर्बोज़ थे। लक्ष्य एक भाषा डिजाइन करना था ताकि प्रबंधक कार्यक्रमों को पढ़ सकें। हालाँकि, संरचित कथनों की कमी ने इस लक्ष्य में बाधा उत्पन्न की।<ref name="cpl_3rd-ch2-25">{{cite book
}}</ref><ref name="cpl_3rd-ch2-30" />
  | last = Wilson
*अभिलेख
  | first = Leslie B.
*सरणियों के लिए संकेत
  | title = तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण| publisher = Addison-Wesley
  | year = 2001
  | page = 25
  | isbn = 0-201-71012-9
}}</रेफरी>
 
कोबोल के विकास को सख्ती से नियंत्रित किया गया था, इसलिए एएनएसआई मानकों की आवश्यकता के लिए बोलियों का उदय नहीं हुआ। परिणामस्वरूप, इसे 1974 तक 25 वर्षों तक नहीं बदला गया। 1990 के दशक के संस्करण ने वस्तु-उन्मुख प्रोग्रामिंग जैसे परिणामी परिवर्तन किए।<ref name="cpl_3rd-ch2-25"/>
 
 
=== अल्गोल ===
ALGOL (1960) ALGOritmic Language के लिए है। प्रोग्रामिंग लैंग्वेज डिजाइन पर इसका गहरा प्रभाव पड़ा।<ref name="cpl_3rd-ch2-19">{{cite book
  | last = Wilson
  | first = Leslie B.
  | title = तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण| publisher = Addison-Wesley
  | year = 2001
  | page = 19
  | isbn = 0-201-71012-9
}}</रेफरी> यूरोपीय और अमेरिकी प्रोग्रामिंग भाषा विशेषज्ञों की एक समिति से उभरकर, यह मानक गणितीय संकेतन का इस्तेमाल करता था और एक पठनीय संरचित डिजाइन था। एल्गोल सबसे पहले बैकस-नौर फॉर्म का उपयोग करके अपने [[सिंटेक्स (प्रोग्रामिंग भाषाएं)]] को परिभाषित करने वाला था।<ref name="cpl_3rd-ch2-19"/>इसके कारण सिंटैक्स-निर्देशित अनुवाद | वाक्य-विन्यास-निर्देशित संकलक हुए। इसमें इस तरह की विशेषताएं जोड़ी गईं:
* ब्लॉक संरचना, जहाँ चर उनके ब्लॉक के लिए स्थानीय थे
* चर सीमा के साथ सरणियाँ
* पाश के लिए | छोरों के लिए
* सबरूटीन # कार्य
* [[रिकर्सन (कंप्यूटर विज्ञान)]]<ref name="cpl_3rd-ch2-19"/>
 
अल्गोल के प्रत्यक्ष वंशजों में एक शाखा पर पास्कल (प्रोग्रामिंग भाषा), मोडुला -2, एडा (प्रोग्रामिंग भाषा), [[डेल्फी (सॉफ्टवेयर)]] और ओबेरॉन (प्रोग्रामिंग भाषा) शामिल हैं। दूसरी ब्रांच में C (प्रोग्रामिंग लैंग्वेज), C++ और Java (प्रोग्रामिंग लैंग्वेज) है।<ref name="cpl_3rd-ch2-19"/>


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


=== बेसिक ===
कोबोल के विकास को दृढ़ता से नियंत्रित किया गया था इसलिए एएनएसआई मानकों की आवश्यकता के लिए भाषाओं का विकास नहीं हुआ। इसके परिणामस्वरूप, इसे 1974 तक 15 वर्षों तक नहीं परिवर्तित किया गया। 1990 के दशक मे वस्तु-उन्मुख प्रोग्रामिंग संस्करण मे कई परिणामी परिवर्तन किए गए थे।<ref name="cpl_3rd-ch2-30" />
BASIC (1964) का मतलब बिगिनर्स ऑल पर्पस सिंबॉलिक इंस्ट्रक्शन कोड है। इसे [[डार्टमाउथ कॉलेज]] में उनके सभी छात्रों के सीखने के लिए विकसित किया गया था।<ref name="cpl_3rd-ch2-30">{{cite book
  | last = Wilson
  | first = Leslie B.
  | title = तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण| publisher = Addison-Wesley
  | year = 2001
  | page = 30
  | isbn = 0-201-71012-9
}}</ref> यदि कोई छात्र अधिक शक्तिशाली भाषा का प्रयोग नहीं करता है, तो छात्र को अभी भी बेसिक याद रहेगा।<ref name="cpl_3rd-ch2-30"/>1970 के दशक के अंत में निर्मित माइक्रो कंप्यूटरों में एक बेसिक दुभाषिया स्थापित किया गया था। जैसे-जैसे माइक्रो कंप्यूटर उद्योग बढ़ता गया, वैसे-वैसे भाषा भी बढ़ती गई।<ref name="cpl_3rd-ch2-30"/>


बेसिक ने रीड-इवल-प्रिंट लूप का बीड़ा उठाया।<ref name="cpl_3rd-ch2-30"/>इसने अपने वातावरण में ऑपरेटिंग सिस्टम कमांड की पेशकश की:
=== ऐल्गॉल ===
* 'नई' कमांड ने एक खाली स्लेट बनाई
ऐल्गॉल (1960) का अर्थ "एल्गोरिटमिक भाषा" है। प्रोग्रामिंग भाषा डिजाइन पर इसका महत्वपूर्ण प्रभाव था। यूरोपीय और अमेरिकी प्रोग्रामिंग भाषा विशेषज्ञों की एक समिति से इस मानक गणितीय संकेतन का उपयोग किया गया था क्योकि यह टेक्स्ट संरचित डिजाइन था। एल्गोल ने सबसे पहले बैकस-नौर फॉर्म का उपयोग करते हुए इसके सिंटैक्स को परिभाषित किया था। इसने सिंटैक्स-निर्देशित कंपाइलरों का नेतृत्व किया गया था। जिसमे निम्नलिखित प्रकार की विशेषताएं संबद्ध की गईं है:
* कथनों का तुरंत मूल्यांकन किया जाता है
* ब्लॉक संरचना, जहाँ वेरिएबल उनके ब्लॉक के लिए स्थानीय थे।
* कथनों के आगे एक पंक्ति संख्या लगाकर उन्हें क्रमादेशित किया जा सकता है
* ऐरे के साथ वेरिएबल
* 'सूची' कमांड ने प्रोग्राम प्रदर्शित किया
* "फार" लूप
* 'रन' कमांड ने प्रोग्राम को निष्पादित किया
* फंक्शन
* रिकर्शन फंक्शन
ऐल्गॉल के प्रत्यक्ष संस्कारण में पास्कल, मोडुला-2, एडा, डेल्फी और ओबेरॉन आदि प्रोग्रामिंग भाषाए सम्मिलित हैं। दूसरे संस्कारण में C, C++ और जावा प्रोग्रामिंग भाषाए सम्मिलित है।


हालाँकि, बड़े कार्यक्रमों के लिए मूल सिंटैक्स बहुत सरल था।<ref name="cpl_3rd-ch2-30"/>हाल की बोलियों ने संरचना और वस्तु-उन्मुख एक्सटेंशन जोड़े। Microsoft|Microsoft का [[Visual Basic]] अभी भी व्यापक रूप से उपयोग किया जाता है और एक [[ग्राफिकल यूज़र इंटरफ़ेस]] बनाता है।<ref name="cpl_3rd-ch2-31">{{cite book
=== C (प्रोग्रामिंग भाषा) ===
C प्रोग्रामिंग भाषा को 1973 मे इसका नाम विकसित किया गया क्योंकि भाषा बीसीपीएल को बी से परिवर्तित कर दिया गया था और एटी और टी बेल लैब्स ने अगले संस्करण को "C" कहा है इसका उद्देश्य यूनिक्स ऑपरेटिंग सिस्टम को लिखना था।<ref name="cpl_3rd-ch2-31">{{cite book
   | last = Wilson
   | last = Wilson
   | first = Leslie B.
   | first = Leslie B.
Line 116: Line 82:
}}</रेफरी>
}}</रेफरी>


=== सी ===
===सी===
C (प्रोग्रामिंग लैंग्वेज) (1973) को इसका नाम इसलिए मिला क्योंकि भाषा [[BCPL]] को B (प्रोग्रामिंग लैंग्वेज) से बदल दिया गया था, और Bell Labs|AT&T Bell Labs ने अगला संस्करण C कहा। इसका उद्देश्य [[UNIX]] ऑपरेटिंग सिस्टम लिखना था।<ref name="cpl_3rd-ch2-37">{{cite book
C (प्रोग्रामिंग लैंग्वेज) (1973) को इसका नाम इसलिए मिला क्योंकि भाषा [[BCPL]] को B (प्रोग्रामिंग लैंग्वेज) से बदल दिया गया था, और Bell Labs|AT&T Bell Labs ने अगला संस्करण C कहा। इसका उद्देश्य [[UNIX]] ऑपरेटिंग सिस्टम लिखना था।<nowiki><ref name="cpl_3rd-ch2-37"></nowiki>{{cite book
   | last = Wilson
   | last = Wilson
   | first = Leslie B.
   | first = Leslie B.
Line 124: Line 90:
   | page = 37
   | page = 37
   | isbn = 0-201-71012-9
   | isbn = 0-201-71012-9
}}</ref> सी एक अपेक्षाकृत छोटी भाषा है - जिससे कम्पाइलर लिखना आसान हो जाता है। इसकी वृद्धि ने 1980 के दशक में हार्डवेयर विकास को प्रतिबिंबित किया।<ref name="cpl_3rd-ch2-37"/>इसकी वृद्धि इसलिए भी हुई क्योंकि इसमें असेंबली लैंग्वेज की सुविधाएं हैं, लेकिन हाई-लेवल प्रोग्रामिंग लैंग्वेज | हाई-लेवल सिंटैक्स का उपयोग करता है। इसमें उन्नत सुविधाएँ शामिल हैं जैसे:
}}</ref> C एक अपेक्षाकृत छोटी प्रोग्रामिंग भाषा है जिससे कंपाइलर लिखना आसान हो जाता है। इसकी वृद्धि ने 1980 के दशक में हार्डवेयर विकास को प्रतिबिम्बित किया। इसकी वृद्धि इसलिए भी हुई क्योंकि इसमें असेंबली भाषा की सुविधाएं हैं, लेकिन यह उच्च स्तरीय सिंटैक्स का उपयोग करता है। इसमें अन्य नए संस्कारण की सुविधाएँ सम्मिलित हैं जैसे:
* [[इनलाइन असेंबलर]]
* [[इनलाइन असेंबलर]]
* पॉइंटर्स पर अंकगणित
* गणितीय पॉइंटर्स
* कार्यों के लिए संकेत
* फंक्शन संकेत  
* बिट ऑपरेशंस
* बिट ऑपरेशंस
* सी और सी ++ में जटिल ऑपरेटरों को स्वतंत्र रूप से जोड़ना<ref name="cpl_3rd-ch2-37"/>
* C और C ++ में स्वतंत्र रूप से जटिल ऑपरेटरों का संयोजन<ref name="cpl_3rd-ch2-37" />


[[File:Computer-memory-map.png|thumb|right|कंप्यूटर मेमोरी मैप]]सी प्रोग्रामर को यह नियंत्रित करने की अनुमति देता है कि स्मृति डेटा के किस क्षेत्र को संग्रहित किया जाना है। ग्लोबल वेरिएबल्स और स्टैटिक वेरिएबल्स को स्टोर करने के लिए सबसे कम [[घड़ी का संकेत]] की आवश्यकता होती है। [[कॉल स्टैक]] स्वचालित रूप से मानक चर घोषणा (कंप्यूटर प्रोग्रामिंग) के लिए उपयोग किया जाता है। [[मैनुअल मेमोरी प्रबंधन]] मेमोरी सी डायनेमिक मेमोरी एलोकेशन से एक पॉइंटर (कंप्यूटर प्रोग्रामिंग) में वापस आ जाती है<code>malloc()</code>समारोह।
[[File:Computer-memory-map.png|thumb|right|कंप्यूटर मेमोरी मानचित्र]]C प्रोग्रामर को यह नियंत्रित करने की स्वीकृति देता है कि मेमोरी डेटा के किस एड्रेस को संग्रहित किया जाना है। ग्लोबल वेरिएबल्स और स्टैटिक वेरिएबल्स को स्थित करने के लिए सबसे कम [[घड़ी का संकेत|भंडारण]] की आवश्यकता होती है। [[कॉल स्टैक]] स्वचालित रूप से मानक वेरिएबल निर्दिष्ट कंप्यूटर प्रोग्रामिंग के लिए उपयोग किया जाता है। [[मैनुअल मेमोरी प्रबंधन|हीप मेमोरी]] को <code>malloc()</code> फ़ंक्शन से एक पॉइंटर वैरिएबल में वापस किया जाता है।


* वैश्विक और स्थैतिक डेटा क्षेत्र कार्यक्रम क्षेत्र के ठीक ऊपर स्थित है। (प्रोग्राम क्षेत्र को तकनीकी रूप से टेक्स्ट क्षेत्र कहा जाता है। यह वह जगह है जहां मशीन निर्देश संग्रहीत होते हैं।)
* ग्लोबल और स्थैतिक डेटा प्रोग्राम के ठीक ऊपर स्थित है। प्रोग्राम को तकनीकी रूप से टेक्स्ट कहा जाता है। यह वह कारण है जहां मशीन निर्देश संग्रहीत होते हैं।
:* वैश्विक और स्थैतिक डेटा क्षेत्र तकनीकी रूप से दो क्षेत्र हैं।<ref name="geeksforgeeks">{{cite web
*ग्लोबल और स्थैतिक डेटा एड्रेस तकनीकी रूप से दो एड्रेस हैं।<ref name="geeksforgeeks">{{cite web
   | url = https://www.geeksforgeeks.org/memory-layout-of-c-program/
   | url = https://www.geeksforgeeks.org/memory-layout-of-c-program/
   | title = Memory Layout of C Programs
   | title = Memory Layout of C Programs
| date = 12 September 2011
| date = 12 September 2011
}}</ref> एक क्षेत्र को इनिशियलाइज़्ड [[डेटा खंड]] कहा जाता है, जहाँ डिफॉल्ट वैल्यू के साथ डिक्लेयर किए गए वेरिएबल स्टोर किए जाते हैं। दूसरे क्षेत्र को .bss कहा जाता है, जहां डिफॉल्ट वैल्यू के बिना डिक्लेयर किए गए वेरिएबल स्टोर किए जाते हैं।
}}</ref> एक एड्रेस को प्रारंभ [[डेटा खंड]] कहा जाता है, जहाँ डिफॉल्ट मान के साथ निर्धारित किए गए वेरिएबल स्थित किए जाते हैं। दूसरे एड्रेस को बीएसएस कहा जाता है, जहां डिफॉल्ट मान के बिना निर्धारित किए गए वेरिएबल स्थित किए जाते हैं
: * वैश्विक और स्थैतिक डेटा क्षेत्र में संग्रहीत चर का मेमोरी पता संकलन-समय पर सेट होता है। वे प्रक्रिया के पूरे जीवन भर अपने मूल्यों को बनाए रखते हैं।
*ग्लोबल और स्थैतिक डेटा एड्रेस में संग्रहीत वेरिएबल का मेमोरी एड्रेस रन-टाइम पर निर्भर होता है। वे प्रक्रिया के पूरे रन-टाइम अपने मान को बनाए रखते हैं।
 
*ग्लोबल और स्थिर एड्रेस उन वैश्विक वेरिएबल को संग्रहीत करता है जो <code>main()</code> फ़ंक्शन के ऊपर (बाहर) घोषित किए जाते हैं। स्रोत कोड में वैश्विक वेरिएबल <code>main()</code> और हर दूसरे फ़ंक्शन के लिए दृश्यमान हैं।<ref name="cpl-ch1-p31">{{cite book
:* वैश्विक और स्थैतिक क्षेत्र उन वैश्विक चरों को संग्रहीत करता है जो (बाहर) के शीर्ष पर घोषित किए जाते हैं <code>main()</code> समारोह।<ref name="cpl-ch1-p31">{{cite book
  |title=The C Programming Language Second Edition
  |title=The C Programming Language Second Edition
  |last1=Kernighan
  |last1=Kernighan
Line 150: Line 115:
  |year=1988
  |year=1988
  |isbn=0-13-110362-8
  |isbn=0-13-110362-8
  |page=31}}</ref> वैश्विक चर दिखाई दे रहे हैं <code>main()</code> और स्रोत कोड में हर दूसरे कार्य।
  |page=31}}</ref>
 
*दूसरी ओर, <code>main()</code> अन्य कार्यों के अंदर, या <code>{</code> <code>}</code> ब्लॉक सीमांकक के भीतर वेरिएबल घोषणाएँ स्थानीय वेरिएबल हैं। स्थानीय वेरिएबल में औपचारिक पैरामीटर वेरिएबल भी सम्मिलित हैं। पैरामीटर वेरिएबल फ़ंक्शन परिभाषाओं को <code>{</code> <code>}</code> के भीतर स्थित किया जाता हैं।<ref name="cpl_3rd-ch6-128">{{cite book
: दूसरी ओर, चर घोषणाओं के अंदर <code>main()</code>, अन्य कार्य, या भीतर <code>{</code> <code>}</code> ब्लॉक (प्रोग्रामिंग) स्थानीय चर हैं। स्थानीय चर में पैरामीटर (कंप्यूटर प्रोग्रामिंग)#पैरामीटर और तर्क चर भी शामिल हैं। पैरामीटर चर फ़ंक्शन परिभाषाओं के कोष्ठक के भीतर संलग्न हैं।<ref name="cpl_3rd-ch6-128">{{cite book
   | last = Wilson
   | last = Wilson
   | first = Leslie B.
   | first = Leslie B.
Line 159: Line 123:
   | page = 128
   | page = 128
   | isbn = 0-201-71012-9
   | isbn = 0-201-71012-9
}}</ref> वे फ़ंक्शन को एक [[इंटरफ़ेस (कंप्यूटिंग)]] प्रदान करते हैं।
}}</ref> जो फ़ंक्शन को एक [[इंटरफ़ेस (कंप्यूटिंग)]] प्रदान करते हैं।
*स्थानीय वेरिएबल का उपयोग करके <code>static</code> निर्धारित किया गया है उपसर्ग वैश्विक और स्थैतिक डेटा एड्रेस में भी संग्रहीत होते हैं।<ref name="geeksforgeeks" /> वैश्विक वेरिएबल के विपरीत, स्थैतिक वेरिएबल केवल फ़ंक्शन या ब्लॉक में दिखाई देते हैं। स्थैतिक वेरिएबल सदैव अपना मान बनाए रखते हैं। एक उदाहरण फ़ंक्शन <code>int increment_counter(){ static int counter = 0; counter++; return counter;}</code>का उपयोग किया जाता है।


:* स्थानीय चर का उपयोग करके घोषित किया गया <code>static</code> उपसर्ग वैश्विक और स्थैतिक डेटा क्षेत्र में भी संग्रहीत होते हैं।<ref name="geeksforgeeks"/>वैश्विक चर के विपरीत, स्थैतिक चर केवल फ़ंक्शन या ब्लॉक में दिखाई देते हैं। स्थैतिक चर हमेशा अपना मान बनाए रखते हैं। एक उदाहरण उपयोग समारोह होगा <code>int increment_counter(){ static int counter = 0; counter++; return counter;}</code>
* स्टैक एड्रेस शीर्ष मेमोरी एड्रेस के पास स्थित मेमोरी का एक सन्निहित ब्लॉक है।<ref name="lpi-ch6-p121">{{cite book
* कॉल स्टैक क्षेत्र शीर्ष मेमोरी पते के पास स्थित मेमोरी का एक सन्निहित ब्लॉक है।<ref name="lpi-ch6-p121">{{cite book
  |title=The Linux Programming Interface
  |title=The Linux Programming Interface
  |last=Kerrisk
  |last=Kerrisk
Line 169: Line 133:
  |year=2010
  |year=2010
  |isbn=978-1-59327-220-3
  |isbn=978-1-59327-220-3
  |page=121}}</ref> विडंबना यह है कि स्टैक में रखे गए वेरिएबल्स ऊपर से नीचे तक भरे जाते हैं।<ref name="lpi-ch6-p121"/>एक कॉल स्टैक#STACK-POINTER एक विशेष-उद्देश्य [[प्रोसेसर रजिस्टर]] है जो अंतिम पॉप्युलेट किए गए मेमोरी एड्रेस का ट्रैक रखता है।<ref name="lpi-ch6-p121"/>असेंबली लैंग्वेज PUSH इंस्ट्रक्शन के जरिए वेरिएबल्स को स्टैक में रखा जाता है। इसलिए, इन चरों के पते [[रनटाइम (कार्यक्रम जीवनचक्र चरण)]] के दौरान निर्धारित किए जाते हैं। स्टैक वेरिएबल्स के [[स्कोप (कंप्यूटर साइंस)]] को खोने की विधि POP निर्देश के माध्यम से है।
  |page=121}}</ref> विडंबना यह है कि स्टैक में रखे गए वेरिएबल्स ऊपर से नीचे तक भरे जाते हैं।<ref name="lpi-ch6-p121" /> एक स्टैक पॉइंटर एक विशेष [[प्रोसेसर रजिस्टर]] है जो अंतिम पॉप्युलेट मेमोरी एड्रेस का नियंत्रित रखता है। असेंबली भाषा <code>PUSH</code> निर्देश के साथ वेरिएबल्स को अतिरिक्त भंडारण के साथ रखा जाता है। इसलिए, इन वेरिएबल्स के एड्रेस रनटाइम के समय नियुक्त किए जाते हैं। [[स्कोप (कंप्यूटर साइंस)|स्कोप]] वेरिएबल्स की यह विधि पीओपी निर्देश के माध्यम से होती है।
 
*स्थानीय वेरिएबल निर्दिष्ट किए <code>static</code> उपसर्ग, औपचारिक पैरामीटर वेरिएबल सहित,<ref name="lpi-ch6-p122">{{cite book
:* स्थानीय चर बिना घोषित किए <code>static</code> उपसर्ग, औपचारिक पैरामीटर चर सहित,<ref name="lpi-ch6-p122">{{cite book
  |title=The Linux Programming Interface
  |title=The Linux Programming Interface
  |last=Kerrisk
  |last=Kerrisk
Line 178: Line 141:
  |year=2010
  |year=2010
  |isbn=978-1-59327-220-3
  |isbn=978-1-59327-220-3
  |page=122}}</ref> स्वचालित चर कहलाते हैं<ref name="cpl-ch1-p31"/>और ढेर में जमा हो जाते हैं।<ref name="geeksforgeeks"/>वे फ़ंक्शन या ब्लॉक के अंदर दिखाई देते हैं और फ़ंक्शन या ब्लॉक से बाहर निकलने पर अपना दायरा खो देते हैं।
  |page=122}}</ref> स्वचालित वेरिएबल कहलाते हैं<ref name="cpl-ch1-p31" /> और भंडारण में एकत्र हो जाते हैं।<ref name="geeksforgeeks" /> वे फ़ंक्शन या ब्लॉक के अंदर दिखाई देते हैं और फ़ंक्शन या ब्लॉक से बाहर निकलने पर अपना महत्व नष्ट कर देते हैं।


* मैनुअल मेमोरी प्रबंधन क्षेत्र स्टैक के नीचे स्थित है।<ref name="geeksforgeeks"/>यह नीचे से ऊपर तक आबाद है। ऑपरेटिंग सिस्टम हीप पॉइंटर और आवंटित मेमोरी ब्लॉक की सूची का उपयोग करके ढेर का प्रबंधन करता है।<ref name="cpl-ch1-p185">{{cite book
* हीप मेमोरी प्रबंधन एड्रेस स्टैक के नीचे स्थित होता है।<ref name="geeksforgeeks" /> यह नीचे से ऊपर तक स्वतंत्र रहता है। ऑपरेटिंग सिस्टम हीप पॉइंटर और आवंटित मेमोरी ब्लॉक की सूची का उपयोग करके भंडारण का प्रबंधन करता है।<ref name="cpl-ch1-p185">{{cite book
  |title=The C Programming Language Second Edition
  |title=The C Programming Language Second Edition
  |last1=Kernighan
  |last1=Kernighan
Line 189: Line 152:
  |year=1988
  |year=1988
  |isbn=0-13-110362-8
  |isbn=0-13-110362-8
  |page=185}}</ref> स्टैक की तरह, हीप चर के पते रनटाइम के दौरान सेट किए जाते हैं। मेमोरी से बाहर त्रुटि तब होती है जब हीप पॉइंटर और स्टैक पॉइंटर मिलते हैं।
  |page=185}}</ref> स्टैक की तरह, हीप वेरिएबल के एड्रेस रनटाइम के समय निर्धारित किए जाते हैं। मेमोरी से बाहर त्रुटि तब होती है जब हीप पॉइंटर और स्टैक पॉइंटर संबद्ध होते हैं।
 
*C प्रोग्रामिंग हीप मेमोरी आवंटित करने के लिए <code>malloc()</code> लाइब्रेरी फ़ंक्शन प्रदान करती है।<ref name="cpl-ch8-p187">{{cite book
:* सी प्रदान करता है <code>malloc()</code> [[सी गतिशील स्मृति आवंटन]] हीप मेमोरी के लिए लाइब्रेरी फंक्शन।<ref name="cpl-ch8-p187">{{cite book
  |title=The C Programming Language Second Edition
  |title=The C Programming Language Second Edition
  |last1=Kernighan
  |last1=Kernighan
Line 200: Line 162:
  |year=1988
  |year=1988
  |isbn=0-13-110362-8
  |isbn=0-13-110362-8
  |page=187}}</ref> डेटा के साथ हीप को पॉप्युलेट करना एक अतिरिक्त कॉपी फंक्शन है। हीप में संग्रहीत चर आर्थिक रूप से पॉइंटर्स का उपयोग करके कार्यों में पारित किए जाते हैं। पॉइंटर्स के बिना, स्टैक के माध्यम से डेटा के पूरे ब्लॉक को फ़ंक्शन में पास करना होगा।
  |page=187}}</ref> डेटा के साथ हीप को सम्मिलित करना एक अतिरिक्त <code>copy;</code> फंक्शन है। हीप में संग्रहीत वेरिएबल आर्थिक रूप से पॉइंटर्स का उपयोग करके लाइब्रेरी फ़ंक्शन मे निर्दिष्ट किए जाते हैं। पॉइंटर्स के अतिरिक्त <code>stack;</code> के माध्यम से डेटा को सम्पूर्ण ब्लॉक फ़ंक्शन में निर्दिष्ट करना होता है।


=== सी ++ ===
=== C++ ===
1970 के दशक में, [[सॉफ्टवेयर इंजीनियरिंग]] को बड़ी परियोजनाओं को मॉड्यूलर प्रोग्रामिंग में तोड़ने के लिए भाषा समर्थन की आवश्यकता थी।<ref name="cpl_3rd-ch2-38">{{cite book
1970 के दशक में, [[सॉफ्टवेयर इंजीनियरिंग|सॉफ्टवेयर इंजीनियरों]] को विस्तृत परियोजनाओं को मॉड्यूल में स्थगित करने के लिए भाषा समर्थन की आवश्यकता थी।<ref name="cpl_3rd-ch2-38">{{cite book
   | last = Wilson
   | last = Wilson
   | first = Leslie B.
   | first = Leslie B.
Line 210: Line 172:
   | page = 38
   | page = 38
   | isbn = 0-201-71012-9
   | isbn = 0-201-71012-9
}}</ref> एक स्पष्ट विशेषता बड़ी परियोजनाओं को भौतिक रूप से अलग [[कम्प्यूटर फाइल]] में विघटित करना था। एक कम स्पष्ट विशेषता बड़ी परियोजनाओं को [[सार और ठोस]] [[डेटा प्रकार]] में तार्किक रूप से विघटित करना था।<ref name="cpl_3rd-ch2-38"/>उस समय, भाषाएँ ठोस (वैरिएबल (कंप्यूटर साइंस)) डेटाटाइप जैसे [[पूर्णांक]] संख्या, [[फ़्लोटिंग-पॉइंट अंकगणित]] | फ़्लोटिंग-पॉइंट नंबर, और [[चरित्र (कंप्यूटिंग)]] के स्ट्रिंग (कंप्यूटर विज्ञान) का समर्थन करती थीं। कंक्रीट डेटाटाइप्स का प्रतिनिधित्व उनके नाम के हिस्से के रूप में होता है।<ref name="stroustrup-ch3-65">{{cite book
}}</ref> एक स्पष्ट विशेषता बड़ी परियोजनाओं को भौतिक रूप से अलग-अलग [[कम्प्यूटर फाइल|कम्प्यूटर फाइलों]] में विभाजित करना था। और कम स्पष्ट विशेषता वाली विस्तृत परियोजनाओं को निश्चित डेटाटाइप्स में तार्किक रूप से विभाजित करना था।<ref name="cpl_3rd-ch2-38"/> उस समय, भाषाएं स्केलर डेटाटाइप जैसे पूर्णांक संख्या, फ्लोटिंग-पॉइंट संख्या और वर्णों के स्ट्रिंग का समर्थन करती थीं। डेटाटाइप्स का प्रतिनिधित्व उनके नाम के भाग के रूप में होता है।<ref name="stroustrup-ch3-65">{{cite book
   | last = Stroustrup
   | last = Stroustrup
   | first = Bjarne
   | first = Bjarne
Line 218: Line 180:
   | page = 65
   | page = 65
   | isbn = 978-0-321-56384-2
   | isbn = 978-0-321-56384-2
}}</ref> अमूर्त डेटाटाइप ठोस डेटाटाइप के रिकॉर्ड (कंप्यूटर विज्ञान) हैं - एक नए नाम के साथ। उदाहरण के लिए, पूर्णांकों की [[सूची (सार डेटा प्रकार)]] को कॉल किया जा सकता है <code>integer_list</code>.
}}</ref> संक्षिप्त डेटाटाइप स्थिर डेटाटाइप्स की संरचनाएं हैं जिनको एक नए नाम उदाहरण के लिए, पूर्णांकों की सूची को <code>integer_list</code> कहा जा सकता है। वस्तु- उन्मुख भाषाएं मॉडल उपसमुच्चय /सुपरसेट संबंधों के लिए एक सिंटैक्स का समर्थन करती हैं। समुच्चय सिद्धांत में, एक उपसमुच्चय  का एक भाग उपसमुच्चय में निहित सभी विशेषताओं को प्राप्त करता है। उदाहरण के लिए, एक छात्र एक व्यक्ति है। इसलिए, छात्रों का समुच्चय व्यक्तियों के समुच्चय का एक उपसमुच्चय है। जिसके परिणाम स्वरूप, छात्रों को सभी व्यक्तियों के लिए सामान्य सभी गुण मिलते हैं। इसके अतिरिक्त, छात्रों के पास अद्वितीय गुण होते हैं जो अन्य व्यक्तियों के पास नहीं होते हैं। वस्तु-उन्मुख भाषाएँ इनहेरिटेंस का उपयोग करते हुए उपसमुच्चय /सुपरसेट संबंधों को मॉडल करती हैं।<ref name="cpl_3rd-ch8-193">{{cite book
 
वस्तु-उन्मुख शब्दजाल में, अमूर्त डेटाटाइप्स को [[वर्ग (कंप्यूटर प्रोग्रामिंग)]] कहा जाता है। हालाँकि, एक वर्ग केवल एक परिभाषा है; कोई स्मृति आवंटित नहीं की जाती है। जब किसी वर्ग को स्मृति आवंटित की जाती है, तो उसे [[वस्तु (कंप्यूटर विज्ञान)]] कहा जाता है।<ref name="cpl_3rd-ch8-193">{{cite book
   | last = Wilson
   | last = Wilson
   | first = Leslie B.
   | first = Leslie B.
Line 229: Line 189:
}}</रेफरी>
}}</रेफरी>


ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग | क्लास की आवश्यकता और सुरक्षित [[कार्यात्मक प्रोग्रामिंग]] की आवश्यकता को मिलाकर ऑब्जेक्ट-ओरिएंटेड अनिवार्य भाषाएं विकसित की गईं।<ref name="cpl_3rd-ch2-39">{{cite book
ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग | क्लास की आवश्यकता और सुरक्षित [[कार्यात्मक प्रोग्रामिंग]] की आवश्यकता को मिलाकर ऑब्जेक्ट-ओरिएंटेड अनिवार्य भाषाएं विकसित की गईं।<nowiki><ref name="cpl_3rd-ch2-39"></nowiki>{{cite book
   | last = Wilson
   | last = Wilson
   | first = Leslie B.
   | first = Leslie B.
Line 236: Line 196:
   | page = 39
   | page = 39
   | isbn = 0-201-71012-9
   | isbn = 0-201-71012-9
}}</ref> ऑब्जेक्ट-ओरिएंटेड भाषा में एक फंक्शन, एक क्लास को असाइन किया जाता है। एक असाइन किए गए फ़ंक्शन को तब [[विधि (कंप्यूटर प्रोग्रामिंग)]], विधि (कंप्यूटर प्रोग्रामिंग) # सी ++ में सदस्य फ़ंक्शन या [[ऑपरेशन (गणित)]] के रूप में संदर्भित किया जाता है। वस्तु-उन्मुख प्रोग्रामिंग वस्तुओं पर संचालन को अंजाम दे रही है।<ref name="cpl_3rd-ch2-35">{{cite book
}}</ref> 1990 के दशक के अंत से वस्तु-उन्मुख प्रोग्रामिंग प्रमुख भाषा सिंटेक्स बन गई है।<ref name="cpl_3rd-ch2-38" />  
  | last = Wilson
  | first = Leslie B.
  | title = तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण| publisher = Addison-Wesley
  | year = 2001
  | page = 35
  | isbn = 0-201-71012-9
}}</रेफरी>
 
ऑब्जेक्ट-ओरिएंटेड भाषाएं मॉडल सबसेट | सबसेट/सुपरसेट संबंधों के सिंटैक्स का समर्थन करती हैं। [[समुच्चय सिद्धान्त]] में, एक सबसेट का एक [[तत्व (गणित)]] सुपरसेट में निहित सभी विशेषताओं को प्राप्त करता है। उदाहरण के लिए, एक छात्र एक व्यक्ति है। इसलिए, छात्रों का समुच्चय व्यक्तियों के समुच्चय का एक उपसमुच्चय है। नतीजतन, छात्रों को सभी व्यक्तियों के लिए सामान्य सभी गुण विरासत में मिलते हैं। इसके अतिरिक्त, छात्रों के पास अद्वितीय गुण होते हैं जो अन्य व्यक्तियों के पास नहीं होते हैं। ऑब्जेक्ट-ओरिएंटेड लैंग्वेज [[वंशानुक्रम (वस्तु-उन्मुख प्रोग्रामिंग)]] का उपयोग करके सबसेट/सुपरसेट रिलेशनशिप मॉडल करती हैं।<ref name="cpl_3rd-ch8-192">{{cite book
  | last = Wilson
  | first = Leslie B.
  | title = तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण| publisher = Addison-Wesley
  | year = 2001
  | page = 192
  | isbn = 0-201-71012-9
}}</ref> 1990 के दशक के अंत तक वस्तु-उन्मुख प्रोग्रामिंग प्रमुख भाषा प्रतिमान बन गई।<ref name="cpl_3rd-ch2-38"/>


C++ (1985) को मूल रूप से C with Classes कहा जाता था।<ref name="stroustrup-notes-22">{{cite book
C ++ (1985) को मूल रूप से "C-क्लासेस" कहा जाता था।<ref name="stroustrup-notes-22">{{cite book
   | last = Stroustrup
   | last = Stroustrup
   | first = Bjarne
   | first = Bjarne
Line 262: Line 206:
   | page = 22
   | page = 22
   | isbn = 978-0-321-56384-2
   | isbn = 978-0-321-56384-2
}}</ref> इसे सी (प्रोग्रामिंग लैंग्वेज) | सी की क्षमताओं का विस्तार करने के लिए सिमुला भाषा की वस्तु-उन्मुख सुविधाओं को जोड़कर डिजाइन किया गया था।<ref name="stroustrup-notes-21">{{cite book
}}</ref> इसको सिमुला भाषा की वस्तु-उन्मुख सुविधाओं के साथ संबद्ध करके C की क्षमताओं का विस्तार करने के लिए डिज़ाइन किया गया था।<ref name="stroustrup-notes-21">{{cite book
   | last = Stroustrup
   | last = Stroustrup
   | first = Bjarne
   | first = Bjarne
Line 270: Line 214:
   | page = 21
   | page = 21
   | isbn = 978-0-321-56384-2
   | isbn = 978-0-321-56384-2
}}</ref>
}}</ref> एक वस्तु-उन्मुख मॉड्यूल दो फाइलों से बना होता है। परिभाषा फ़ाइल को <code>''header_file''</code> कहा जाता है। यहाँ एक साधारण एप्लिकेशन में <code>GRADE</code> क्लास के लिए C++ हेडर फ़ाइल दी गई है:
एक ऑब्जेक्ट-ओरिएंटेड मॉड्यूल दो फाइलों से बना होता है। परिभाषा फ़ाइल को [[निर्देश शामिल करें]] कहा जाता है। यहाँ एक साधारण स्कूल एप्लिकेशन में GRADE क्लास के लिए C++ हेडर फ़ाइल दी गई है:
// grade.h
 
// -------
<वाक्यविन्यास लैंग = सीपीपी>
// ग्रेड.एच
// Used to allow multiple source files to include
// -------
// this header file without duplication errors.
 
// ----------------------------------------------
// एकाधिक स्रोत फ़ाइलों को शामिल करने की अनुमति देने के लिए उपयोग किया जाता है
#ifndef GRADE_H
// यह शीर्ष लेख फ़ाइल दोहराव त्रुटियों के बिना।
#define GRADE_H
// -------------------------------------------------------------
#ifndef ग्रेड_एच
class GRADE {
#ग्रेड_एच को परिभाषित करें
public:
 
    // This is the constructor operation.
कक्षा ग्रेड {
    // ----------------------------------
जनता:
    GRADE ( const char letter );
    // यह कंस्ट्रक्टर ऑपरेशन है।
    // -----------------------------------
    // This is a class variable.
    ग्रेड (स्थिरांक चार अक्षर);
    // -------------------------
 
    char letter;
    // यह एक वर्ग चर है।
    // -------------------------
    // This is a member operation.
    चार पत्र;
    // ---------------------------
 
    int grade_numeric( const char letter );
    // यह एक सदस्य ऑपरेशन है।
    // ---------------------------
    // This is a class variable.
    int ग्रेड_न्यूमेरिक (कास्ट चार अक्षर);
    // -------------------------
 
    int numeric;
    // यह एक वर्ग चर है।
};
    // -------------------------
#endif
    इंट न्यूमेरिक;
[[कंस्ट्रक्टर (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग)|वस्तु-उन्मुख प्रोग्रामिंग]] ऑपरेशन एक फंक्शन है जिसका नाम क्लास के नाम के समान है।<ref name="stroustrup-ch2-49">{{cite book
};
#अगर अंत
</वाक्यविन्यास हाइलाइट>
 
एक [[कंस्ट्रक्टर (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग)]] ऑपरेशन एक फंक्शन है जिसका नाम क्लास के नाम के समान है।<ref name="stroustrup-ch2-49">{{cite book
   | last = Stroustrup
   | last = Stroustrup
   | first = Bjarne
   | first = Bjarne
Line 312: Line 251:
   | page = 49
   | page = 49
   | isbn = 978-0-321-56384-2
   | isbn = 978-0-321-56384-2
}}</ref> इसे तब निष्पादित किया जाता है जब कॉलिंग ऑपरेशन निष्पादित होता है <code>new</code> कथन।
}}</ref> इसे तब निष्पादित किया जाता है जब कॉलिंग ऑपरेशन <code>new</code> स्टेटमेंट को निष्पादित करता है। एक मॉड्यूल की अन्य फाइल स्रोत कोड है। जहाँ एक साधारण एप्लिकेशन में <code>GRADE</code> क्लास के लिए सी ++ स्रोत फ़ाइल है:
 
// grade.cpp
एक मॉड्यूल की अन्य फाइल स्रोत कोड है। यहाँ एक साधारण स्कूल एप्लिकेशन में GRADE क्लास के लिए C++ स्रोत फ़ाइल है:
// ---------
 
#include "grade.h"
<वाक्यविन्यास लैंग = सीपीपी>
// ग्रेड.सीपीपी
GRADE::GRADE( const char letter )
// ---------
{
# ग्रेड शामिल करें। एच
    // Reference the object using the keyword 'this'.
 
    // ----------------------------------------------
ग्रेड :: ग्रेड ( स्थिरांक वर्ण पत्र )
    this->letter = letter;
{
    // कीवर्ड 'यह' का उपयोग करके ऑब्जेक्ट का संदर्भ लें।
    // This is Temporal Cohesion
    // -------------------------------------------------------------
    // -------------------------
    यह-> पत्र = पत्र;
    this->numeric = grade_numeric( letter );
 
}
    // यह टेम्पोरल सामंजस्य है
    // -------------------------
int GRADE::grade_numeric( const char letter )
    यह->संख्यात्मक = ग्रेड_संख्यात्मक (पत्र);
{
}
    if ( ( letter == 'A' || letter == 'a' ) )
 
        return 4;
int ग्रेड :: ग्रेड_न्यूमेरिक ( कास्ट चार अक्षर )
    else
{
    if ( ( letter == 'B' || letter == 'b' ) )
    अगर ((अक्षर == 'ए' || अक्षर == 'ए'))
        return 3;
        वापसी 4;
    else
    अन्य
    if ( ( letter == 'C' || letter == 'c' ) )
    अगर ((पत्र == 'बी' || पत्र == 'बी'))
        return 2;
        वापसी 3;
    else
    अन्य
    if ( ( letter == 'D' || letter == 'd' ) )
    अगर ((पत्र == 'सी' || पत्र == 'सी'))
        return 1;
        वापसी 2;
    else
    अन्य
    if ( ( letter == 'F' || letter == 'f' ) )
    अगर ((अक्षर == 'डी' || अक्षर == 'डी'))
        return 0;
        वापसी 1;
    else
    अन्य
        return -1;
    अगर ((पत्र == 'एफ' || पत्र == 'एफ'))
}
        वापसी 0;
यहाँ एक साधारण एप्लिकेशन में <code>PERSON</code> क्लास के लिए C++ एक हेडर फाइल है:
    अन्य
// person.h
        वापसी -1;
// --------
}
#ifndef PERSON_H
</वाक्यविन्यास हाइलाइट>
#define PERSON_H
 
यहाँ एक साधारण स्कूल एप्लिकेशन में PERSON क्लास के लिए C++ हेडर फाइल है:
class PERSON {
 
public:
<वाक्यविन्यास लैंग = सीपीपी>
    PERSON ( const char *name );
// व्यक्ति। एच
    const char *name;
// --------
};
#ifndef PERSON_H
#endif
#PERSON_H को परिभाषित करें
यहाँ एक साधारण एप्लिकेशन में <code>''STUDENT''</code> क्लास के लिए सी ++ स्रोत फ़ाइल है:
 
// student.cpp
वर्ग व्यक्ति {
// -----------
जनता:
#include "student.h"
    व्यक्ति (स्थिरांक चार * नाम);
#include "person.h"
    कास्ट चार * नाम;
};
STUDENT::STUDENT ( const char *name ):
#अगर अंत
    // Execute the constructor of the PERSON superclass.
</वाक्यविन्यास हाइलाइट>
    // -------------------------------------------------
 
    PERSON( name )
यहाँ एक साधारण स्कूल एप्लिकेशन में PERSON वर्ग के लिए C++ स्रोत फ़ाइल है:
{
 
    // Nothing else to do.
<वाक्यविन्यास लैंग = सीपीपी>
    // -------------------
// व्यक्ति। सीपीपी
}
// ----------
यहाँ एक साधारण एप्लिकेशन में <code>PERSON</code> क्लास के लिए सी ++ स्रोत फ़ाइल है:
#शामिल व्यक्ति
// person.cpp
 
// ----------
व्यक्ति :: व्यक्ति ( स्थिरांक चार * नाम )
#include "person.h"
{
    यह-> नाम = नाम;
PERSON::PERSON ( const char *name )
}
{
</वाक्यविन्यास हाइलाइट>
    this->name = name;
 
}
यहाँ एक साधारण स्कूल एप्लिकेशन में छात्र वर्ग के लिए C++ हेडर फाइल है:
यहाँ स्पष्टीकरण के लिए एक <code>''grade''</code> प्रोग्राम है:
 
// student.h
<वाक्यविन्यास लैंग = सीपीपी>
// ---------
// छात्र। एच
#ifndef STUDENT_H
// ---------
#define STUDENT_H
#ifndef STUDENT_H
#छात्र_एच को परिभाषित करें
#include "person.h"
 
#include "grade.h"
#शामिल व्यक्ति
# ग्रेड शामिल करें। एच
// A STUDENT is a subset of PERSON.
 
// --------------------------------
// एक छात्र व्यक्ति का एक सबसेट है।
class STUDENT : public PERSON{
//--------------------------------
public:
कक्षा छात्र : सार्वजनिक व्यक्ति {
    STUDENT ( const char *name );
जनता:
    GRADE *grade;
    छात्र (स्थिरांक चार * नाम);
};
    ग्रेड * ग्रेड;
#endif
};
यहाँ एक साधारण एप्लिकेशन में <code>''STUDENT_class''</code> के लिए सी ++ स्रोत फ़ाइल है:
#अगर अंत
// student.cpp
</वाक्यविन्यास हाइलाइट>
// -----------
 
#include "student.h"
यहाँ एक साधारण स्कूल एप्लिकेशन में छात्र वर्ग के लिए C++ स्रोत फ़ाइल है:
#include "person.h"
 
<वाक्यविन्यास लैंग = सीपीपी>
STUDENT::STUDENT ( const char *name ):
// छात्र.सीपीपी
    // Execute the constructor of the PERSON superclass.
// -----------
    // -------------------------------------------------
#छात्र शामिल करें
    PERSON( name )
#शामिल व्यक्ति
{
 
    // Nothing else to do.
छात्र :: छात्र ( स्थिरांक चार * नाम ):
    // -------------------
    // PERSON सुपर क्लास के कंस्ट्रक्टर को निष्पादित करें।
}
    //------------------------------------------------ -
यहाँ स्पष्टीकरण के लिए एक कंप्यूटर सॉफ़्टवेयर प्रोग्राम है:
    व्यक्ति (नाम)
// student_dvr.cpp
{
// ---------------
    // और कुछ करने के लिए नहीं है।
#include <iostream>
    // -------------------
#include "student.h"
}
</वाक्यविन्यास हाइलाइट>
int main( void )
 
{
यहाँ प्रदर्शन के लिए एक ड्राइवर कार्यक्रम है:
    STUDENT *student = new STUDENT( "The Student" );
 
    student->grade = new GRADE( 'a' );
<वाक्यविन्यास लैंग = सीपीपी>
// छात्र_डीवीआर.सीपीपी
    std::cout
// ---------------
        // Notice student inherits PERSON's name
#शामिल <iostream>
        << student->name
#छात्र शामिल करें
        << ": Numeric grade = "
 
        << student->grade->numeric
पूर्णांक मुख्य (शून्य)
        << "\n";
{
return 0;
    छात्र * छात्र = नया छात्र (छात्र);
}
    छात्र-> ग्रेड = नया ग्रेड ('ए');
यहाँ सब कुछ कंपाइल करने के लिए एक [[mac|मेकफ़ाइल]] है:
 
# makefile
    एसटीडी :: अदालत
# --------
        // सूचना छात्र को PERSON का नाम विरासत में मिला है
all: student_dvr
        << छात्र-> नाम
        <<: संख्यात्मक ग्रेड =
clean:
        << छात्र->ग्रेड->संख्यात्मक
    rm student_dvr *.o
        << \n;
वापसी 0;
student_dvr: student_dvr.cpp grade.o student.o person.o
}
    सी ++ student_dvr.cpp grade.o student.o person.o -o student_dvr
</वाक्यविन्यास हाइलाइट>
 
grade.o: grade.cpp grade.h
यहाँ सब कुछ संकलित करने के लिए एक [[mac]] है:
    सी ++ -c grade.cpp
 
<वाक्यविन्यास लैंग = मेक>
student.o: student.cpp student.h
#मेकफाइल
    सी ++ -c student.cpp
#-------
सब: छात्र_डीवीआर
person.o: person.cpp person.h
 
    सी ++ -c person.cpp
साफ़:
    आरएम छात्र_डीवीआर *.ओ
 
छात्र_डीवीआर: छात्र_डीवीआर.सीपीपी ग्रेड.ओ छात्र.ओ व्यक्ति.ओ
    सी ++ छात्र_डीवीआर.सीपीपी ग्रेड.ओ छात्र.ओ व्यक्ति.ओ -ओ छात्र_डीवीआर
 
ग्रेड.ओ: ग्रेड.सीपीपी ग्रेड.एच
    सी ++ -सी ग्रेड.सीपीपी
 
छात्र.ओ: छात्र.सीपीपी छात्र.एच
    सी ++ -सी छात्र.सीपीपी
 
व्यक्ति.ओ: व्यक्ति.सीपीपी व्यक्ति.एच
    सी ++ -सी व्यक्ति। सीपीपी
</वाक्यविन्यास हाइलाइट>


== यह भी देखें ==
== यह भी देखें ==
* कार्यात्मक प्रोग्रामिंग
* फंक्शन प्रोग्रामिंग
* [[प्रोग्रामिंग प्रतिमानों की तुलना]]
* [[प्रोग्रामिंग प्रतिमानों की तुलना|प्रोग्रामिंग सिंटेक्स की तुलना]]
* [[प्रतिक्रियाशील प्रोग्रामिंग]]
* [[प्रतिक्रियाशील प्रोग्रामिंग|प्रतिक्रियात्मक प्रोग्रामिंग]]
* [[प्रोग्रामिंग भाषाओं का इतिहास]]
* [[प्रोग्रामिंग भाषाओं का इतिहास]]
* श्रेणी के अनुसार प्रोग्रामिंग भाषाओं की सूची# अनिवार्य भाषाएं
* श्रेणी के अनुसार प्रोग्रामिंग भाषाओं की सूची# इम्पेरेटिव भाषाएं


==टिप्पणियाँ==
==टिप्पणियाँ==
{{Reflist|group=note}}
{{Reflist|group=note}}
==संदर्भ==
==संदर्भ==
{{Reflist}}
{{Reflist}}
Line 484: Line 406:
* Sebesta, Robert W. ''Concepts of Programming Languages'', 3rd ed. Reading, Mass.: Addison-Wesley Publishing Company, 1996.
* Sebesta, Robert W. ''Concepts of Programming Languages'', 3rd ed. Reading, Mass.: Addison-Wesley Publishing Company, 1996.


<!-- Reduced license notice by special permission of Stan Seibert, see Talk -->
: ''Originally based on the article 'Imperative programming' by Stan Seibert, from [[Nupedia]], licensed under the [[GNU Free Documentation License]].''
: ''Originally based on the article 'Imperative programming' by Stan Seibert, from [[Nupedia]], licensed under the [[GNU Free Documentation License]].''
{{Types of programming languages}}


{{Authority control}}
{{Authority control}}


{{DEFAULTSORT:Imperative Programming}}
{{DEFAULTSORT:Imperative Programming}}
<!--Categories-->[[Category: प्रोग्रामिंग प्रतिमान]]




[[Category: Machine Translated Page]]
[[Category:All articles needing additional references|Imperative Programming]]
[[Category:Created On 17/02/2023]]
[[Category:Articles needing additional references from October 2011|Imperative Programming]]
[[Category:CS1 English-language sources (en)]]
[[Category:Collapse templates|Imperative Programming]]
[[Category:Created On 17/02/2023|Imperative Programming]]
[[Category:Lua-based templates|Imperative Programming]]
[[Category:Machine Translated Page|Imperative Programming]]
[[Category:Navigational boxes| ]]
[[Category:Navigational boxes without horizontal lists|Imperative Programming]]
[[Category:Pages with reference errors]]
[[Category:Pages with script errors|Imperative Programming]]
[[Category:Short description with empty Wikidata description|Imperative Programming]]
[[Category:Sidebars with styles needing conversion|Imperative Programming]]
[[Category:Template documentation pages|Documentation/doc]]
[[Category:Templates Vigyan Ready|Imperative Programming]]
[[Category:Templates generating microformats|Imperative Programming]]
[[Category:Templates that add a tracking category|Imperative Programming]]
[[Category:Templates that are not mobile friendly|Imperative Programming]]
[[Category:Templates that generate short descriptions|Imperative Programming]]
[[Category:Templates using TemplateData|Imperative Programming]]
[[Category:Wikipedia metatemplates|Imperative Programming]]
[[Category:प्रोग्रामिंग प्रतिमान|Imperative Programming]]

Latest revision as of 17:25, 28 August 2023

Programming paradigms

कंप्यूटर विज्ञान में, इम्पेरेटिव प्रोग्रामिंग सॉफ़्टवेयर का एक प्रोग्रामिंग सिंटेक्स है जो प्रोग्राम की स्थिति को परिवर्तित करने वाले सिंटेक्स का उपयोग करता है। उसी प्रकार जिस प्रकार से प्राकृतिक भाषाए इम्पेरेटिव कमांड (कंप्यूटिंग) को व्यक्त करती है एक इम्पेरेटिव प्रोग्रामिंग में कंप्यूटर के प्रदर्शन के लिए कमांड होते हैं। इम्पेरेटिव प्रोग्रामिंग यह वर्णन करने पर केंद्रित होती है कि एक प्रोग्राम अपने अपेक्षित परिणामों के उच्च-स्तरीय विवरणों के अतिरिक्त चरण दर को कैसे संचालित करता है।[1]

इस शब्द का प्रयोग प्रायः निर्दिष्ट प्रोग्रामिंग के विपरीत किया जाता है जो इस विषय पर ध्यान केंद्रित करती है कि प्रोग्राम को परिणाम कैसे प्राप्त करना चाहिए और इसके सभी विवरणों को निर्दिष्ट किए बिना प्रोग्राम को कैसे पूर्ण जा सकता है।[2]

इम्पेरेटिव और प्रक्रियात्मक प्रोग्रामिंग

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

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

तर्काधार (रेशनल) और इम्पेरेटिव प्रोग्रामिंग की नींव

लगभग सभी कंप्यूटरों मे प्रोग्राम बनाने के लिए उपयोग किए जाने वाले प्रोग्रामिंग सिंटेक्स समान्यतः एक इम्पेरेटिव मॉडल का अनुसरण करते हैं।[note 1] डिजिटल कंप्यूटर हार्डवेयर को मशीन कोड मे निष्पादित करने के लिए डिज़ाइन किया गया है जो कंप्यूटर के लिए मूल सिंटेक्स है जो समान्यतः इम्पेरेटिव प्रोग्रामिंग भाषा में लिखा जाता है, हालांकि अन्य सिंटेक्स का उपयोग करने वाले निम्न-स्तरीय कंपाइलर कुछ संरचनात्मक लिस्प मशीन मे सम्मिलित हैं।

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

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

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

प्रारंभिक इम्पेरेटिव भाषाएँ मूल कंप्यूटरों की मशीनी भाषाएँ थीं। इन भाषाओं में सिंटेक्स बहुत सरल थे, जो हार्डवेयर कार्यान्वयन को आसान बनाते थे लेकिन जटिल प्रोग्रामों के निर्माण में अवरोध उत्पन्न करते थे। 1954 में अंतर्राष्ट्रीय व्यवसाय मशीन (आईबीएम) में जॉन बैकस द्वारा विकसित फोरट्रान, जटिल प्रोग्रामों के निर्माण में मशीन कोड द्वारा प्रस्तुत अवरोधों को दूर करने वाली पहली प्रमुख प्रोग्रामिंग भाषा थी। फोरट्रान एक संकलित भाषा थी जो नामांकित वेरिएबल, जटिल प्रोग्राम और कई अन्य विशेषताओं की स्वीकृति देती थी जो अब इम्पेरेटिव भाषाओं में सामान्य हैं। अगले दो दशकों में कई अन्य प्रमुख उच्च-स्तरीय इम्पेरेटिव प्रोग्रामिंग भाषाओं का विकास हुआ। 1950 और 1960 के दशक के अंत में, ऐल्गॉल को गणितीय एल्गोरिदम को अधिक आसानी से अभिव्यक्त करने की स्वीकृति देने के लिए विकसित किया गया था और यहां तक ​​कि कुछ कंप्यूटरों के लिए ऑपरेटिंग सिस्टम की लक्ष्य भाषा के रूप में भी कार्य किया गया था। एमयूएमपीएस (1966) ने इम्पेरेटिव सिंटेक्स को एक तार्किक रूप तक प्रदर्शित किया था जो किसी भी प्रकार के सिंटेक्स न देकर, पूर्ण रूप से कमांड पर निर्धारित थे यहाँ तक कि IF और ELSEकमांड को एक दूसरे से स्वतंत्र बनाने की सीमा तक, केवल $ नाम के एक आंतरिक वेरिएबल से जुड़ा हुआ है। कोबोल (1960) और बेसिक (1964) दोनों प्रोग्रामिंग सिंटैक्स को अंग्रेजी की तरह बनाने के प्रयास थे। 1970 के दशक में, पास्कल (प्रोग्रामिंग भाषा) निकोलस विर्थ द्वारा विकसित किया गया था और C को डेनिस रिची द्वारा बनाया गया था, जब वह बेल प्रयोगशालाओं में कार्य कर रहे थे। तब विर्थ ने मोडुला-2 और ओबेरोन को डिजाइन किया। संयुक्त राज्य अमेरिका के सुरक्षा विभाग की आवश्यकताओ के लिए, जीन इचबियाह और हनीवेल के समूह ने भाषा के लिए आवश्यकताओं को परिभाषित करने के लिए 4 साल की परियोजना के बाद 1978 में एडा (प्रोग्रामिंग भाषा) को डिजाइन करना प्रारम्भ किया। विनिर्देश पहली बार 1983 में 1995, 2005 और 2012 में संशोधन के साथ प्रकाशित हुआ था।

1980 के दशक में वस्तु-उन्मुख प्रोग्रामिंग में रुचि में तीव्रता से वृद्धि देखी गई। ये भाषाएँ शैली में इम्पेरेटिव थीं, लेकिन वस्तुओं का समर्थन करने के लिए इसमे अन्य सुविधाएँ संबद्ध की गईं थी। 20वीं शताब्दी के अंतिम दो दशकों में ऐसी कई भाषाओं का विकास हुआ। स्मॉलटाक -80, मूल रूप से 1969 में एलन के द्वारा परिकल्पित, 1980 में ज़ेरॉक्स पालो ऑल्टो शोध संस्थान (पीएआरसी) द्वारा प्रारम्भ किया गया था। एक अन्य वस्तु-उन्मुख प्रोग्रामिंग भाषा में अवधारणाओं से आरेखण "सिमुला" जिसे विश्व की पहली वस्तु-उन्मुख प्रोग्रामिंग भाषा माना जाता है, जिसे 1960 के दशक में विकसित किया गया था -बज़्ने स्ट्रॉस्ट्रुप ने C ++ पर आधारित एक वस्तु-उन्मुख भाषा C ++ को डिजाइन किया था। C++ का डिजाइन 1979 में प्रारम्भ हुआ था। और पहला कार्यान्वयन 1983 में पूर्ण हुआ।

1980 और 1990 के दशक के अंत में, वस्तु-उन्मुख अवधारणाओं पर चित्रित उल्लेखनीय इम्पेरेटिव भाषा पर्ल प्रोग्रामिंग भाषा थीं जिसे 1987 में लैरी वॉल द्वारा प्रारम्भ किया गया था पायथन को 1990 में गुइडो वैन रोसुम द्वारा प्रारम्भ किया गया था विजुअल बेसिक और विजुअल C ++ जिसमें माइक्रोसॉफ्ट फाउंडेशन क्लास लाइब्रेरी (एमएफसी) 2.0 सम्मिलित है, जिसको माइक्रोसॉफ्ट द्वारा क्रमशः 1991 और 1993 में प्रारम्भ किया गया था 1994 में रासमस लेर्डोर्फ द्वारा प्रारम्भ पीएचपी, जावा (प्रोग्रामिंग भाषा) 1995 में जेम्स गोस्लिंग (सन माइक्रोसिस्टम्स) द्वारा,जावास्क्रिप्ट, ब्रेंडन ईच (नेटस्केप) द्वारा और रूबी (प्रोग्रामिंग भाषा), युकीहिरो "मैट्ज़" मात्सुमोतो द्वारा, दोनों 1995 में प्रारम्भ की गयी थी माइक्रोसॉफ्ट का डॉटनेट फ्रेमवर्क (2002) इसके मूल में इम्पेरेटिव है, क्योंकि इसकी मुख्य लक्ष्य भाषाएँ हैं, वीबी डॉटनेट और C# जो माइक्रोसॉफ्ट डॉटनेट पर आधारित हैं हालाँकि माइक्रोसॉफ्ट की एफ#, एक कार्यात्मक भाषा भी इस पर आधारित है।

उदाहरण

फोरट्रान

फोरट्रान (1958) को "आईबीएम गणितीय सूत्र अनुवाद प्रणाली" के रूप में प्रस्तुत किया गया था। इसको स्ट्रिंग (कंप्यूटर विज्ञान) सुविधाओं के अतिरिक्त, वैज्ञानिक गणनाओं के लिए डिज़ाइन किया गया था। निर्दिष्ट (कंप्यूटर प्रोग्रामिंग), प्रक्रियात्मक प्रोग्रामिंग और स्टेटमेंट (कंप्यूटर विज्ञान) के साथ, यह समर्थित है:

यह सफल हुआ क्योंकि:

  • प्रोग्रामिंग और डिबगिंग (दोष मार्जन) लागत कंप्यूटर की लागत से कम थी।
  • यह आईबीएम द्वारा समर्थित था।
  • उस समय के अनुप्रयोग वैज्ञानिक द्वारा किए जाते थे।
  • अमेरिकी सुरक्षा विभाग ने कोबोल के विकास को प्रभावित किया था जिसमें ग्रेस हूपर का प्रमुख योगदान था। हालांकि, गैर आईबीएम विक्रेताओं ने भी फोरट्रान कंपाइलर प्रोग्राम लिखे, लेकिन एक सिंटैक्स के साथ जो संभवतः आईबीएम के कंपाइलर को विफल कर डेटा था अमेरिकी राष्ट्रीय मानक संस्थान (एएनएसआई) ने 1966 में पहला फोरट्रान मानक विकसित किया। और 1978 में, फोरट्रान-77 फोरट्रान 90 समर्थन करता था।[4][5]
  • अभिलेख
  • सरणियों के लिए संकेत

कोबोल

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

कोबोल के विकास को दृढ़ता से नियंत्रित किया गया था इसलिए एएनएसआई मानकों की आवश्यकता के लिए भाषाओं का विकास नहीं हुआ। इसके परिणामस्वरूप, इसे 1974 तक 15 वर्षों तक नहीं परिवर्तित किया गया। 1990 के दशक मे वस्तु-उन्मुख प्रोग्रामिंग संस्करण मे कई परिणामी परिवर्तन किए गए थे।[5]

ऐल्गॉल

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

  • ब्लॉक संरचना, जहाँ वेरिएबल उनके ब्लॉक के लिए स्थानीय थे।
  • ऐरे के साथ वेरिएबल
  • "फार" लूप
  • फंक्शन
  • रिकर्शन फंक्शन

ऐल्गॉल के प्रत्यक्ष संस्कारण में पास्कल, मोडुला-2, एडा, डेल्फी और ओबेरॉन आदि प्रोग्रामिंग भाषाए सम्मिलित हैं। दूसरे संस्कारण में C, C++ और जावा प्रोग्रामिंग भाषाए सम्मिलित है।

C (प्रोग्रामिंग भाषा)

C प्रोग्रामिंग भाषा को 1973 मे इसका नाम विकसित किया गया क्योंकि भाषा बीसीपीएल को बी से परिवर्तित कर दिया गया था और एटी और टी बेल लैब्स ने अगले संस्करण को "C" कहा है इसका उद्देश्य यूनिक्स ऑपरेटिंग सिस्टम को लिखना था।[6] C एक अपेक्षाकृत छोटी प्रोग्रामिंग भाषा है जिससे कंपाइलर लिखना आसान हो जाता है। इसकी वृद्धि ने 1980 के दशक में हार्डवेयर विकास को प्रतिबिम्बित किया। इसकी वृद्धि इसलिए भी हुई क्योंकि इसमें असेंबली भाषा की सुविधाएं हैं, लेकिन यह उच्च स्तरीय सिंटैक्स का उपयोग करता है। इसमें अन्य नए संस्कारण की सुविधाएँ सम्मिलित हैं जैसे:

  • इनलाइन असेंबलर
  • गणितीय पॉइंटर्स
  • फंक्शन संकेत
  • बिट ऑपरेशंस
  • C और C ++ में स्वतंत्र रूप से जटिल ऑपरेटरों का संयोजन[7]
कंप्यूटर मेमोरी मानचित्र

C प्रोग्रामर को यह नियंत्रित करने की स्वीकृति देता है कि मेमोरी डेटा के किस एड्रेस को संग्रहित किया जाना है। ग्लोबल वेरिएबल्स और स्टैटिक वेरिएबल्स को स्थित करने के लिए सबसे कम भंडारण की आवश्यकता होती है। कॉल स्टैक स्वचालित रूप से मानक वेरिएबल निर्दिष्ट कंप्यूटर प्रोग्रामिंग के लिए उपयोग किया जाता है। हीप मेमोरी को malloc() फ़ंक्शन से एक पॉइंटर वैरिएबल में वापस किया जाता है।

  • ग्लोबल और स्थैतिक डेटा प्रोग्राम के ठीक ऊपर स्थित है। प्रोग्राम को तकनीकी रूप से टेक्स्ट कहा जाता है। यह वह कारण है जहां मशीन निर्देश संग्रहीत होते हैं।
  • ग्लोबल और स्थैतिक डेटा एड्रेस तकनीकी रूप से दो एड्रेस हैं।[8] एक एड्रेस को प्रारंभ डेटा खंड कहा जाता है, जहाँ डिफॉल्ट मान के साथ निर्धारित किए गए वेरिएबल स्थित किए जाते हैं। दूसरे एड्रेस को बीएसएस कहा जाता है, जहां डिफॉल्ट मान के बिना निर्धारित किए गए वेरिएबल स्थित किए जाते हैं
  • ग्लोबल और स्थैतिक डेटा एड्रेस में संग्रहीत वेरिएबल का मेमोरी एड्रेस रन-टाइम पर निर्भर होता है। वे प्रक्रिया के पूरे रन-टाइम अपने मान को बनाए रखते हैं।
  • ग्लोबल और स्थिर एड्रेस उन वैश्विक वेरिएबल को संग्रहीत करता है जो main() फ़ंक्शन के ऊपर (बाहर) घोषित किए जाते हैं। स्रोत कोड में वैश्विक वेरिएबल main() और हर दूसरे फ़ंक्शन के लिए दृश्यमान हैं।[9]
  • दूसरी ओर, main() अन्य कार्यों के अंदर, या { } ब्लॉक सीमांकक के भीतर वेरिएबल घोषणाएँ स्थानीय वेरिएबल हैं। स्थानीय वेरिएबल में औपचारिक पैरामीटर वेरिएबल भी सम्मिलित हैं। पैरामीटर वेरिएबल फ़ंक्शन परिभाषाओं को { } के भीतर स्थित किया जाता हैं।[10] जो फ़ंक्शन को एक इंटरफ़ेस (कंप्यूटिंग) प्रदान करते हैं।
  • स्थानीय वेरिएबल का उपयोग करके static निर्धारित किया गया है उपसर्ग वैश्विक और स्थैतिक डेटा एड्रेस में भी संग्रहीत होते हैं।[8] वैश्विक वेरिएबल के विपरीत, स्थैतिक वेरिएबल केवल फ़ंक्शन या ब्लॉक में दिखाई देते हैं। स्थैतिक वेरिएबल सदैव अपना मान बनाए रखते हैं। एक उदाहरण फ़ंक्शन int increment_counter(){ static int counter = 0; counter++; return counter;}का उपयोग किया जाता है।
  • स्टैक एड्रेस शीर्ष मेमोरी एड्रेस के पास स्थित मेमोरी का एक सन्निहित ब्लॉक है।[11] विडंबना यह है कि स्टैक में रखे गए वेरिएबल्स ऊपर से नीचे तक भरे जाते हैं।[11] एक स्टैक पॉइंटर एक विशेष प्रोसेसर रजिस्टर है जो अंतिम पॉप्युलेट मेमोरी एड्रेस का नियंत्रित रखता है। असेंबली भाषा PUSH निर्देश के साथ वेरिएबल्स को अतिरिक्त भंडारण के साथ रखा जाता है। इसलिए, इन वेरिएबल्स के एड्रेस रनटाइम के समय नियुक्त किए जाते हैं। स्कोप वेरिएबल्स की यह विधि पीओपी निर्देश के माध्यम से होती है।
  • स्थानीय वेरिएबल निर्दिष्ट किए static उपसर्ग, औपचारिक पैरामीटर वेरिएबल सहित,[12] स्वचालित वेरिएबल कहलाते हैं[9] और भंडारण में एकत्र हो जाते हैं।[8] वे फ़ंक्शन या ब्लॉक के अंदर दिखाई देते हैं और फ़ंक्शन या ब्लॉक से बाहर निकलने पर अपना महत्व नष्ट कर देते हैं।
  • हीप मेमोरी प्रबंधन एड्रेस स्टैक के नीचे स्थित होता है।[8] यह नीचे से ऊपर तक स्वतंत्र रहता है। ऑपरेटिंग सिस्टम हीप पॉइंटर और आवंटित मेमोरी ब्लॉक की सूची का उपयोग करके भंडारण का प्रबंधन करता है।[13] स्टैक की तरह, हीप वेरिएबल के एड्रेस रनटाइम के समय निर्धारित किए जाते हैं। मेमोरी से बाहर त्रुटि तब होती है जब हीप पॉइंटर और स्टैक पॉइंटर संबद्ध होते हैं।
  • C प्रोग्रामिंग हीप मेमोरी आवंटित करने के लिए malloc() लाइब्रेरी फ़ंक्शन प्रदान करती है।[14] डेटा के साथ हीप को सम्मिलित करना एक अतिरिक्त copy; फंक्शन है। हीप में संग्रहीत वेरिएबल आर्थिक रूप से पॉइंटर्स का उपयोग करके लाइब्रेरी फ़ंक्शन मे निर्दिष्ट किए जाते हैं। पॉइंटर्स के अतिरिक्त stack; के माध्यम से डेटा को सम्पूर्ण ब्लॉक फ़ंक्शन में निर्दिष्ट करना होता है।

C++

1970 के दशक में, सॉफ्टवेयर इंजीनियरों को विस्तृत परियोजनाओं को मॉड्यूल में स्थगित करने के लिए भाषा समर्थन की आवश्यकता थी।[15] एक स्पष्ट विशेषता बड़ी परियोजनाओं को भौतिक रूप से अलग-अलग कम्प्यूटर फाइलों में विभाजित करना था। और कम स्पष्ट विशेषता वाली विस्तृत परियोजनाओं को निश्चित डेटाटाइप्स में तार्किक रूप से विभाजित करना था।[15] उस समय, भाषाएं स्केलर डेटाटाइप जैसे पूर्णांक संख्या, फ्लोटिंग-पॉइंट संख्या और वर्णों के स्ट्रिंग का समर्थन करती थीं। डेटाटाइप्स का प्रतिनिधित्व उनके नाम के भाग के रूप में होता है।[16] संक्षिप्त डेटाटाइप स्थिर डेटाटाइप्स की संरचनाएं हैं जिनको एक नए नाम उदाहरण के लिए, पूर्णांकों की सूची को integer_list कहा जा सकता है। वस्तु- उन्मुख भाषाएं मॉडल उपसमुच्चय /सुपरसेट संबंधों के लिए एक सिंटैक्स का समर्थन करती हैं। समुच्चय सिद्धांत में, एक उपसमुच्चय का एक भाग उपसमुच्चय में निहित सभी विशेषताओं को प्राप्त करता है। उदाहरण के लिए, एक छात्र एक व्यक्ति है। इसलिए, छात्रों का समुच्चय व्यक्तियों के समुच्चय का एक उपसमुच्चय है। जिसके परिणाम स्वरूप, छात्रों को सभी व्यक्तियों के लिए सामान्य सभी गुण मिलते हैं। इसके अतिरिक्त, छात्रों के पास अद्वितीय गुण होते हैं जो अन्य व्यक्तियों के पास नहीं होते हैं। वस्तु-उन्मुख भाषाएँ इनहेरिटेंस का उपयोग करते हुए उपसमुच्चय /सुपरसेट संबंधों को मॉडल करती हैं।[17] 1990 के दशक के अंत से वस्तु-उन्मुख प्रोग्रामिंग प्रमुख भाषा सिंटेक्स बन गई है।[15]

C ++ (1985) को मूल रूप से "C-क्लासेस" कहा जाता था।[18] इसको सिमुला भाषा की वस्तु-उन्मुख सुविधाओं के साथ संबद्ध करके C की क्षमताओं का विस्तार करने के लिए डिज़ाइन किया गया था।[19] एक वस्तु-उन्मुख मॉड्यूल दो फाइलों से बना होता है। परिभाषा फ़ाइल को header_file कहा जाता है। यहाँ एक साधारण एप्लिकेशन में GRADE क्लास के लिए C++ हेडर फ़ाइल दी गई है: 

// grade.h
// -------

// Used to allow multiple source files to include
// this header file without duplication errors.
// ----------------------------------------------
#ifndef GRADE_H
#define GRADE_H

class GRADE {
public:
    // This is the constructor operation.
    // ----------------------------------
    GRADE ( const char letter );

    // This is a class variable.
    // -------------------------
    char letter;

    // This is a member operation.
    // ---------------------------
    int grade_numeric( const char letter );

    // This is a class variable.
    // -------------------------
    int numeric;
};
#endif

वस्तु-उन्मुख प्रोग्रामिंग ऑपरेशन एक फंक्शन है जिसका नाम क्लास के नाम के समान है।[20] इसे तब निष्पादित किया जाता है जब कॉलिंग ऑपरेशन new स्टेटमेंट को निष्पादित करता है। एक मॉड्यूल की अन्य फाइल स्रोत कोड है। जहाँ एक साधारण एप्लिकेशन में GRADE क्लास के लिए सी ++ स्रोत फ़ाइल है: 

// grade.cpp
// ---------
#include "grade.h"

GRADE::GRADE( const char letter )
{
    // Reference the object using the keyword 'this'.
    // ----------------------------------------------
    this->letter = letter;

    // This is Temporal Cohesion
    // -------------------------
    this->numeric = grade_numeric( letter );
}

int GRADE::grade_numeric( const char letter )
{
    if ( ( letter == 'A' || letter == 'a' ) )
        return 4;
    else
    if ( ( letter == 'B' || letter == 'b' ) )
        return 3;
    else
    if ( ( letter == 'C' || letter == 'c' ) )
        return 2;
    else
    if ( ( letter == 'D' || letter == 'd' ) )
        return 1;
    else
    if ( ( letter == 'F' || letter == 'f' ) )
        return 0;
    else
        return -1;
}

यहाँ एक साधारण एप्लिकेशन में PERSON क्लास के लिए C++ एक हेडर फाइल है: 

// person.h
// --------
#ifndef PERSON_H
#define PERSON_H

class PERSON {
public:
    PERSON ( const char *name );
    const char *name;
};
#endif

यहाँ एक साधारण एप्लिकेशन में STUDENT क्लास के लिए सी ++ स्रोत फ़ाइल है: 

// student.cpp
// -----------
#include "student.h"
#include "person.h"

STUDENT::STUDENT ( const char *name ):
    // Execute the constructor of the PERSON superclass.
    // -------------------------------------------------
    PERSON( name )
{
    // Nothing else to do.
    // -------------------
}

यहाँ एक साधारण एप्लिकेशन में PERSON क्लास के लिए सी ++ स्रोत फ़ाइल है: 

// person.cpp
// ----------
#include "person.h"

PERSON::PERSON ( const char *name )
{
    this->name = name;
}

यहाँ स्पष्टीकरण के लिए एक grade प्रोग्राम है: 

// student.h
// ---------
#ifndef STUDENT_H
#define STUDENT_H

#include "person.h"
#include "grade.h"

// A STUDENT is a subset of PERSON.
// --------------------------------
class STUDENT : public PERSON{
public:
    STUDENT ( const char *name );
    GRADE *grade;
};
#endif

यहाँ एक साधारण एप्लिकेशन में STUDENT_class के लिए सी ++ स्रोत फ़ाइल है: 

// student.cpp
// -----------
#include "student.h"
#include "person.h"

STUDENT::STUDENT ( const char *name ):
    // Execute the constructor of the PERSON superclass.
    // -------------------------------------------------
    PERSON( name )
{
    // Nothing else to do.
    // -------------------
}

यहाँ स्पष्टीकरण के लिए एक कंप्यूटर सॉफ़्टवेयर प्रोग्राम है: 

// student_dvr.cpp
// ---------------
#include <iostream>
#include "student.h"

int main( void )
{
    STUDENT *student = new STUDENT( "The Student" );
    student->grade = new GRADE( 'a' );

    std::cout 
        // Notice student inherits PERSON's name
        << student->name
        << ": Numeric grade = "
        << student->grade->numeric
        << "\n";
	return 0;
}

यहाँ सब कुछ कंपाइल करने के लिए एक मेकफ़ाइल है: 

# makefile
# --------
all: student_dvr

clean:
    rm student_dvr *.o

student_dvr: student_dvr.cpp grade.o student.o person.o
    सी ++ student_dvr.cpp grade.o student.o person.o -o student_dvr

grade.o: grade.cpp grade.h
    सी ++ -c grade.cpp

student.o: student.cpp student.h
    सी ++ -c student.cpp

person.o: person.cpp person.h
    सी ++ -c person.cpp

यह भी देखें

टिप्पणियाँ

  1. ↑ Reconfigurable computing is a notable exception.

संदर्भ

  1. ↑ Jain, Anisha (2022-12-10). "Javascript Promises— Is There a Better Approach?". Medium (in English). Retrieved 2022-12-20.
  2. ↑ "Imperative programming: Overview of the oldest programming paradigm". IONOS Digitalguide (in English). Retrieved 2022-05-03.
  3. ↑ Bruce Eckel (2006). Thinking in Java. Pearson Education. p. 24. ISBN 978-0-13-187248-6.
  4. ↑ Wilson, Leslie B. (2001). तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण. Addison-Wesley. p. 16. ISBN 0-201-71012-9.</रेफरी> हालांकि, गैर आईबीएम विक्रेताओं ने फोरट्रान कंपाइलर्स भी लिखे, लेकिन एक सिंटैक्स के साथ जो संभवतः आईबीएम के कंपाइलर को विफल कर देगा।अमेरिकी राष्ट्रीय मानक संस्थान (एएनएसआई) ने 1966 में पहला फोरट्रान मानक विकसित किया। 1978 में, फोरट्रान 77 1991 तक मानक बन गया। फोरट्रान 90 समर्थन करता है:

    कोबोल

    कोबोल (1959) कॉमन बिजनेस ओरिएंटेड लैंग्वेज के लिए खड़ा है। फोरट्रान ने प्रतीकों में हेरफेर किया। जल्द ही यह महसूस किया गया कि प्रतीकों को संख्या होने की आवश्यकता नहीं है, इसलिए तार पेश किए गए।<ref name="cpl_3rd-ch2-24">Wilson, Leslie B. (2001). तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण. Addison-Wesley. p. 24. ISBN 0-201-71012-9.

  5. ↑ 5.0 5.1 Cite error: Invalid <ref> tag; no text was provided for refs named cpl_3rd-ch2-30
  6. ↑ Wilson, Leslie B. (2001). तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण. Addison-Wesley. p. 31. ISBN 0-201-71012-9.</रेफरी>

    सी

    C (प्रोग्रामिंग लैंग्वेज) (1973) को इसका नाम इसलिए मिला क्योंकि भाषा BCPL को B (प्रोग्रामिंग लैंग्वेज) से बदल दिया गया था, और Bell Labs|AT&T Bell Labs ने अगला संस्करण C कहा। इसका उद्देश्य UNIX ऑपरेटिंग सिस्टम लिखना था।<ref name="cpl_3rd-ch2-37">Wilson, Leslie B. (2001). तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण. Addison-Wesley. p. 37. ISBN 0-201-71012-9.

  7. ↑ Cite error: Invalid <ref> tag; no text was provided for refs named cpl_3rd-ch2-37
  8. ↑ 8.0 8.1 8.2 8.3 "Memory Layout of C Programs". 12 September 2011.
  9. ↑ 9.0 9.1 Kernighan, Brian W.; Ritchie, Dennis M. (1988). The C Programming Language Second Edition. Prentice Hall. p. 31. ISBN 0-13-110362-8.
  10. ↑ Wilson, Leslie B. (2001). तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण. Addison-Wesley. p. 128. ISBN 0-201-71012-9.
  11. ↑ 11.0 11.1 Kerrisk, Michael (2010). The Linux Programming Interface. No Starch Press. p. 121. ISBN 978-1-59327-220-3.
  12. ↑ Kerrisk, Michael (2010). The Linux Programming Interface. No Starch Press. p. 122. ISBN 978-1-59327-220-3.
  13. ↑ Kernighan, Brian W.; Ritchie, Dennis M. (1988). The C Programming Language Second Edition. Prentice Hall. p. 185. ISBN 0-13-110362-8.
  14. ↑ Kernighan, Brian W.; Ritchie, Dennis M. (1988). The C Programming Language Second Edition. Prentice Hall. p. 187. ISBN 0-13-110362-8.
  15. ↑ 15.0 15.1 15.2 Wilson, Leslie B. (2001). तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण. Addison-Wesley. p. 38. ISBN 0-201-71012-9.
  16. ↑ Stroustrup, Bjarne (2013). The C++ Programming Language, Fourth Edition. Addison-Wesley. p. 65. ISBN 978-0-321-56384-2.
  17. ↑ Wilson, Leslie B. (2001). तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण. Addison-Wesley. p. 193. ISBN 0-201-71012-9.</रेफरी> ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग | क्लास की आवश्यकता और सुरक्षित कार्यात्मक प्रोग्रामिंग की आवश्यकता को मिलाकर ऑब्जेक्ट-ओरिएंटेड अनिवार्य भाषाएं विकसित की गईं।<ref name="cpl_3rd-ch2-39">Wilson, Leslie B. (2001). तुलनात्मक प्रोग्रामिंग भाषाएँ, तीसरा संस्करण. Addison-Wesley. p. 39. ISBN 0-201-71012-9.
  18. ↑ Stroustrup, Bjarne (2013). The C++ Programming Language, Fourth Edition. Addison-Wesley. p. 22. ISBN 978-0-321-56384-2.
  19. ↑ Stroustrup, Bjarne (2013). The C++ Programming Language, Fourth Edition. Addison-Wesley. p. 21. ISBN 978-0-321-56384-2.
  20. ↑ Stroustrup, Bjarne (2013). The C++ Programming Language, Fourth Edition. Addison-Wesley. p. 49. ISBN 978-0-321-56384-2.
  • Pratt, Terrence W. and Marvin V. Zelkowitz. Programming Languages: Design and Implementation, 3rd ed. Englewood Cliffs, N.J.: Prentice Hall, 1996.
  • Sebesta, Robert W. Concepts of Programming Languages, 3rd ed. Reading, Mass.: Addison-Wesley Publishing Company, 1996.
Originally based on the article 'Imperative programming' by Stan Seibert, from Nupedia, licensed under the GNU Free Documentation License.
Retrieved from ‘https://www.vigyanwiki.in/index.php?title=इम्पेरेटिव_प्रोग्रामिंग&oldid=254002’