प्रक्रियात्मक कार्यक्रम और ऑब्जेक्ट उन्मुख प्रोग्राम के बीच क्या अंतर है?

Question

मैं प्रोग्रामिंग के लिए बिल्कुल नया हूं लेकिन मैं विभिन्न प्रोग्रामिंग दृष्टिकोणों के बारे में स्टैक ओवरव्लो पर कुछ रोचक चर्चाएं पढ़ रहा हूं। प्रक्रियात्मक प्रोग्रामिंग और ऑब्जेक्ट उन्मुख प्रोग्रामिंग के बीच अंतर क्या है, इस पर मैं अभी भी 100% स्पष्ट नहीं हूं। ऐसा लगता है जैसे ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग अभी भी प्रक्रियाओं (विधियों) का उपयोग करती है लेकिन सबकुछ अलग-अलग व्यवस्थित होता है क्योंकि ऑब्जेक्ट शो का सितारा होता है। लेकिन मुझे ऐसा लगता है कि प्रक्रियाएं अभी भी आपको एक ही चीजों को करने की अनुमति देती हैं। सी की तरह, आप अपनी सभी समान प्रक्रियाओं को लाइब्रेरी में डाल सकते हैं। तो क्या आप वास्तव में यह नहीं कह सकते कि सी में लाइब्रेरी सी ++ में किसी ऑब्जेक्ट के समान है? प्रक्रियात्मक भाषाओं 'structs' (चीजें हैं जो संबंधित डेटा को एक साथ पकड़) जो रहता डेटा प्रक्रियाओं से अलग का उपयोग करें -

Answer 1

दोनों के बीच का अंतर सूक्ष्म लेकिन महत्वपूर्ण है।

एक प्रक्रियात्मक कार्यक्रम में, मॉड्यूल साझा डेटा संरचनाओं में संग्रहीत स्थिति को पढ़ने और लिखने से बातचीत करते हैं।

किसी ऑब्जेक्ट उन्मुख प्रोग्राम में, ऑब्जेक्ट्स के रूप में मॉड्यूल अन्य ऑब्जेक्ट्स को संदेश भेजकर बातचीत करते हैं।

Answer 2

अंतर यह है कि वस्तुओं प्रक्रियाओं और एक ही स्थान पर संबंधित डेटा है। प्रभावी रूप से, आप ओओ भाषा में जो कुछ भी करते हैं वह स्ट्रक्चर और प्रक्रियाओं के संयोजन के साथ एक प्रक्रियात्मक भाषा में संभव होना चाहिए।

मुख्य अंतर यह है मन सेट है कि एक OO भाषाओं में प्रोग्रामर डालता है।

Answer 3

इस सरल जवाब है।

• एक वास्तविक ओओ भाषा में, एक वस्तु के अंदर एकमात्र प्रक्रियात्मक कोडिंग किया जाता है।

• सी कोई वस्तुएं हैं और सी ++ एक भाषा है कि वस्तुओं का समर्थन करता है है। दूसरी ओर जावा सब कुछ एक वस्तु है (प्राइमेटिव को छोड़कर)। सब कुछ टाइप किया गया है।

• रैखिक प्रगति वस्तुओं के अंदर होती है लेकिन ऑब्जेक्ट्स स्वयं कोड और डेटा का संग्रह होते हैं।

Answer 4

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

Answer 5

प्रक्रियात्मक प्रक्रियात्मक/कार्यात्मक/तार्किक (या तर्क उन्मुख) भेद (सी, लिस्पी, और प्रोलॉग की तुलना करें) का वर्णन करने के विभिन्न तरीकों के बीच प्रक्रिया का एक हिस्सा है जो प्रोग्राम करना चाहिए।

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

के रूप में दूसरों का उल्लेख किया है, हालांकि, उचित वस्तु उन्मुख सोच का तरीका बदल आप कार्यात्मक के लिए प्रक्रियात्मक से एक स्विच के रूप के रूप में ज्यादा अपने प्रोग्रामिंग करते हैं।

---

BTW-- मैं देख रहा हूँ "प्रक्रियात्मक" एक बहुत अलग करने के लिए अपने ऑब्जेक्ट ओरिएंटेड भाइयों से गैर वस्तु उन्मुख प्रक्रियात्मक भाषाओं का उपयोग किया है, लेकिन मुझे लगता है कि यह एक साफ विशेषण की कमी के द्वारा संचालित एक गरीब उपयोग है "ऑब्जेक्ट उन्मुख नहीं" के लिए। YMMV।

