इम्पेरेटिव प्रोग्रामिंग

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

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

आदेशसूचक और प्रक्रियात्मक प्रोग्रामिंग

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

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

तर्काधार और आदेशसूचक प्रोग्रामिंग की नींव

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

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

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

आदेशसूचक और वस्तु-उन्मुख भाषाओं का इतिहास

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

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

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

उदाहरण

फोरट्रान

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

• सरणी डेटा संरचना
• सबरूटीन्स
• पाश के लिए | लूप करो

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

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

बेसिक ने रीड-इवल-प्रिंट लूप का बीड़ा उठाया।इसने अपने वातावरण में ऑपरेटिंग सिस्टम कमांड की पेशकश की:

• 'नई' कमांड ने एक खाली स्लेट बनाई
• कथनों का तुरंत मूल्यांकन किया जाता है
• कथनों के आगे एक पंक्ति संख्या लगाकर उन्हें क्रमादेशित किया जा सकता है
• 'सूची' कमांड ने प्रोग्राम प्रदर्शित किया
• 'रन' कमांड ने प्रोग्राम को निष्पादित किया

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

• इनलाइन असेंबलर
• पॉइंटर्स पर अंकगणित
• कार्यों के लिए संकेत
• बिट ऑपरेशंस
• सी और सी ++ में जटिल ऑपरेटरों को स्वतंत्र रूप से जोड़ना

कंप्यूटर मेमोरी मैप

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

• वैश्विक और स्थैतिक डेटा क्षेत्र प्रोग्राम क्षेत्र के ठीक ऊपर स्थित है। (प्रोग्राम क्षेत्र को तकनीकी रूप से टेक्स्ट क्षेत्र कहा जाता है। यह वह जगह है जहां मशीन निर्देश संग्रहीत होते हैं।)

• वैश्विक और स्थैतिक डेटा क्षेत्र तकनीकी रूप से दो क्षेत्र हैं। एक क्षेत्र को इनिशियलाइज़्ड डेटा खंड कहा जाता है, जहाँ डिफॉल्ट वैल्यू के साथ डिक्लेयर किए गए वेरिएबल स्टोर किए जाते हैं। दूसरे क्षेत्र को .bss कहा जाता है, जहां डिफॉल्ट वैल्यू के बिना डिक्लेयर किए गए वेरिएबल स्टोर किए जाते हैं।

* वैश्विक और स्थैतिक डेटा क्षेत्र में संग्रहीत वेरिएबल का मेमोरी पता संकलन-समय पर सेट होता है। वे प्रक्रिया के पूरे जीवन भर अपने मूल्यों को बनाए रखते हैं।

• वैश्विक और स्थैतिक क्षेत्र उन वैश्विक चरों को संग्रहीत करता है जो (बाहर) के शीर्ष पर घोषित किए जाते हैं main() समारोह। वैश्विक वेरिएबल दिखाई दे रहे हैं main() और स्रोत कोड में हर दूसरे कार्य।

दूसरी ओर, वेरिएबल घोषणाओं के अंदर main(), अन्य कार्य, या भीतर { } ब्लॉक (प्रोग्रामिंग) स्थानीय वेरिएबल हैं। स्थानीय वेरिएबल में पैरामीटर (कंप्यूटर प्रोग्रामिंग)#पैरामीटर और तर्क वेरिएबल भी सम्मिलित हैं। पैरामीटर वेरिएबल फ़ंक्शन परिभाषाओं के कोष्ठक के भीतर संलग्न हैं। वे फ़ंक्शन को एक इंटरफ़ेस (कंप्यूटिंग) प्रदान करते हैं।

• स्थानीय वेरिएबल का उपयोग करके घोषित किया गया static उपसर्ग वैश्विक और स्थैतिक डेटा क्षेत्र में भी संग्रहीत होते हैं।वैश्विक वेरिएबल के विपरीत, स्थैतिक वेरिएबल केवल फ़ंक्शन या ब्लॉक में दिखाई देते हैं। स्थैतिक वेरिएबल हमेशा अपना मान बनाए रखते हैं। एक उदाहरण उपयोग समारोह होगा int increment_counter(){ static int counter = 0; counter++; return counter;}

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

• स्थानीय वेरिएबल बिना घोषित किए static उपसर्ग, औपचारिक पैरामीटर वेरिएबल सहित, स्वचालित वेरिएबल कहलाते हैंऔर ढेर में जमा हो जाते हैं।वे फ़ंक्शन या ब्लॉक के अंदर दिखाई देते हैं और फ़ंक्शन या ब्लॉक से बाहर निकलने पर अपना दायरा खो देते हैं।

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

• सी प्रदान करता है malloc() सी गतिशील मेमोरी आवंटन हीप मेमोरी के लिए लाइब्रेरी फंक्शन। डेटा के साथ हीप को पॉप्युलेट करना एक अतिरिक्त कॉपी फंक्शन है। हीप में संग्रहीत वेरिएबल आर्थिक रूप से पॉइंटर्स का उपयोग करके कार्यों में पारित किए जाते हैं। पॉइंटर्स के बिना, स्टैक के माध्यम से डेटा के पूरे ब्लॉक को फ़ंक्शन में पास करना होगा।

सी ++

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

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

सी ++ (1985) को मूल रूप से "C with Classes" कहा जाता था। इसे Simula भाषा की वस्तु-उन्मुख सुविधाओं को जोड़कर C की क्षमताओं का विस्तार करने के लिए डिज़ाइन किया गया था।

एक ऑब्जेक्ट-ओरिएंटेड मॉड्यूल दो फाइलों से बना होता है। परिभाषा फ़ाइल को हेडर फ़ाइल कहा जाता है। यहाँ एक साधारण स्कूल एप्लिकेशन में GRADE क्लास के लिए सी ++ हेडर फ़ाइल दी गई है:

// 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

एक कंस्ट्रक्टर (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) ऑपरेशन एक फंक्शन है जिसका नाम क्लास के नाम के समान है। इसे तब निष्पादित किया जाता है जब कॉलिंग ऑपरेशन निष्पादित होता है 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.h
// --------
#ifndef PERSON_H
#define PERSON_H

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

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

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

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

यहाँ प्रदर्शन के लिए एक ड्राइवर प्रोग्राम है:

// 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.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;
}

यहाँ सब कुछ संकलित करने के लिए एक mac है:

# 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

यह भी देखें

• कार्यात्मक प्रोग्रामिंग
• प्रोग्रामिंग सिंटेक्सों की तुलना
• प्रतिक्रियाशील प्रोग्रामिंग
• प्रोग्रामिंग भाषाओं का इतिहास
• श्रेणी के अनुसार प्रोग्रामिंग भाषाओं की सूची# आदेशसूचक भाषाएं

संदर्भ

• 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.