अब समय है C++ के मुख्य पैराडाइम में से एक पर आने का: ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP)।
OOP classes के इर्द-गिर्द घूमती है, यानी उपयोगकर्ता द्वारा परिभाषित डेटा टाइप, जिनके अपने संबंधित फंक्शन होते हैं।
हम बुनियादी बातों से शुरू करेंगे और सिलेबस में आगे जाने पर और भी उन्नत विषयों पर बात करेंगे।
क्लास में मेंबर वेरिएबल और मेंबर फंक्शन हो सकते हैं।
इन्हें मेंबर सेलेक्शन ऑपरेटर . से एक्सेस किया जाता है।
क्लास के बाहर के वेरिएबल की तरह ही, मेंबर वेरिएबल को घोषित करते समय ही कोई वैल्यू देकर इनिशियलाइज़ कर देना बेहतर होता है।
तब यह वैल्यू इस क्लास के नए बनाए गए ऑब्जेक्ट के लिए डिफॉल्ट बन जाती है।
क्लास अपने मेंबर तक पहुँच सीमित करने का विकल्प देती है।
दो बुनियादी access specifiers हैं private और public।
private मेंबर क्लास के बाहर से एक्सेस नहीं किए जा सकते।
public मेंबर खुलकर एक्सेस किए जा सकते हैं।
class के सारे मेंबर डिफॉल्ट रूप से private होते हैं।
क्लास के बाहर खुलकर सिर्फ वही मेंबर इस्तेमाल किए जा सकते हैं, जिन्हें साफ तौर पर public चिह्नित किया गया हो।
एक class की परिभाषा नीचे के उदाहरण में देखी जा सकती है।
ध्यान दीजिए कि परिभाषा के बाद ; लगता है:
class Wizard {
public: // from here on all members are publicly accessible
int cast_spell() { // defines the public member function cast_spell
return damage;
}
std::string name{}; // defines the public member variable `name`
private: // from here on all members are private
int damage{5}; // defines the private member variable `damage`
};
क्लास के अंदर से आप सभी मेंबर वेरिएबल एक्सेस कर सकते हैं।
cast_spell फंक्शन के अंदर damage पर एक नज़र डालिए।
क्लास के बाहर से आप private मेंबर को न पढ़ सकते हैं, न बदल सकते हैं:
Wizard silverhand{};
// calling the `cast_spell` function is okay, it is public:
silverhand.cast_spell();
// => 5
// name is public and can be changed:
silverhand.name = "Laeral";
// damage is private:
silverhand.damage = 500;
// => Compilation error
कंस्ट्रक्टर ऑब्जेक्ट बनाते समय मेंबर वेरिएबल को वैल्यू असाइन करने का मौका देते हैं।
इनका नाम class जैसा ही होता है और इनका कोई रिटर्न टाइप नहीं होता।
एक क्लास में कई कंस्ट्रक्टर हो सकते हैं।
यह तब काम आता है, जब आपको हर बार सभी वेरिएबल सेट करने की ज़रूरत न हो।
कभी-कभी आप सब कुछ डिफॉल्ट पर रखना चाहते हैं, लेकिन name वेरिएबल बदलना चाहते हैं।
किसी खास Wizard के मामले में आप damage भी बदलना चाह सकते हैं, इसलिए आपको दो constructors चाहिए।
class Wizard {
public:
Wizard(std::string new_name) {
name = new_name;
}
Wizard(std::string new_name, int new_damage) {
name = new_name;
damage = new_damage;
}
int cast_spell() {
return damage;
}
std::string name{};
private:
int damage{5};
};
Wizard el{"Eleven"}; // deals 5 damage
Wizard vecna{"Vecna", 50}; // deals 50 damage
कंस्ट्रक्टर एक बड़ा विषय है और इसमें कई बारीकियाँ हैं।
अगर आप अपनी class के लिए साफ तौर पर कोई constructor नहीं बनाते, तो तभी, और सिर्फ तभी, कंपाइलर यह काम आपके लिए कर देगा।
ऊपर के पहले उदाहरण में यही हुआ है।
silverhand ऑब्जेक्ट डिफॉल्ट कंस्ट्रक्टर को कॉल करके बनाया गया है, कोई आर्गुमेंट पास नहीं किया गया।
सभी वेरिएबल उसी वैल्यू पर सेट हो जाते हैं जो क्लास की परिभाषा में लिखी थी।
अगर आपने उस परिभाषा में कोई वैल्यू न दी होती, तो वेरिएबल बिना इनिशियलाइज़ किए रह सकते थे, जिसके अनचाहे परिणाम हो सकते हैं।
स्ट्रक्ट भाषा की शुरुआती C जड़ों से आए हैं और C++ जितने ही पुराने हैं।
व्यावहारिक रूप से ये classes जैसी ही चीज़ें हैं, बस एक जरूरी अपवाद के साथ।
डिफॉल्ट रूप से class में सब कुछ private होता है।
दूसरी ओर, स्ट्रक्ट तब तक public रहते हैं जब तक कुछ और तय न किया जाए।
परंपरा से struct कीवर्ड का इस्तेमाल अक्सर सिर्फ डेटा रखने वाली संरचनाओं के लिए किया जाता है।
जिन ऑब्जेक्ट को कुछ निश्चित गुण सुनिश्चित करने होते हैं, उनके लिए class कीवर्ड को प्राथमिकता दी जाती है।
ऐसा इनवेरिएंट यह हो सकता है कि आपकी Wizard class का damage कभी ऋणात्मक न हो जाए।
damage वेरिएबल private है और जो भी फंक्शन damage को बदलता है, वह यह सुनिश्चित करेगा कि इनवेरिएंट बना रहे।
Ellen एक ऐसा गेम बना रही हैं जिसमें खिलाड़ी को एलियन से लड़ना होता है।
उन्होंने अभी-अभी ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) के बारे में सीखा है और वे उत्सुक हैं कि classes के इस्तेमाल से उनके प्रोग्राम को क्या-क्या मिल सकता है।
Ellen को खुशी हुई कि आपने मदद करने की पेशकश की, और अब उन्होंने आपको वे एलियन प्रोग्राम करने का काम सौंपा है जिनसे खिलाड़ी को लड़ना है।
Alien क्लास बनाइएAlien क्लास को एक कंस्ट्रक्टर के साथ बनाइए जो दो int पैरामीटर x और y लेता है और उन्हें x_coordinate और y_coordinate मेंबर वेरिएबलो में रखता है।
हर एलियन की शुरुआती हेल्थ भी 3 होगी, इसलिए health मेंबर वेरिएबल को भी शुरू में ही वैल्यू देनी होगी।
health एक private मेंबर वेरिएबल होना चाहिए।
प्रोग्राम के बाकी हिस्से हेल्थ की जानकारी पढ़ सकें, इसके लिए Ellen एक public get_health() मेथड चाहती हैं जो एक int लौटाता है।
Alien alien{2, 0};
alien.x_coordinate;
// => 2
alien.y_coordinate;
// => 0
alien.get_health();
// => 3
अब हर एलियन को अपनी जगह और हेल्थ का हिसाब खुद रख पाना चाहिए।
hit फंक्शनEllen चाहती हैं कि class क्लास में एक hit मेथड हो, जो कॉल करने पर एलियन ऑब्जेक्ट की हेल्थ 1 कम कर दे।
इससे वे एलियन की हेल्थ खुद बदलने के बजाय सीधे some_alien_instance.hit() कॉल कर सकेंगी।
ध्यान रखिए कि हेल्थ 0 से नीचे न गिरे।
फंक्शन को true लौटाना चाहिए।
Ellen आगे चलकर शील्ड जोड़ना चाहती हैं, और तब शील्ड चालू होने पर यही फंक्शन false लौटाएगा।
Alien alien {0, 0};
alien.get_health();
// => 3 (Initial health value)
alien.hit(); // Decrements health by 1 point.
alien.get_health();
// => 2
is_alive फंक्शनआप समझ ही गए होंगे कि हेल्थ लगातार घटती रहे, तो किसी न किसी समय वह 0 तक पहुँच जाएगी।
तो बेहतर होगा कि एक is_alive मेथड जोड़ दिया जाए, जिसे Ellen जल्दी से कॉल करके यह देख सकें कि एलियन... अरे हाँ... ज़िंदा है या नहीं। 😉
some_alien_instance.is_alive() को एक बूलियन लौटाना चाहिए।
alien.get_health();
// => 1
alien.is_alive();
// => true
alien.hit();
alien.get_health();
// => 0
alien.is_alive();
// => false
teleport फंक्शनEllen के गेम में एलियन टेलीपोर्ट कर सकते हैं!
आपको एक teleport मेथड लिखना होगा जो x_new और y_new वैल्यू लेता है और उसी हिसाब से एलियन के निर्देशांक बदल देता है।
फिलहाल इस फंक्शन को true लौटाना चाहिए।
Ellen आगे के लेवल में टेलीपोर्ट रोकने वाले बम जोड़ना चाहती हैं, और तब टेलीपोर्ट की असफल कोशिश पर यही फंक्शन false लौटाएगा।
alien.teleport(5, -4);
alien.x_coordinate;
// => 5
alien.y_coordinate;
// => -4
collision_detection फंक्शनअगर एलियन पर किसी चीज़ की चोट लग सकती है, तो उन्हें यह पता लगाने की भी ज़रूरत है कि ऐसी टक्कर कब हो सकती है।
Ellen को जानना है कि दो एलियन एक ही निर्देशांक पर हैं या नहीं।
collision_detection() फंक्शन आर्गुमेंट के तौर पर दूसरा एलियन ऑब्जेक्ट लेता है और एक bool लौटाता है।
Alien lrrr {3, 6};
Alien ndnd {-2, 12};
lrrr.collision_detection(ndnd);
// => false
ndnd.teleport(3, 6);
ndnd.collision_detection(lrrr);
// => true
Exercism पर साइन अप कीजिए और C++ को 19 कॉन्सेप्ट100 अभ्यास तथा असली इंसानों से मिलने वाली मेंटरिंग के साथ सीखिए और उसमें महारत हासिल कीजिए, वह भी बिल्कुल मुफ्त।