Answer 6

एक प्रक्रियात्मक कार्यक्रम में, कोड राजा है और डेटा अधीनस्थ है। दूसरे शब्दों में, आपके पास ऐसे प्रोग्राम हैं जो डेटा पर कार्य करते हैं और वे आमतौर पर कसकर बंधे नहीं होते हैं।

ओओ दुनिया में, वस्तुएं ब्याज की प्राथमिक बात हैं। किसी ऑब्जेक्ट में डेटा और कोड होता है जो उस डेटा पर कार्य करने की अनुमति देता है, और वे बहुत कड़े बाध्य होते हैं। यह जानकारी छिपाने, encapsulation की अवधारणा है।

एक उदाहरण, मान लें कि आपके पास एक संख्या है और आप इसे दोगुना करना चाहते हैं। ऐसा करने का एक प्रक्रियात्मक तरीका है:

n = n * 2 

यहाँ कोड काफी स्पष्ट रूप से 2 से n गुणा और परिणाम एन में वापस संग्रहीत करता है।

ऐसा करने का OO रास्ता संख्या वस्तु ही दोगुना करने के लिए यह कह रही करने के लिए एक "संदेश" भेजने के लिए है:

n.double(); 

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

ओओ के साथ, आप एक स्ट्रिंग ऑब्जेक्ट बनाते हैं जो 'डबल' संदेश भी ले सकता है। एक स्ट्रिंग को डबल करने के लिए कोड स्ट्रिंग ऑब्जेक्ट से संबंधित है, इसलिए यह जानता है कि इसे संख्या ऑब्जेक्ट पर अलग-अलग कार्य करना है। यदि यह फैसला किया है कि "बॉब" * 2 था "bobbob", कोड कुछ ऐसा दिखाई देगा:)

class number:     class string: 
    int n       char array s 
    procedure double:    procedure double: 
     n = n * 2      s = string_join(s,s) 

