कक्षाएं और वस्तुएं
Text translation
Source text
748 / 5000
Translation results
5
कक्षाएं और वस्तुएं
महत्वपूर्ण अवधारणाएं
> संरचनाओं का उपयोग करना
>
एक वर्ग बनाना
सदस्य कार्यों को परिभाषित करना।
वस्तुओं का निर्माण
<वस्तुओं का उपयोग करना
>
इनलाइन सदस्य कार्य नेस्टेड सदस्य कार्य
> निजी सदस्य कार्य करता है।
वर्ग के सदस्यों के रूप में सरणियाँ
वस्तुओं का भंडारण
5.1 परिचय
स्टेटिक डेटा सदस्य
स्थिर सदस्य कार्य
<वस्तुओं की सरणियों का उपयोग करना
वस्तुओं को पैरामीटर के रूप में पास करना
कार्यों को कक्षाओं के अनुकूल बनाना
वस्तुओं को लौटाने वाले कार्य
कास्ट सदस्य कार्य
सदस्यों को संकेत
dereferencing ऑपरेटरों का उपयोग करना
स्थानीय कक्षाएं
>
<
<
<
<
सी ++ की सबसे महत्वपूर्ण विशेषता "वर्ग" है। इसका महत्व इस तथ्य से उजागर होता है कि स्ट्राउस्ट्रप ने शुरू में अपनी नई भाषा को "सी विद क्लासेन" नाम दिया था। एक वर्ग एक है
यह
कक्षाएं और वस्तुएं
97
सी में प्रयुक्त संरचना के विचार का विस्तार। यह उपयोगकर्ता द्वारा परिभाषित डेटा प्रकार बनाने और कार्यान्वित करने का एक नया तरीका है। हम इस अध्याय में कक्षा की अवधारणा पर पहले C में पाई जाने वाली पारंपरिक संरचनाओं की समीक्षा करेंगे और फिर उन तरीकों पर चर्चा करेंगे जिनसे कक्षाओं को डिजाइन, कार्यान्वित और लागू किया जा सकता है।
5.2 सी संरचनाओं पर दोबारा गौर किया गया
हम जानते हैं कि सी भाषा की अनूठी विशेषताओं में से एक संरचना है। वे विभिन्न प्रकार के डेटा को एक साथ पैक करने के लिए एक विधि प्रदान करते हैं। तार्किक रूप से संबंधित डेटा आइटम के समूह को संभालने के लिए एक संरचना एक सुविधाजनक उपकरण है। यह एक उपयोगकर्ता-परिभाषित डेटा प्रकार है जिसमें एक टेम्प्लेट होता है जो इसके डेटा गुणों को परिभाषित करने का कार्य करता है। एक बार संरचना प्रकार परिभाषित हो जाने के बाद, हम घोषणाओं का उपयोग करके उस प्रकार के चर बना सकते हैं जो अंतर्निहित प्रकार की घोषणाओं के समान हैं। उदाहरण के लिए, निम्नलिखित घोषणा पर विचार करें:
संरचना छात्र
(
चार नाम [20]; इंट रोल नंबर;
फ्लोट कुल अंक;
कीवर्ड स्ट्रक्चर छात्र को एक नए डेटा प्रकार के रूप में घोषित करता है जो विभिन्न डेटा प्रकारों के तीन क्षेत्रों को धारण कर सकता है। इन क्षेत्रों को संरचना सदस्य या तत्व के रूप में जाना जाता है। पहचानकर्ता छात्र, जिसे संरचना नाम या संरचना टैग के रूप में संदर्भित किया जाता है, का उपयोग छात्र के प्रकार के चर बनाने के लिए किया जा सकता है। उदाहरण:
संरचना छात्र ए; // सी घोषणा
ए प्रकार के छात्र का एक चर है और इसमें तीन सदस्य चर हैं जैसा कि टेम्पलेट द्वारा परिभाषित किया गया है सदस्य चर को डॉट या अवधि ऑपरेटर का उपयोग करके निम्नानुसार एक्सेस किया जा सकता है:
strcpy (ए.नाम, "जॉन"); ए.रोल नंबर = 999;
ए.कुल अंक = 595.5;
अंतिम योग = A. कुल अंक + 5;
संरचना में सदस्य के रूप में सरणियाँ, संकेत या संरचनाएँ हो सकती हैं।
सी संरचना की सीमाएं
मानक सी संरचना डेटा प्रकार को अंतर्निर्मित प्रकारों की तरह व्यवहार करने की अनुमति नहीं देता है। उदाहरण के लिए, निम्नलिखित संरचना पर विचार करें:
usses
तथ्य
s an
98
C++ के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
संरचना परिसर
फ्लोट एक्स फ्लोट वाई;
संरचना जटिल c1, c2, c3;
जटिल संख्या c1, c2, और c3 को डॉट ऑपरेटर का उपयोग करके आसानी से मान निर्दिष्ट किया जा सकता है, लेकिन हम दो जटिल संख्याएँ नहीं जोड़ सकते हैं या एक को दूसरे से घटा सकते हैं। उदाहरण के लिए, c3-cl + c2;
सी में अवैध है।
सी संरचनाओं की एक और महत्वपूर्ण सीमा यह है कि वे डॉट छिपाने की अनुमति नहीं देते हैं। संरचना के सदस्यों को उनके दायरे में कहीं भी किसी भी फ़ंक्शन द्वारा संरचना चर द्वारा सीधे पहुँचा जा सकता है। दूसरे शब्दों में, संरचना के सदस्य सार्वजनिक सदस्य होते हैं।
संरचनाओं के लिए विस्तार
सी ++, सी में परिभाषित संरचनाओं की सभी विशेषताओं का समर्थन करता है। लेकिन सी ++ ने अपने ओओपी दर्शन के अनुरूप अपनी क्षमताओं का और विस्तार किया है। यह उपयोगकर्ता-परिभाषित प्रकारों को अंतर्निर्मित डेटा प्रकारों के जितना संभव हो सके करीब लाने का प्रयास करता है, और डेटा को छिपाने की सुविधा भी प्रदान करता है जो ओओपी के मुख्य सिद्धांतों में से एक है। वंशानुक्रम, एक तंत्र जिसके द्वारा एक प्रकार
अन्य प्रकार की विशेषताओं को इनहेरिट कर सकते हैं, C++ द्वारा समर्थित भी C++ में, एक संरचना में सदस्यों के रूप में चर और कार्य दोनों हो सकते हैं। यह अपने कुछ सदस्यों को 'निजी' भी घोषित कर सकता है ताकि उन्हें सीधे बाहरी लोगों द्वारा एक्सेस नहीं किया जा सके
कार्य।
C++ में, संरचना के नाम स्टैंड-अलोन होते हैं और किसी भी अन्य प्रकार के नामों की तरह उपयोग किए जा सकते हैं
दूसरे शब्दों में, संरचना चर की घोषणा में कीवर्ड संरचना को छोड़ा जा सकता है
उदाहरण के लिए, हम छात्र चर A को के रूप में घोषित कर सकते हैं
विद्यार्थी:
// सी ++ घोषणा
याद रखें, यह सी में एक त्रुटि है।
सी ++ इन सभी एक्सटेंशन को एक अन्य उपयोगकर्ता-परिभाषित प्रकार में शामिल करता है जिसे कक्षा के रूप में जाना जाता है। सी ++ में संरचनाओं और कक्षाओं के बीच बहुत कम वाक्य रचनात्मक अंतर है और इसलिए, उन्हें मामूली संशोधनों के साथ एक दूसरे के लिए इस्तेमाल किया जा सकता है। चूँकि क्लास C++ में एक विशेष रूप से पेश किया गया डेटा प्रकार है, अधिकांश C++ प्रोग्रामर केवल डेटा रखने के लिए संरचनाओं का उपयोग करते हैं, और डेटा और फ़ंक्शंस दोनों को रखने के लिए क्लासेस का उपयोग करते हैं। इसलिए, हम आगे संरचनाओं पर चर्चा नहीं करेंगे।
ध्यान दें
सी ++ में संरचना और वर्ग के बीच एकमात्र अंतर यह है कि, डिफ़ॉल्ट रूप से, सदस्य
एक वर्ग के निजी होते हैं, जबकि, डिफ़ॉल्ट रूप से, संरचना के सदस्य सार्वजनिक होते हैं।
कक्षाएं और वस्तुएं
99
5.3 एक वर्ग निर्दिष्ट करना
एक वर्ग डेटा और उससे जुड़े कार्यों को एक साथ बांधने का एक तरीका है। यह डेटा (और फ़ंक्शंस) को बाहरी उपयोग से, यदि आवश्यक हो, छिपाने की अनुमति देता है। एक वर्ग को परिभाषित करते समय, हम एक नया सार डेटा प्रकार बना रहे हैं जिसे किसी अन्य अंतर्निहित डेटा प्रकार की तरह माना जा सकता है। आम तौर पर, एक वर्ग विनिर्देश में दो भाग होते हैं:
1. क्लास डिक्लेरेशन 2. क्लास फंक्शन डेफिनिशन
वर्ग घोषणा इसके सदस्यों के प्रकार और दायरे का वर्णन करती है। क्लास फ़ंक्शन परिभाषाएँ बताती हैं कि क्लास फ़ंक्शंस कैसे कार्यान्वित किए जाते हैं।
वर्ग घोषणा का सामान्य रूप है:
कक्षा वर्ग का नाम
(
निजी:
परिवर्तनीय घोषणाएं; समारोह घोषणाएं;
सह लोक:
परिवर्तनीय घोषणाएं; समारोह घोषणा;
वर्ग घोषणा एक संरचना घोषणा के समान है। कीवर्ड वर्ग निर्दिष्ट करता है, कि जो निम्न प्रकार है वह class_name प्रकार का एक सार डेटा है। एक वर्ग का शरीर ब्रेसिज़ के भीतर संलग्न होता है और अर्धविराम द्वारा समाप्त होता है। वर्ग निकाय में चर और कार्यों की घोषणा शामिल है। इन कार्यों और चरों को सामूहिक रूप से वर्ग सदस्य कहा जाता है। उन्हें आम तौर पर दो वर्गों के तहत समूहीकृत किया जाता है, अर्थात् निजी और सार्वजनिक यह दर्शाने के लिए कि कौन से सदस्य निजी हैं और उनमें से कौन सा सार्वजनिक है। निजी और सार्वजनिक खोजशब्दों को दृश्यता लेबल के रूप में जाना जाता है। ध्यान दें कि इन कीवर्ड के बाद एक कोलन आता है।
निजी घोषित किए गए वर्ग के सदस्यों को केवल कक्षा के भीतर से ही पहुँचा जा सकता है। दूसरी ओर, सार्वजनिक सदस्यों को कक्षा के बाहर से भी एक्सेस किया जा सकता है। डेटा छिपाना (निजी घोषणा का उपयोग करना) ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग की प्रमुख विशेषता है। निजी कीवर्ड का उपयोग वैकल्पिक है। डिफ़ॉल्ट रूप से, एक वर्ग के सदस्य निजी होते हैं। यदि दोनों लेबल गायब हैं, तो, डिफ़ॉल्ट रूप से, सभी सदस्य निजी होते हैं। ऐसा वर्ग बाहरी दुनिया से पूरी तरह छिपा हुआ है और किसी उद्देश्य की पूर्ति नहीं करता है।
कक्षा के अंदर घोषित चर को डेटा सदस्य के रूप में जाना जाता है और कार्यों को सदस्य कार्यों के रूप में जाना जाता है। केवल सदस्य कार्यों के पास निजी डेटा सदस्यों और निजी कार्यों तक पहुंच हो सकती है। हालाँकि, सार्वजनिक सदस्यों (फ़ंक्शन और डेटा दोनों) को कक्षा के बाहर से एक्सेस किया जा सकता है। यह चित्र 5.1 में दिखाया गया है। डेटा और फ़ंक्शंस को एक साथ एक वर्ग-प्रकार के चर में बाँधना इनकैप्सुलेशन के रूप में जाना जाता है।
रेटर,
ले,
साइडिंग
राष्ट्रीय
एड इट्स
प्रकार
आंकड़े
ई टाइप
एक्लेरे
तेहरा
एम्स
अक्षम।
वहां
इसलिए,
खासकर
इसके लिए रेस
नहीं करूँगा
बेर्स
Text translation
Source text
1711 / 5000
Translation results
1000
C++ के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
कक्षा
निजी क्षेत्र
निजी क्षेत्र में नो एंट्री
एक्स
आंकड़े
कार्यों
सार्वजनिक क्षेत्र में प्रवेश की अनुमति
सार्वजनिक क्षेत्र
आंकड़े
कार्यों
अंजीर। 5.1 डेटा कक्षाओं में छिपा हुआ
एक साधारण वर्ग उदाहरण
एक विशिष्ट वर्ग घोषणा इस तरह दिखेगी:
वर्ग वस्तु
इंट नंबर: फ्लोट कॉस्ट;
सह लोक:
शून्य गेटडेटा (इंट ए, फ्लोट बी); शून्य पुटडेटा (शून्य);
// चर घोषणा डिफ़ॉल्ट रूप से निजी है
// प्रोटोटाइप का उपयोग करके कार्यों की घोषणा
1:// अर्धविराम के साथ समाप्त होता है
हम आमतौर पर एक वर्ग को कुछ सार्थक नाम देते हैं, जैसे कि आइटम। यह नाम अब एक नए प्रकार का पहचानकर्ता बन गया है जिसका उपयोग उस वर्ग प्रकार के उदाहरण घोषित करने के लिए किया जा सकता है। क्लास आइटम में दो डेटा सदस्य और दो फ़ंक्शन सदस्य होते हैं। डेटा सदस्य डिफ़ॉल्ट रूप से निजी होते हैं जबकि दोनों कार्य घोषणा द्वारा सार्वजनिक होते हैं। फ़ंक्शन getdata () का उपयोग सदस्य चर संख्या और लागत के लिए मान निर्दिष्ट करने के लिए किया जा सकता है, और उनके मान प्रदर्शित करने के लिए putdata () का उपयोग किया जा सकता है। ये फ़ंक्शन कक्षा के बाहर से डेटा सदस्यों तक एकमात्र पहुंच प्रदान करते हैं। इसका मतलब है कि डेटा को किसी भी फ़ंक्शन द्वारा एक्सेस नहीं किया जा सकता है जो क्लास आइटम का सदस्य नहीं है। ध्यान दें कि फ़ंक्शन घोषित किए गए हैं, परिभाषित नहीं हैं। वास्तविक कार्य परिभाषाएँ कार्यक्रम में बाद में दिखाई देंगी। डेटा सदस्यों को आमतौर पर निजी घोषित किया जाता है और सदस्य सार्वजनिक के रूप में कार्य करता है। चित्र 5.2 OOP विश्लेषकों द्वारा एक वर्ग का प्रतिनिधित्व करने के लिए उपयोग किए जाने वाले दो अलग-अलग संकेतन को दर्शाता है।
वस्तुओं का निर्माण
याद रखें कि आइटम की घोषणा जैसा कि ऊपर दिखाया गया है, आइटम की किसी भी वस्तु को परिभाषित नहीं करता है, लेकिन केवल यह निर्दिष्ट करता है कि उनमें क्या होगा। एक बार क्लास घोषित हो जाने के बाद, हम क्लास के नाम (किसी भी अन्य बिल्ट-इन टाइप वेरिएबल की तरह) का उपयोग करके उस प्रकार के वेरिएबल बना सकते हैं। उदाहरण के लिए,
कक्षाएं और वस्तुएं
कक्षा आइटम
मद
आंकड़े
डेटा प्राप्त करें)
101
संख्या
पुटडेटा ()
कार्य
(0)
(6)
चित्र 5.2 es एक वर्ग का प्रतिनिधित्व है
आइटम एक्स;
प्रकार की वस्तु का एक चर x बनाता है। C++ में, क्लास वेरिएबल को ऑब्जेक्ट के रूप में जाना जाता है। इसलिए,
x के लिए मेमोरी बनाई जाती है
x को वस्तु प्रकार की वस्तु कहा जाता है। हम एक कथन में एक से अधिक वस्तुओं की घोषणा भी कर सकते हैं। उदाहरण:
आइटम एक्स, वाई, जेड;
किसी वस्तु की घोषणा किसी भी मूल प्रकार के चर के समान होती है। आवश्यक
इस स्तर पर किसी वस्तु को स्मृति स्थान आवंटित किया जाता है। ध्यान दें कि वर्ग विनिर्देश, जैसे a
संरचना, केवल एक टेम्पलेट प्रदान करती है और वस्तुओं के लिए कोई मेमोरी स्पेस नहीं बनाती है
वस्तुओं को तब भी बनाया जा सकता है जब किसी वर्ग को उनके नाम तुरंत रखकर परिभाषित किया जाता है
क्लोजिंग ब्रेस के बाद, जैसा कि हम संरचनाओं के मामले में करते हैं। यानी परिभाषा
वर्ग वस्तु
पी
वस्तु x, y और z प्रकार की वस्तुओं का निर्माण करेगा। इस अभ्यास का शायद ही कभी पालन किया जाता है क्योंकि हम वस्तुओं को उस स्थान के करीब घोषित करना चाहते हैं जहां उनका उपयोग किया जाता है न कि वर्ग परिभाषा के समय
कक्षा के सदस्यों तक पहुंचना
पहले बताया गया है कि किसी वर्ग के निजी डेटा को केवल उस वर्ग के सदस्य कार्यों के माध्यम से एक्सेस किया जा सकता है। मेन्टी में ऐसे स्टेटमेंट नहीं हो सकते हैं जो सीधे नंबर और लागत को एक्सेस करते हैं। सदस्य फ़ंक्शन को कॉल करने का प्रारूप निम्नलिखित है:
एर
102
C . के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
ऑब्जेक्ट-नाम। फ़ंक्शन-नाम (वास्तविक-तर्क);
उदाहरण के लिए, फ़ंक्शन कॉल स्टेटमेंट
x.getdata (100,75.5);
वैध है और getdata() फ़ंक्शन को लागू करके ऑब्जेक्ट x की लागत को 100 और 75,5 मान प्रदान करता है। असाइनमेंट वास्तविक फ़ंक्शन में होते हैं। कृपया सेक देखें। 5.4
अधिक जानकारी के लिए।
इसी प्रकार, कथन
x.putdata ();
डेटा सदस्यों के मूल्यों को प्रदर्शित करेगा। याद रखें, एक सदस्य समारोह लागू किया जा सकता है
केवल एक वस्तु (उसी वर्ग के) का उपयोग करके। इस तरह का बयान
गेटडाटा (100,75.5);
कोई मतलब नहीं है। इसी प्रकार, कथन
x.संख्या 100;
अवैध भी है। यद्यपि x उस प्रकार की वस्तु की वस्तु है जिससे संख्या संबंधित है, संख्या
(घोषित निजी) केवल एक सदस्य समारोह के माध्यम से पहुँचा जा सकता है, न कि सीधे वस्तु द्वारा
यह याद किया जा सकता है कि वस्तुएं संदेश भेज और प्राप्त करके संचार करती हैं। यह है
सदस्य कार्यों के माध्यम से हासिल किया। उदाहरण के लिए,
*.पुटडेटा ();
ऑब्जेक्ट x को एक संदेश भेजता है जिसमें उसकी सामग्री प्रदर्शित करने का अनुरोध किया जाता है।
सार्वजनिक के रूप में घोषित एक चर को वस्तुओं द्वारा सीधे पहुँचा जा सकता है, उदाहरण:
कक्षा xyz
इंट एक्स;
सार्वजनिक रूप से:
इंट 2;
};
xyz पी: पी.एक्स = 0;
पी.जेड - 10
// त्रुटि, एक्स टीएस निजी। // ठीक है, z सार्वजनिक है
कक्षाएं और वस्तुएं
103
इस तरह से डेटा का उपयोग डेटा छिपाने के विचार को ही हरा देता है और इसलिए
ध्यान दें
दूर रहे
5.4 सदस्य कार्यों को परिभाषित करना
सदस्य कार्यों को दो स्थानों पर परिभाषित किया जा सकता है:
वर्ग परिभाषा के बाहर। कक्षा परिभाषा के अंदर।
यह स्पष्ट है कि, परिभाषा के स्थान पर ध्यान दिए बिना, फ़ंक्शन को एक ही कार्य करना चाहिए। इसलिए, फ़ंक्शन बॉडी के लिए कोड दोनों मामलों में समान होगा, हालांकि, फ़ंक्शन हेडर को परिभाषित करने के तरीके में एक सूक्ष्म अंतर है। इन दोनों दृष्टिकोणों पर इस खंड में विस्तार से चर्चा की गई है।
कक्षा परिभाषा के बाहर
एक वर्ग के अंदर घोषित सदस्य कार्यों को कक्षा के बाहर अलग से परिभाषित किया जाना है। उनकी परिभाषाएँ सामान्य कार्यों के समान ही हैं। उनके पास एक फंक्शन हेडर और एक फंक्शन बॉडी होनी चाहिए। चूंकि सी ++ फ़ंक्शन परिभाषा के पुराने संस्करण का समर्थन नहीं करता है, इसलिए एएनएसआई प्रोटोटाइप फॉर्म का उपयोग फ़ंक्शन हेडर को परिभाषित करने के लिए किया जाना चाहिए।
सदस्य फ़ंक्शन और सामान्य फ़ंक्शन के बीच एक महत्वपूर्ण अंतर यह है कि a
सदस्य फ़ंक्शन शीर्षलेख में सदस्यता पहचान लेबल शामिल करता है। यह 'लेबल बताता है'
संकलक किस वर्ग से संबंधित है। सदस्य फ़ंक्शन परिभाषा का सामान्य रूप है:
रिटर्न-टाइप क्लास-नैन :: फ़ंक्शन-नाम (तर्क घोषणा)
फंक्शन बॉडी
सदस्यता लेबल वर्ग-नाम: संकलक को बताता है कि फ़ंक्शन फ़ंक्शन-नाम वर्ग वर्ग-नाम से संबंधित है। अर्थात्, फ़ंक्शन का दायरा हेडर लाइन में निर्दिष्ट वर्ग नाम तक ही सीमित है। प्रतीक को स्कोप रेजोल्यूशन ऑपरेटर कहा जाता है।
उदाहरण के लिए, सदस्य कार्यों पर विचार करें getdata() तथा putdata(जैसा कि ऊपर चर्चा की गई है।
उन्हें निम्नानुसार कोडित किया जा सकता है:
शून्य वस्तु::
गेटडेटा (इंट ए, फ्लोट बी)
संख्या - ए; लागत - ख:
भेजना
ईसी 5.4
वोकेड
अंबर
सही ढंग से।
यह है
106
C . के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
इस कार्यक्रम में क्लास आइटम की सुविधा है। इस वर्ग में दो निजी चर और दो सार्वजनिक कार्य हैं। सदस्य फ़ंक्शन getdata() जिसे वर्ग के बाहर परिभाषित किया गया है, दोनों चरों को मान प्रदान करता है। जैसे कथनों के उपयोग पर ध्यान दें
नंबर ए
getdata0 की फ़ंक्शन परिभाषा में)। इससे पता चलता है कि सदस्य कार्यों में हो सकता है
निजी डेटा आइटम तक सीधी पहुंच।
सदस्य फ़ंक्शन putdata0 को कक्षा के अंदर परिभाषित किया गया है और इसलिए एक इनलाइन फ़ंक्शन की तरह व्यवहार करता है। यह फ़ंक्शन निजी चर संख्या और लागत के मान प्रदर्शित करता है
प्रोग्राम दो अलग-अलग कथनों में दो ऑब्जेक्ट, x और y बनाता है। इसे जोड़ा जा सकता है
एक बयान में।
आइटम एक्स वाई:
// वस्तुओं की एक सूची बनाता है
यहाँ कार्यक्रम 5.1 का आउटपुट है:
वस्तु x
संख्या: 100 लागत: 299.95
वस्तु y
संख्या :2001 लागत :175.5
उदाहरण के लिए हमने एक सदस्य फ़ंक्शन को इनलाइन के रूप में और दूसरे को बाहरी सदस्य फ़ंक्शन के रूप में दिखाया है। दोनों को इनलाइन या बाहरी कार्यों के रूप में परिभाषित किया जा सकता है।
5.6 एक बाहरी कार्य को इनलाइन करना
OOP का एक उद्देश्य कार्यान्वयन के विवरण को वर्ग से अलग करना है
परिभाषा। इसलिए कक्षा के बाहर सदस्य कार्यों को परिभाषित करना अच्छा अभ्यास है।
हम वर्ग परिभाषा के बाहर एक सदस्य फ़ंक्शन को परिभाषित कर सकते हैं और फिर भी इसे इनलाइन कर सकते हैं
फंक्शन डेफिनिशन की हेडर लाइन में सिर्फ क्वालीफायर इनलाइन का उपयोग करना। उदाहरण:
कक्षा स्टी
इनलिम
5.7 नंबर
हम अभी
हस का उपयोग करना
के द्वारा बुलाया गया
एक मिटिंग
आराम
सह लोक:
शून्य गेटडेटा (इंट ए, फ्लोट बी);
// घोषणा
Text translation
Source text
901 / 5000
Translation results
यह
और दो
ई क्लास
कक्षाएं और वस्तुएं
-107
पास होना
अमीर
एम्बर
बिनीड
वहाँ
कक्षा
ई बाय
इनलाइन शून्य आइटम :: गेटडेटा (इंट ए, फ्लोट बी) // परिभाषा
नंबर ए; लागत = बी;
5.7 सदस्य कार्यों का नेस्टिंग
हमने अभी चर्चा की है कि किसी वर्ग के सदस्य फ़ंक्शन को केवल उसी ऑब्जेक्ट द्वारा बुलाया जा सकता है। एक डॉट ऑपरेटर का उपयोग कर वर्ग। हालाँकि, इसका एक अपवाद है। एक सदस्य फ़ंक्शन को उसी वर्ग के किसी अन्य सदस्य फ़ंक्शन के अंदर उसके नाम का उपयोग करके बुलाया जा सकता है। इसे सदस्य कार्यों के नेस्टिंग के रूप में जाना जाता है। कार्यक्रम 5.2 इस सुविधा को दिखाता है।
सदस्य कार्यों का नेस्टिंग
#शामिल करें <iostream>
नेमस्पेस एसटीडी का उपयोग करना;
कक्षा सेट
इंट एम. एन: सार्वजनिक:
शून्य इनपुट (शून्य): शून्य प्रदर्शन (शून्य);
इंट सबसे बड़ा (शून्य);
इंट सेट :: सबसे बड़ा (शून्य)
अगर (एम> = एन)
वापसी (एम):
अन्यथा
वापसी (एन);
शून्य सेट :: इनपुट (शून्य))
cout <<m और n के इनपुट मान << "\n';
सिनेमा >>>>01
शून्य सेट :: प्रदर्शन (शून्य)
(जारी)
Text translation
Source text
1212 / 5000
Translation results
1080
C++ के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
cout << "सबसे बड़ा मान = << सबसे बड़ा () << "\ n":
मैं ataber समारोह बुला रहा हूँ
मुख्य प्रवेश बिंदु()
सेट ए;
ए इनपुट ();
एक प्रदर्शन();
वापसी 0;
कार्यक्रम 5.2 का आउटपुट होगा:
कार्यक्रम 5.2
m और n . के इनपुट मान
25 18
सबसे बड़ा मान = 25
5.8 निजी सदस्य कार्य
यद्यपि सभी डेटा आइटम को एक निजी अनुभाग में और सभी कार्यों को सार्वजनिक रूप से रखना सामान्य बात है, कुछ स्थितियों में बाहरी कॉलों से कुछ फ़ंक्शन (जैसे निजी डेटा) को छिपाने की आवश्यकता हो सकती है। ग्राहक फ़ाइल में किसी खाते को हटाने, या किसी कर्मचारी को वेतन वृद्धि प्रदान करने जैसे कार्य गंभीर परिणामों की घटनाएं हैं और इसलिए ऐसे कार्यों को संभालने वाले कार्यों में प्रतिबंधित पहुंच होनी चाहिए। हम इन कार्यों को निजी अनुभाग में रख सकते हैं।
एक निजी सदस्य फ़ंक्शन को केवल किसी अन्य फ़ंक्शन द्वारा बुलाया जा सकता है जो इसकी कक्षा का सदस्य है। यहां तक कि कोई ऑब्जेक्ट भी डीईटी ऑपरेटर का उपयोग करके एक निजी फ़ंक्शन का आह्वान नहीं कर सकता है। नीचे परिभाषित एक वर्ग पर विचार करें:
कक्षा नमूना
इंट एम;
शून्य पढ़ा (शून्य);
सह लोक:
शून्य अद्यतन (शून्य); शून्य लिखना (शून्य);
// निजी सदस्य समारोह
};
यदि sI नमूने की वस्तु है, तो
s1.पढ़ें ();
// काम नहीं करेगा; वस्तुओं तक नहीं पहुंच सकता
// निजी सदस्य
क्लास सिंध ऑब्जेक्ट्स
109
अवैध है। हेस्टवर, फ़ंक्शन read0 को m के मान को अद्यतन करने के लिए अद्यतन किए गए फ़ंक्शन द्वारा कॉल किया जा सकता है।
शून्य नमूना अद्यतन (शून्य)
पढ़ना();
// साधारण सेल; किसी वस्तु का उपयोग नहीं किया गया
5.9 कक्षा के भीतर सरणी
सरणियों का उपयोग कक्षा में सदस्य चर के रूप में किया जा सकता है। निम्न वर्ग परिभाषा है
वैध।
कास्ट इंट साइज = 10;
वर्ग सरणी
इंट ए [आकार:
a' इंट टाइप ऐरे है
कॉम
ईएनटी
इंग
बैठता
सह लोक:
शून्य सेटवल (शून्य);
शून्य प्रदर्शन (शून्य);
सरणी चर al 1 को वर्ग सरणी के एक निजी सदस्य के रूप में घोषित किया गया है, जिसका उपयोग किसी अन्य सरणी चर की तरह सदस्य कार्यों में किया जा सकता है। हम इस पर कोई भी ऑपरेशन कर सकते हैं उदाहरण के लिए, उपरोक्त वर्ग परिभाषा में, सदस्य फ़ंक्शन setval0 सरणी al 1 के तत्वों के मान सेट करता है, और डिस्प्ले () फ़ंक्शन मान प्रदर्शित करता है। इसी तरह, हम सरणी मानों पर कोई अन्य संचालन करने के लिए अन्य सदस्य कार्यों का उपयोग कर सकते हैं।
आइए हम उन वस्तुओं की खरीदारी सूची पर विचार करें जिनके लिए हम हर महीने एक डीलर को ऑर्डर देते हैं। सूची में प्रत्येक आइटम की कोड संख्या और कीमत जैसे विवरण शामिल हैं। हम सूची में एक आइटम जोड़ने, सूची से किसी आइटम को हटाने और ऑर्डर के कुल मूल्य को प्रिंट करने जैसे संचालन करना चाहते हैं। प्रोग्राम 5.3 दिखाता है कि डेटा सदस्यों के रूप में सरणी वाले वर्ग का उपयोग करके इन परिचालनों को कैसे कार्यान्वित किया जाता है।
प्रसंस्करण खरीदारी सूची
#शामिल करें <iostream
नेमस्पेस एसटीडी का उपयोग करना;
कास्ट #-504
वर्ग आइटम
(जारी)
सरणी आकार के लिए
प्रदान करता है
कक्षाएं और वस्तुएं
111
cout << "\nकोड मूल्य\n":
के लिए (int 1-0: 1-गिनती: 1++)
cout << "\ n" << आइटमकोड [i]; cout <<" << आइटम मूल्य [i];
कोउट << "\ n":
मुख्य प्रवेश बिंदु()
आइटम ऑर्डर:
आदेश। सीएनटी ();
इंट एक्स;
करना
// करते हैं .... जबकि लूप
cout << "\nआप निम्न कार्य कर सकते हैं:"
<< "उचित संख्या दर्ज करें \n":
cout << "\n1: एक आइटम जोड़ें": cout << "\n2: कुल मूल्य प्रदर्शित करें":
cout << "\n3: एक आइटम हटाएं":
cout << "\ n4: सभी आइटम प्रदर्शित करें";
cout << An5: छोड़ें":"
cout << "\n\nआपका विकल्प क्या है?";
सिनेमा >> एक्स;
स्विच (एक्स)
केस 1: ऑर्डर.गेटिटम (); टूटना;
केस 2 ऑर्डर। डिस्प्लेसम (); टूटना; केस 3: ऑर्डर। हटाएं (); टूटना;
केस 4: ऑर्डर.डिस्प्लेआइटम्स (); टूटना;
केस 5: ब्रेक;
डिफ़ॉल्ट: cout << "इनपुट में त्रुटि; पुनः प्रयास करें\n":
जबकि (एक्स - 5);
करो...समाप्त होने तक
वापसी 0;
कार्यक्रम 5.3
कक्षाएं और वस्तुएं
113
आप निम्न कार्य कर सकते हैं: उपयुक्त संख्या दर्ज करें 1: एक आइटम जोड़ें
2: कुल मूल्य प्रदर्शित करें
3: एक आइटम हटाएं 4 सभी आइटम प्रदर्शित करें
5: छोड़ो
आपका विकल्प क्या है?3 आइटम कोड दर्ज करें:222
आप निम्न कार्य कर सकते हैं: उपयुक्त संख्या दर्ज करें
1: एक आइटम जोड़ें 2 कुल मूल्य प्रदर्शित करें
3: एक आइटम हटाएं
4: सभी आइटम प्रदर्शित करें।
5: छोड़ो
आपका विकल्प क्या है24
कोड मूल्य
111
222
333
100
0
300
आप निम्न कार्य कर सकते हैं; उपयुक्त संख्या दर्ज करें
1: एक आइटम जोड़ें
2 कुल मान 3 प्रदर्शित करें: एक आइटम हटाएं
4 सभी आइटम प्रदर्शित करें
5: छोड़ो
आपका विकल्प क्या है?5
ध्यान दें
कार्यक्रम दो सरणियों का उपयोग करता है, अर्थात् itemCodel | कीमतों को बनाए रखने के लिए आइटम और आइटमप्रिकेल की कोड संख्या रखने के लिए]। सूची में आइटम का रिकॉर्ड रखने के लिए तीसरे डेटा सदस्य गणना का उपयोग किया जाता है। कार्यक्रम सूची में किए जाने वाले कार्यों को लागू करने के लिए कुल चार कार्यों का उपयोग करता है। बयान
कास्ट इंट एम = 50;
सरणी सदस्यों के आकार को परिभाषित करता है।
पहला फ़ंक्शन CNT) केवल चर गणना को शून्य पर सेट करता है। दूसरा फ़ंक्शन getitem आइटम कोड और आइटम की कीमत अंतःक्रियात्मक रूप से प्राप्त करता है और उन्हें सरणी सदस्यों आइटमकोड [गिनती] और आइटमप्राइस [गिनती] को असाइन करता है। ध्यान दें कि इस फ़ंक्शन के अंदर गिनती
1140
C++ के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
असाइनमेंट ऑपरेशन समाप्त होने के बाद वृद्धि हुई है। फ़ंक्शन डिस्प्लेसम () पहले ऑर्डर के कुल मूल्य का मूल्यांकन करता है और फिर मूल्य को प्रिंट करता है। चौथा फ़ंक्शन हटाएं) सूची से किसी दिए गए आइटम को हटा देता है। यह सूची में इसका पता लगाने के लिए आइटम कोड का उपयोग करता है और मूल्य को शून्य पर सेट करता है यह दर्शाता है कि आइटम सूची में 'सक्रिय' नहीं है। अंत में, फ़ंक्शन displayItems () सूची में सभी आइटम प्रदर्शित करता है।
कार्यक्रम मेनू-आधारित यूजर इंटरफेस का उपयोग करके सभी कार्यों को लागू करता है।
5.10 वस्तुओं के लिए स्मृति आवंटन
हमने कहा है कि वस्तुओं के लिए स्मृति स्थान आवंटित किया जाता है जब उन्हें घोषित किया जाता है न कि जब वर्ग निर्दिष्ट किया जाता है। यह कथन केवल आंशिक रूप से सत्य है। दरअसल, सदस्य फ़ंक्शन केवल एक बार मेमोरी स्पेस में बनाए और रखे जाते हैं, जब उन्हें एक वर्ग विनिर्देश के एक भाग के रूप में परिभाषित किया जाता है। चूंकि उस वर्ग से संबंधित सभी वस्तुएं समान सदस्य कार्यों का उपयोग करती हैं, इसलिए सदस्य कार्यों के लिए कोई अलग स्थान आवंटित नहीं किया जाता है जब ऑब्जेक्ट बनाए जाते हैं प्रत्येक ऑब्जेक्ट के लिए केवल सदस्य चर के लिए अलग से स्थान आवंटित किया जाता है। वस्तुओं के लिए अलग स्मृति स्थान आवश्यक हैं, क्योंकि सदस्य चर विभिन्न वस्तुओं के लिए अलग-अलग डेटा मान रखेंगे। यह चित्र 5.3 में दिखाया गया है।
सभी ऑब्जेक्ट सदस्य फ़ंक्शन के लिए सामान्य 1
सदस्य समारोह 2
फ़ंक्शन परिभाषित होने पर बनाई गई मेमोरी
वस्तु 1
वस्तु 2
वस्तु 3
सदस्य चर 1
सदस्य चर 1
सदस्य चर 1
सदस्य चर 2
सदस्य चर 2
सदस्य चर 2
वस्तुओं को परिभाषित करते समय बनाई गई मेमोरी
अंजीर 53 स्मृति का बाईट
कक्षाएं और वस्तुएं
5.11 स्थिर डेटा सदस्य
किसी वर्ग के डेटा सदस्य को स्थिर के रूप में योग्य बनाया जा सकता है। स्टैटिक मी वेरिएबल के गुण C स्टैटिक वेरिएबल के समान होते हैं। एक स्थिर सदस्य चर में c विशेष विशेषताएँ होती हैं। य़े हैं :
. जब इसकी कक्षा की पहली वस्तु बनाई जाती है तो इसे शून्य से प्रारंभ किया जाता है। किसी अन्य को ization की अनुमति नहीं है।
उस सदस्य की केवल एक प्रति पूरे वर्ग के लिए बनाई जाती है और उस वर्ग की वस्तुओं द्वारा साझा की जाती है, चाहे कितनी भी वस्तुएँ बनाई जाएँ।
यह केवल कक्षा के भीतर ही दिखाई देता है, लेकिन इसका जीवनकाल पूरा कार्यक्रम है। स्टेटिक वेरिएबल्स का उपयोग आम तौर पर संपूर्ण वर्ग के लिए सामान्य मूल्यों को बनाए रखने के लिए किया जाता है
उदाहरण के लिए, एक स्थिर डेटा सदस्य का उपयोग काउंटर के रूप में किया जा सकता है जो वस्तुओं की घटनाओं को रिकॉर्ड करता है। प्रोग्राम 5.4 एक स्थिर डेटा सदस्य के उपयोग को दिखाता है।
स्थिर वर्ग सदस्य
#शामिल करें <iostream>
नेमस्पेस एसटीडी का उपयोग करना;
वर्ग वस्तु
पहला
NS
पर
रा
डीईआर
एसए
हिट
ईडी।
जिज्ञासा
टा
स्थिर इंट गिनती; इंट नंबर;
शून्य गेटडेटा (int a)
सह लोक:
संख्या = ए;
गिनती++;
शून्य गेटकाउंट (शून्य)
cout << "गिनती:"; cout << गिनती << "\ n";
एलिंट आइटम :: गिनती;
मुख्य प्रवेश बिंदु()
1160
C++ के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
आइटम ए, बी, सी:
ए.गेटकाउंट ();
// गिनती शून्य से शुरू होती है // प्रदर्शन गिनती
बी.गेटकाउंट ();
सी.गेटकाउंट ();
ए.गेटडेटा (100);
// ऑब्जेक्ट में डेटा प्राप्त करना a
बी.गेटडेटा (200); सी.गेटडेटा (300);
cout << "डेटा पढ़ने के बाद <<"\n";
ऑब्जेक्ट बी में डेटा प्राप्त करना // ऑब्जेक्ट सी में डेटा प्राप्त करना
ए.गेटकाउंट ();
बी.गेटकाउंट ();
// प्रदर्शन गिनती
सी.गेटकाउंट (); वापसी 0;
कार्यक्रम 5.4
कार्यक्रम 5.4 का आउटपुट होगा:
गिनती: 0
गिनती: 0
गिनती: 0
डेटा पढ़ने के बाद
गिनती: 3
गिनती: 3
गिनती: 3
ध्यान दें
कार्यक्रम में निम्नलिखित कथन पर ध्यान दें:
इंट आइटम :: गिनती;
स्थिर डेटा सदस्य की परिभाषा I
ध्यान दें कि प्रत्येक स्थिर सदस्य चर के प्रकार और दायरे को वर्ग परिभाषा के बाहर परिभाषित किया जाना चाहिए। यह आवश्यक है क्योंकि स्थिर डेटा सदस्यों को किसी वस्तु के हिस्से के बजाय अलग से संग्रहीत किया जाता है। चूँकि वे किसी वर्ग वस्तु के बजाय स्वयं वर्ग से जुड़े होते हैं, इसलिए उन्हें वर्ग चर के रूप में भी जाना जाता है।
जब ऑब्जेक्ट बनाए जाते हैं तो स्टैटिक वेरिएबल काउंट को शून्य से इनिशियलाइज़ किया जाता है। जब भी डेटा को किसी ऑब्जेक्ट में पढ़ा जाता है तो गिनती बढ़ जाती है। चूंकि डेटा को तीन बार ऑब्जेक्ट में पढ़ा जाता है, इसलिए वैरिएबल काउंट तीन गुना बढ़ जाता है। क्योंकि सभी तीन वस्तुओं द्वारा साझा की गई गणना की केवल एक प्रति है, तीनों आउटपुट स्टेटमेंट के कारण मान 3 प्रदर्शित होता है। चित्र 5.4 दिखाता है कि वस्तुओं द्वारा एक स्थिर चर का उपयोग कैसे किया जाता है।
कक्षाएं और वस्तुएं
वस्तु 2
वस्तु 1 संख्या
संख्या
वस्तु 3 संख्या
117
100
200
300
3
गिनती (तीनों वस्तुओं के लिए सामान्य)
अंजीर। 5.4 एक स्थिर डेटा सदस्य के रूप में साझा करना
स्थैतिक चर गैर-इनलाइन सदस्य कार्यों की तरह हैं क्योंकि उन्हें एक वर्ग घोषणा में घोषित किया जाता है और स्रोत फ़ाइल में परिभाषित किया जाता है। एक स्थिर चर को परिभाषित करते समय, कुछ प्रारंभिक मान भी चर को सौंपा जा सकता है। उदाहरण के लिए, निम्नलिखित परिभाषा प्रारंभिक मान 10 की गणना करती है।
इंट आइटम :: गिनती = 10;
5.12 स्थिर सदस्य कार्य
स्थिर सदस्य चर की तरह, हमारे पास स्थिर सदस्य कार्य भी हो सकते हैं। एक सदस्य फ़ंक्शन जिसे स्थिर घोषित किया गया है, में निम्नलिखित गुण हैं:
एक स्थिर फ़ंक्शन के पास केवल अन्य स्थिर सदस्यों तक पहुंच हो सकती है (फ़ंक्शंस या
चर) एक ही कक्षा में घोषित किया गया। एक स्थिर सदस्य फ़ंक्शन को वर्ग नाम (इसकी वस्तुओं के बजाय) का उपयोग करके बुलाया जा सकता है।
निम्नलिखित नुसार:
वर्ग-नाम :: फ़ंक्शन-नाम;
कार्यक्रम 5.5 इन विशेषताओं के कार्यान्वयन को दर्शाता है। स्थैतिक फ़ंक्शन शोकाउंट () उस क्षण तक बनाई गई वस्तुओं की संख्या प्रदर्शित करता है। बनाई गई वस्तुओं की संख्या की गणना स्थिर चर गणना द्वारा की जाती है।
फ़ंक्शन शोकोड () प्रत्येक ऑब्जेक्ट की कोड संख्या प्रदर्शित करता है।
सी
1180
C++ के साथ ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग
स्थिर सदस्य समारोह
#शामिल करें <iostream>
नेमस्पेस एसटीडी का उपयोग करना;
कक्षा परीक्षण
इंट कोड:
स्थिर इंट गिनती:
शून्य सेटकोड (शून्य)
सह लोक:
11 स्थिर सदस्य चर
कोड = ++ गिनती;
शून्य शोकोड (शून्य)
cout << "ऑब्जेक्ट नंबर: << कोड << "\ n";
स्थिर शून्य प्रदर्शन गणना (शून्य)
// स्थिर सदस्य फ़ंक्शन
cout << "गिनती: << गिनती <<"\n";
19
इंट टेस्ट :: गिनती; मुख्य प्रवेश बिंदु()
परीक्षण 11, 12:
tl.सेटकोड (); 12.सेटकोड ():
परीक्षण :: शोकाउंट ();
// स्टेटिक फंक्शन एक्सेस करना
परीक्षण 13; 13.सेटकोड ():
शोकाउंट के रूप में परीक्षण ();
$1.शोकोड (); 12.शोकोड ();
13.स्नोकोड ();
वापसी 0;
कार्यक्रम 5.5
कक्षाएं और वस्तुएं
119
कार्यक्रम का आउटपुट 5.5:
गिनती: 2
गिनती: 3
वस्तु संख्या: 1
वस्तु संख्या: 2
वस्तु संख्या: 3
ध्यान दें कि कथन
ध्यान दें
रैम 5.5
कोड ++ गिनती;
जब भी सेटकोड () फ़ंक्शन को लागू किया जाता है और गिनती का वर्तमान मान कोड को सौंपा जाता है, तो इसे निष्पादित किया जाता है। चूंकि प्रत्येक वस्तु के पास कोड की अपनी प्रति होती है, इसलिए कोड में निहित मान उसकी वस्तु की एक अद्वितीय संख्या का प्रतिनिधित्व करता है।
याद रखें, निम्नलिखित फ़ंक्शन परिभाषा काम नहीं करेगी:
स्थैतिक शून्य शोकाउंट () 1
cout << कोड: // कोड स्थिर नहीं है
1
5.13 वस्तुओं की सरणी
हम जानते हैं कि एक सरणी संरचना सहित किसी भी डेटा प्रकार की हो सकती है। इसी तरह, हम भी कर सकते हैं। चर के सरणियाँ हैं जो प्रकार वर्ग के हैं। ऐसे चरों को वस्तुओं का सरणी कहा जाता है। निम्नलिखित वर्ग परिभाषा पर विचार करें:
वर्ग कर्मचारी
चार नाम [30]; तैरने की उम्र;
सार्वजनिक: शून्य गेटडेटा (शून्य);
शून्य पुटडेटा (शून्य);
पहचानकर्ता कर्मचारी एक उपयोगकर्ता-परिभाषित डेटा प्रकार है और इसका उपयोग उन वस्तुओं को बनाने के लिए किया जा सकता है जो कर्मचारियों की विभिन्न श्रेणियों से संबंधित हैं। उदाहरण:
कर्मचारी प्रबंधक [3]:
कर्मचारी फोरमैन [15]:
// प्रबंधक की सरणी
फोरमैन की सरणी
// कार्यकर्ता की सरणी
कर्मचारी कार्यकर्ता [75]:
Text translation
Source text
1227 / 5000
Translation results
1200
C++ के साथ ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग
सरणी प्रबंधक में तीन ऑब्जेक्ट (प्रबंधक) होते हैं, अर्थात्, प्रबंधक [0], प्रबंधक [1] और प्रबंधक [2], प्रकार के कर्मचारी वर्ग। इसी तरह, फोरमैन ऐरे में 15 ऑब्जेक्ट (फोरमैन) होते हैं और वर्कर ऐरे में 75 ऑब्जेक्ट (वर्कर) होते हैं।
चूंकि वस्तुओं की एक सरणी किसी अन्य सरणी की तरह व्यवहार करती है, हम सामान्य सरणी का उपयोग कर सकते हैं
व्यक्तिगत तत्वों तक पहुँचने के तरीकों तक पहुँचने के लिए, और फिर डॉट सदस्य ऑपरेटर तक पहुँचने के लिए
सदस्य कार्य करता है। उदाहरण के लिए, कथन
प्रबंधक [i]। पुटडेटा ();
सरणी प्रबंधक के ith तत्व का डेटा प्रदर्शित करेगा। यही है, यह कथन ऑब्जेक्ट मैनेजर [i] से सदस्य फ़ंक्शन putdata() को आमंत्रित करने का अनुरोध करता है।
वस्तुओं की एक सरणी स्मृति के अंदर उसी तरह संग्रहीत की जाती है जैसे बहु-आयामी सरणी। सरणी प्रबंधक को चित्र 5.5 में दर्शाया गया है। ध्यान दें कि केवल वस्तुओं के डेटा आइटम के लिए स्थान बनाया गया है। सदस्य कार्यों को अलग से संग्रहीत किया जाता है और सभी वस्तुओं द्वारा उपयोग किया जाएगा।
नाम
उम्र
प्रबंधक [0]
नाम
प्रबंधक(1)
उम्र
नाम
प्रबंधक[2]
उम्र
चित्र 5.5 किसी ऑब्जेक्ट सरणी के डेटा आइटम का संग्रहण
प्रोग्राम 5.6 ऑब्जेक्ट सरणियों के उपयोग को दिखाता है।
वस्तुओं की सरणियाँ
#शामिल करें <iostream
नेमस्पेस एसटीडी का उपयोग करना;
वर्ग कर्मचारी
(जारी)
कक्षाएं और वस्तुएं
121
मेज़र [1]
5 वस्तुएं
अल सरणी
उपयोग करने के लिए
चार नाम [30]:
// वर्ग सदस्य के रूप में स्ट्रिंग
तैरने की उम्र; सह लोक:
शून्य गेटडेटा (शून्य); शून्य पुटडेटा (शून्य):
शून्य कर्मचारी :: गेटडेटा (शून्य)
cout << "नाम दर्ज करें:";
सिने
>> नाम;
cout<<"आयु दर्ज करें:"; सिनेमा >> उम्र;
शून्य कर्मचारी :: पुटडेटा (शून्य)
cout << "नाम:"<<नाम << "\n"; cout << "आयु: << आयु <<"\n";
कॉन्स्ट इंट साइज = 3; मुख्य प्रवेश बिंदु()
कर्मचारी प्रबंधक [आकार]: के लिए (int 1-0; 1-आकार: 1)
cout << "\nप्रबंधक का विवरण << 1+1 << "\n";
प्रबंधक [1]। getdata ();
कोउट <<< "\ n"; के लिए (i = 0; मैं <आकार: (++)
cout << "\nप्रबंधक <1+1 << "\n":
प्रबंधक [1] पुटडेटा ();
वापसी 0;
कैटेमेंट
तांत्रिक
टा आइटम
आप सभी
कार्यक्रम 5.6
यह एक इंटरेक्टिव प्रोग्राम है, इनपुट डेटा और प्रोग्राम आउटपुट नीचे दिखाया गया है।
इंटरएक्टिव इनपुट
प्रबंधक का विवरण
नाम दर्ज करें: XXX
उम्र दर्ज करें: 45
जारी)
122
C . के साथ ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग
प्रबंधक2 . का विवरण
नाम दर्ज करें: एफ उम्र दर्ज करें: 37
प्रबंधक3 . का विवरण
नाम दर्ज करें: 22 आयु दर्ज करें: 50
प्रोग्राम आउटपुट
प्रबंधक1 नाम: xxx
आयु: 45
प्रबंधक2
नाम: वर्ष आयु: 37
प्रबंधक3 नाम: zzz आयु: 50
5.14 फंक्शन आर्ग्युमेंट्स के रूप में वस्तुएँ
किसी भी अन्य डेटा प्रकार की तरह, किसी ऑब्जेक्ट को फ़ंक्शन तर्क के रूप में उपयोग किया जा सकता है। यह संभव है
दो तरीके से
पूरे ऑब्जेक्ट की एक प्रति फ़ंक्शन को पास की जाती है। फ़ंक्शन में केवल ऑब्जेक्ट का पता स्थानांतरित किया जाता है।
पहली विधि को पास-बाय-वैल्यू कहा जाता है। चूंकि ऑब्जेक्ट की एक कॉपी फ़ंक्शन को पास की जाती है, फ़ंक्शन के अंदर ऑब्जेक्ट में किए गए कोई भी परिवर्तन फ़ंक्शन को कॉल करने के लिए उपयोग किए गए ऑब्जेक्ट को प्रभावित नहीं करते हैं। दूसरी विधि को पास-बाय-रेफरेंस कहा जाता है। जब ऑब्जेक्ट का पता पास हो जाता है, तो कॉल किया गया फ़ंक्शन कॉल में उपयोग की जाने वाली वास्तविक वस्तु पर सीधे काम करता है। इसका मतलब है कि फ़ंक्शन के अंदर ऑब्जेक्ट में किए गए कोई भी परिवर्तन वास्तविक ऑब्जेक्ट में दिखाई देंगे। पास-बाय संदर्भ विधि अधिक कुशल है क्योंकि इसमें केवल वस्तु का पता पारित करने की आवश्यकता होती है, न कि संपूर्ण वस्तु की।
प्रोग्राम 5.7 ऑब्जेक्ट के उपयोग को फ़ंक्शन तर्कों के रूप में दिखाता है। यह घंटे और मिनट के प्रारूप में समय जोड़ने का कार्य करता है।
कक्षाएं और वस्तुएं
123
तर्क के रूप में वस्तुएँ
#शामिल करें <iostream
नेमस्पेस एसटीडी का उपयोग करना;
कक्षा का समय
अंतर घंटे:
इंट मिनट; सार्वजनिक: ली
बौज़स्टर: 16)
शून्य गेटटाइम (इंट एच, इंट एम) (घंटे एच; मिनट;)
शून्य पुटटाइम (शून्य)
cout << घंटे << घंटे और ";
cout << मिनट << "मिनट" << "\ n";
शून्य राशि (समय, समय); // वस्तुओं के साथ तर्क के रूप में घोषणा
शून्य समय :: योग (समय टीआई, समय टी 2)
मिनट टी.एल.मिनट 12.मिनट; घंटे मिनट/60;
मिनट मिनट 60;
घंटे घंटे + tl.hours + t2.hours;
ती, 12 वस्तुएँ हैं
मुख्य प्रवेश बिंदु()
समय टी 1, 12, 13;
11.गेटटाइम (2,45); // 71 . प्राप्त करें
12.गेटटाइम (3,30); // टी 2 प्राप्त करें
T3.sum (T1, T2);// 13-11+T2
cout<<"T1 T1.puttime (); cout << T2 T2.puttime (); cout <T3 T3.puttime ();
// डिस्प्ले TI // डिस्प्ले T2 // डिस्प्ले T396
वापसी 0;
कार्यक्रम 5.7
कक्षाएं और वस्तुएं
123
तर्क के रूप में वस्तुएँ
#शामिल करें <iostream
नेमस्पेस एसटीडी का उपयोग करना;
कक्षा का समय
अंतर घंटे:
इंट मिनट; सार्वजनिक: ली
बौज़स्टर: 16)
शून्य गेटटाइम (इंट एच, इंट एम) (घंटे एच; मिनट;)
शून्य पुटटाइम (शून्य)
cout << घंटे << घंटे और ";
cout << मिनट << "मिनट" << "\ n";
शून्य राशि (समय, समय); // वस्तुओं के साथ तर्क के रूप में घोषणा
शून्य समय :: योग (समय टीआई, समय टी 2)
मिनट टी.एल.मिनट 12.मिनट; घंटे मिनट/60;
मिनट मिनट 60;
घंटे घंटे + tl.hours + t2.hours;
ती, 12 वस्तुएँ हैं
मुख्य प्रवेश बिंदु()
समय टी 1, 12, 13;
11.गेटटाइम (2,45); // 71 . प्राप्त करें
12.गेटटाइम (3,30); // टी 2 प्राप्त करें
T3.sum (T1, T2);// 13-11+T2
cout<<"T1 T1.puttime (); cout << T2 T2.puttime (); cout <T3 T3.puttime ();
// डिस्प्ले TI // डिस्प्ले T2 // डिस्प्ले T396
वापसी 0;
कार्यक्रम 5.7
Text translation
Source text
1588 / 5000
Translation results
कक्षाएं और वस्तुएं
125
एक बाहरी फ़ंक्शन को एक वर्ग के लिए "दोस्ताना" बनाने के लिए, हमें बस इस फ़ंक्शन को कक्षा के मित्र के रूप में घोषित करना होगा जैसा कि नीचे दिखाया गया है:
कक्षा एबीसी
सह लोक:
मित्र शून्य xyz (शून्य);
T2
चे
रा
तेरा
2
// घोषणा
फ़ंक्शन घोषणा कीवर्ड मित्र से पहले होनी चाहिए। फ़ंक्शन को सामान्य C++ फ़ंक्शन की तरह प्रोग्राम में कहीं और परिभाषित किया गया है। फ़ंक्शन परिभाषा या तो कीवर्ड मित्र या स्कोप ऑपरेटर का उपयोग नहीं करती है। मित्र कीवर्ड के साथ घोषित किए गए कार्यों को मित्र फ़ंक्शन के रूप में जाना जाता है। एक समारोह को किसी भी वर्ग में मित्र के रूप में घोषित किया जा सकता है। एक मित्र फ़ंक्शन, हालांकि सदस्य फ़ंक्शन नहीं है, लेकिन कक्षा के निजी सदस्यों तक पूर्ण पहुंच अधिकार है।
एक मित्र फ़ंक्शन में कुछ विशेष विशेषताएं होती हैं:
• यह उस वर्ग के दायरे में नहीं है जिसके लिए इसे मित्र घोषित किया गया है। • चूंकि यह वर्ग के दायरे में नहीं है, इसलिए इसे उस की वस्तु का उपयोग करके नहीं कहा जा सकता है
कक्षा। . इसे बिना किसी ऑब्जेक्ट की मदद के सामान्य फंक्शन की तरह इनवाइट किया जा सकता है। सदस्य कार्यों के विपरीत, यह सीधे सदस्य नामों तक नहीं पहुंच सकता है और प्रत्येक सदस्य नाम के साथ ऑब्जेक्ट नाम और डॉट सदस्यता ऑपरेटर का उपयोग करना पड़ता है। (उदा।
ए.एक्स). इसे बिना किसी प्रभाव के किसी वर्ग के सार्वजनिक या निजी भाग में घोषित किया जा सकता है
इसके अर्थ में।
• आमतौर पर, इसमें ऑब्जेक्ट तर्क के रूप में होते हैं।
फ्रेंड फंक्शन अक्सर ऑपरेटर ओवरलोडिंग में उपयोग किए जाते हैं जिस पर बाद में चर्चा की जाएगी।
प्रोग्राम 5.8 फ्रेंड फंक्शन के उपयोग को दिखाता है।
मित्र समारोह
#शामिल करें <iostream>
नेमस्पेस एसटीडी का उपयोग करना;
कक्षा नमूना
(जारी)
कक्षाएं और वस्तुएं -
127
दोस्त इंट एक्स :: fun1 ():
// fun1 () x का // Y का मित्र है
फ़ंक्शन fun10 कक्षा X का सदस्य है और कक्षा Y का मित्र है।
हम एक वर्ग के सभी सदस्य कार्यों को दूसरे वर्ग के मित्र कार्यों के रूप में भी घोषित कर सकते हैं। ऐसे मामलों में, वर्ग को मित्र वर्ग कहा जाता है। इसे निम्नानुसार निर्दिष्ट किया जा सकता है:
कक्षा Z
दोस्त कक्षा दस;
// एक्स के सभी सदस्य कार्य हैं
// दोस्तों को Z
कार्यक्रम 5.9 प्रदर्शित करता है कि मित्र किस प्रकार कक्षाओं के बीच एक सेतु के रूप में कार्य करता है।
दो वर्गों के लिए अनुकूल समारोह
#शामिल करें <iostream>
नेमस्पेस एसटीडी का उपयोग करना;
कक्षा एबीसी;
1/अग्रेषित घोषणा
8
रा
कक्षा XYZ
इंट एक्स; सह लोक:
शून्य सेटवैल्यू (int i) (x = 1;) मित्र शून्य अधिकतम (XYZ, ABC);
कक्षा एबीसी
इंट ए; सह लोक:
शून्य सेटवैल्यू (इंट आई) (ए = 1;) मित्र शून्य अधिकतम (एक्सवाईजेड, एबीसी);
(Conta
More about this source text
Send feedback
More about this source text
Send feedback
More about this source text
Send feedback
More about this source text
Send feedback
More about this source text
Send feedback
कक्षाएं और वस्तुएं
131
मित्र जटिल योग (जटिल, जटिल) अंत यदि वे
वोल्ड शो (जटिल);
सम्मिश्र योग (जटिल c1, सम्मिश्र c2)
जटिल c3; c3.x cl.x+ c2.x;
// ऑब्जेक्ट c3 बनाया गया है
c3.y cl.y + c2.y; वापसी (सी 3);
// ऑब्जेक्ट c3 लौटाता है
शून्य परिसर :: शो (जटिल सी)
cout << c.x <<"+g" << c.y << "\n";
मुख्य प्रवेश बिंदु()
जटिल ए बी, सी:
ए इनपुट (3.1, 5.65); बी इनपुट (2.75, 1.2);
सी-योग (ए, बी):
// सी = ए + बी
cout<<"A" A.show(A); cout << "बी": बी.शो (बी);
कोउट << "सी"; सी.शो (सी);
वापसी 0;
कृपया
प्रति
कार्यक्रम 5.11
निष्पादन पर, प्रोग्राम 5.11 निम्नलिखित आउटपुट उत्पन्न करेगा:
बाटा ए 3.1 35.65 बी 2.75 +1.2
सी = 5.85+j6.85
कार्यक्रम एक तीसरी जटिल संख्या C उत्पन्न करने के लिए दो सम्मिश्र संख्या A और B जोड़ता है और तीनों संख्याओं को प्रदर्शित करता है।
More about this source text
Send feedback
Comments
Post a Comment