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

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

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

अनिवार्य और प्रक्रियात्मक प्रोग्रामिंग

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

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

तर्काधार और अनिवार्य प्रोग्रामिंग की नींव

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

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

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

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

कई अनिवार्य प्रोग्रामिंग लैंग्वेज (जैसे फोरट्रान, बुनियादी, और सी (प्रोग्रामिंग भाषा)) सभा की भाषा के एब्स्ट्रक्शन (कंप्यूटर साइंस) हैं।

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

प्रारंभिक अनिवार्य भाषाएँ मूल कंप्यूटरों की मशीनी भाषाएँ थीं। इन भाषाओं में, निर्देश बहुत सरल थे, जो हार्डवेयर कार्यान्वयन को आसान बनाते थे लेकिन जटिल प्रोग्रामों के निर्माण में बाधा डालते थे। 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) को आईबीएम मैथमेटिकल फॉर्मूला ट्रांसलेटिंग सिस्टम के रूप में पेश किया गया था। यह स्ट्रिंग (कंप्यूटर विज्ञान) हैंडलिंग सुविधाओं के बिना, वैज्ञानिक गणनाओं के लिए डिज़ाइन किया गया था। घोषणा (कंप्यूटर प्रोग्रामिंग), अभिव्यक्ति (कंप्यूटर विज्ञान), और वक्तव्य (कंप्यूटर विज्ञान) के साथ, यह समर्थित है:

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

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

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

C++ (1985) को मूल रूप से C with Classes कहा जाता था। इसे सी (प्रोग्रामिंग लैंग्वेज) | सी की क्षमताओं का विस्तार करने के लिए सिमुला भाषा की वस्तु-उन्मुख सुविधाओं को जोड़कर डिजाइन किया गया था। एक ऑब्जेक्ट-ओरिएंटेड मॉड्यूल दो फाइलों से बना होता है। परिभाषा फ़ाइल को निर्देश शामिल करें कहा जाता है। यहाँ एक साधारण स्कूल एप्लिकेशन में 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

एक कंस्ट्रक्टर (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) ऑपरेशन एक फंक्शन है जिसका नाम क्लास के नाम के समान है। इसे तब निष्पादित किया जाता है जब कॉलिंग ऑपरेशन निष्पादित होता है new कथन।

एक मॉड्यूल की अन्य फाइल स्रोत कोड है। यहाँ एक साधारण स्कूल एप्लिकेशन में GRADE क्लास के लिए C++ स्रोत फ़ाइल है:

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

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

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

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

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

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

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

// 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
    c++ student_dvr.cpp grade.o student.o person.o -o student_dvr

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

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

person.o: person.cpp person.h
    c++ -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.