तो फिर तुम x.double (कह सकते हैं कोई बात नहीं क्या वास्तविक प्रकार एक्स था (संख्या या स्ट्रिंग) और यह पता चलेगा कि कौन सा कोड चलाना है - यह आपके कोड को बहुत सरल बनाता है। आप अपने मॉनीटर और विभिन्न चीजों के सभी प्रकारों पर पूर्णांक, तार, मैट्रिस, जटिल संख्या, वास्तविकता, विंडो आकार को दोगुना कर सकते हैं।

और आप सही हैं, वस्तुओं की तरह थोड़ा देखने के लिए एक सी लाइब्रेरी बनाई जा सकती है। क्लासिक उदाहरण stdio.h है - आपको कभी भी परवाह नहीं हैFILE* वास्तव में यह इंगित करता है कि यह एक निश्चित तरीके से व्यवहार करेगा। FILE*, fopen(), fclose() और अन्य कार्यों सी आई/ओ क्षमताओं

Answer 7

OO ज्यादातर एक मन सेट है का प्रतिनिधित्व तरह की एक वर्ग के हैं। आप सीओ में प्रोग्राम कर सकते हैं (यदि आप वास्तव में करना चाहते हैं ...), और आप सी ++/जावा में पूरी तरह से प्रक्रियात्मक कोड कर सकते हैं; मेरा मतलब है, भले ही आप सतह पर कक्षाओं का उपयोग करते हैं, फिर भी यह प्रक्रियात्मक हो सकता है।

ओओ के पीछे विचार राज्य का अमूर्त है। "डेटा के समूह" के संदर्भ में "सोचने" के बजाय, आप "ऑब्जेक्ट्स" के संदर्भ में "सोचते हैं", जहां एक वस्तु "डेटा के समूह और इस डेटा में हेरफेर करने के तरीकों" के लिए "इंटरफेस" है।

यह सब दार्शनिक लगता है, क्योंकि यह है।

यहां कहने के लिए बहुत कुछ है, और यह सब एक छोटे एसओ पोस्ट में नहीं कहा जा सकता है, इसलिए मैं इसे यहां छोड़ दूंगा।

अद्यतन
Flanagan's answer में उल्लेख किया है, OO भाषाओं निर्माणों कि इस अमूर्त का उपयोग लागू।

मेरा मतलब है, आप तकनीकी रूप से वर्गों, कार्यों और फ़ंक्शन पॉइंटर्स के संदर्भ में कक्षाओं और बहुरूपता को "हैक" कर सकते हैं।

यहाँ OO in C

Answer 8

दिलचस्प अंक पहले से ही यहाँ उल्लेख बहुत से का एक उदाहरण है।

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

प्रक्रियात्मक प्रोग्रामिंग आम तौर पर डेटा और व्यवहार के इस तरह के युग्मन को 'ऑब्जेक्ट' में उपयोग नहीं करती है। मैंने इसे सी में पहले देखा है लेकिन सी ++ कहने के साथ यह अनुमान लगाने के लिए बहुत अधिक बंदर व्यवसाय नहीं था।

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

अनुमोदित, यदि आप चालाक हैं तो आप ऑब्जेक्ट को बाधित कर सकते हैं लेकिन आपको ऐसा करने के तरीके से बाहर जाना होगा।

यह पूर्ण नहीं है, लेकिन यह एक पहलू है।

Answer 9

जिस तरह से सी ++ लागू किया गया है, ओओ प्रोग्रामिंग प्रक्रियात्मक प्रोग्रामिंग की तरह दिखता है। आपको अपनी सोच थोड़ा बदलना होगा।

सी ++ ऑब्जेक्ट्स में ऐसी विधियां होती हैं जो ऑब्जेक्ट पर कार्य करती हैं। लेकिन वास्तविक ओओ पैराडम में आपको विधियों को संभावित संदेश के रूप में सोचना चाहिए कि ऑब्जेक्ट प्राप्त हो सकता है (यानी अक्षर)। ऑब्जेक्ट एक संदेश प्राप्त करता है (पैरामीटर संदेश के पेलोड का अर्थ है यानी पत्र की सामग्री) और संदेश के आधार पर इसके राज्य को बदलता है।

Answer 10

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

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

Answer 11

[प्राइमर शैली क्षमा, यह देर हो चुकी है और मैं थक गया हूँ]

प्रक्रियाओं प्रक्रिया डेटा -, में डेटा कुछ प्रसंस्करण लागू होते हैं, बाहर

कभी कभी डेटा प्राप्त, डेटा तत्वों में से कुछ से जुड़े हुए हैं कुछ अन्य डेटा तत्व, और उन्हें डेटा संरचना में समूहित करने के लिए सुविधाजनक है, जिसे तब एक इकाई के रूप में छेड़छाड़ और संबोधित किया जा सकता है।

अब हमारी प्रक्रिया इनपुट के रूप में एक डेटा संरचना ले जा सकते हैं और यह परिवर्तन और/या आउटपुट के रूप में एक और डेटा संरचना का निर्माण

कभी कभी हम देखते हैं कि कुछ प्रक्रियाओं केवल डेटा संरचना की एक निश्चित प्रकार के साथ संबंध है; इन प्रक्रियाओं को उनके डेटा संरचना के साथ समूहित करना सुविधाजनक है, और इसे ऑब्जेक्ट पर कॉल करें।

वस्तुओं को बनाने के लिए एक टेम्पलेट को कक्षा कहा जाता है; एक वस्तु

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

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

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

अपनी पढ़ाई के साथ शुभकामनाएँ!

Answer 12

संदर्भ में समझना आसान है, भाषाओं के बीच पेश किए गए अन्य अवशेषों को देखें।

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

प्रक्रियात्मक भाषा और सीओ + जैसी ओओ भाषा के बीच का अंतर "ऑब्जेक्ट" अबास्ट्रक्शन है। जो लोग "सी" लिखते हैं वे अक्सर अवधारणात्मक वस्तुओं but its difficult and error prone बनाते हैं, एक ओओ भाषा आपको इसे आसान बनाने के लिए टूल देती है।

माइक्रोसॉफ्ट (या एरलांग) से Sing# जैसी चीजें भाषा में संदेश/प्रक्रिया अमूर्तता जोड़ती हैं। निश्चित रूप से, आप असेंबली, सी या सी ++ में संदेश गुजरने और संसाधित करने के लिए संदेश कर सकते हैं लेकिन गायन # इसे आसान बनाता है।

यह सब एक ही मशीन कोड पर आता है, ये अवशेष पूरी तरह से हमारे दिमाग के लाभ के लिए हैं, कंप्यूटर नहीं।

Answer 13

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

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

ऑब्जेक्ट उन्मुख प्रतिमान, दूसरी तरफ, कहता है कि आपको एक इकाई के रूप में राज्य और संचालन के बारे में सोचने की आवश्यकता है, और फिर अपने कार्यक्रम को राज्यों का आदान-प्रदान करने और संचालन सक्रिय करने वाली इकाइयों के बीच बातचीत के रूप में डिजाइन करने की आवश्यकता है।

Answer 14

यह निर्भर करता है कि आप ओओपी को कैसे परिभाषित करते हैं। जावा जैसी ओओपी के संदर्भ में जहां आप ऑब्जेक्ट्स पर विधियों को कॉल करते हैं, प्रक्रियात्मक प्रोग्रामिंग काफी समान है। जहां तक ​​मैं आपको बता सकता हूं कि आप सभी ओओपी सिद्धांतों (encapsulation, abstraction, polymorphism, विरासत) को सी प्रक्रियात्मक भाषा में सी का अनुकरण कर सकते हैं। इसका सबूत GObject है, कुछ उद्देश्य उद्देश्य सी, और सी का उपयोग कर कई अन्य ओओपी भाषा कार्यान्वयन, सीपीथन की तरह। यह संरचनाओं का उपयोग करके संरचनाओं का उपयोग करके और उन संरचनाओं पर परिचालन करके किया जाता है:

typedef struct { 
    Object *isa; 
    String *name; 
    Date *birthday; 
} Person; 

Person *Person_new(); 
String *Person_name(Person *self); 
void Person_setName(Person *self, String *newName); 
// ... 

इंटरफ़ेस बहुत ओओपी है। यह वास्तव में बहुरूपता की अनुमति नहीं देता है, लेकिन यह भी संभव है। यह बहुत ही एक अजगर इंटरफ़ेस के समान है, सिवाय इसके कि गुण "तरीकों" से अलग कर रहे हैं:

class Person(object): 
    def __init__(self): 
     self._name = "" 
     self._age = datetime.datetime.now() 

    @property 
    def name(self): 
     return self._name 

    @property 
    def age(self): 
     return self._age 

मैं उदाहरण के लिए अजगर को इसलिए चुना क्योंकि "स्व" स्पष्ट है, सी उदाहरण के रूप में। जावा की तरह कई ओओपी भाषाएं, यह सार है।

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

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

वास्तव में, एक पुस्तकालय, या संरचना पर चलने वाले कार्यों का एक सेट, सी ++ में एक वस्तु के समान है। वास्तव में सी ++ इस तरह से लागू किया गया है।

Answer 15

प्रक्रियात्मक और ओओ के बीच अंतर का एक काफी उदाहरण के लिए, स्मॉलटॉक सीखने का प्रयास करें। स्मॉलटाक में, सबकुछ, और मेरा मतलब है कि सबकुछ एक वस्तु है। कोई if-statement या while-loops नहीं हैं। आप अन्य ऑब्जेक्ट्स (ए.के.ए.ए. पर आविष्कार विधियों) को संदेश भेजकर उस कार्यक्षमता को प्राप्त करते हैं। यह वास्तव में आपके सिर को पहले स्पिन बनाता है, लेकिन मुझे लगता है कि आप ओओ को क्या करना चाहिए जल्दी से ग्रोक करेंगे।

Answer 16

एक प्रक्रियात्मक कार्यक्रम में, आप एक बड़ी समस्या को छोटी समस्याओं में विभाजित करते हैं, और प्रक्रियाओं के रूप में इन छोटी समस्याओं में से प्रत्येक को अमूर्त करते हैं। इसे प्रक्रियात्मक अमूर्त कहा जाता है।

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

Answer 17

अंतर

प्रक्रिया उन्मुख प्रोग्रामिंग है - प्रोग्रामिंग के data.This रास्ता बजाय एल्गोरिथ्म को महत्व देता है प्रक्रियाओं तरीकों यानी पर विशिष्ट कार्य करने के लिए और अपने डेटा संरचना का हिस्सा केंद्रित है। यह टॉप-डाउन संरचनाओं का पालन करता है।

उदाहरण: पास्कल और सी

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

उदाहरण: सी ++ और जावा