परिचय
रेफरेंस
कॉपी और रेफरेंस
अभी जो हम जानते हैं उसके हिसाब से किसी फंक्शन की मदद से कोई वेरिएबल अपडेट करना थोड़ा झंझट भरा काम है।
हर फंक्शन आर्गुमेंट की एक कॉपी बनती है और मूल वैल्यू नहीं बदलती।
आपके टाइप का आकार कितना बड़ा है, उसके हिसाब से यह आपके कोड की परफॉर्मेंस पर गंभीर असर डाल सकता है।
int adjust_salary(int base, int kids) {
return base + kids * 500;
}
int now_a_mother_of_twins{2500};
adjust_salary(now_a_mother_of_twins, 2);
// now_a_mother_of_twins is still 2500
now_a_mother_of_twins = adjust_salary(now_a_mother_of_twins, 2);
// now_a_mother_of_twins is now 3500
References को उपनाम की तरह देखा जा सकता है। इनमें किया गया बदलाव मूल वेरिएबल पर असर डालता है।
References को टाइप घोषित करते समय एम्परसैंड (&) लगाया जाता है।
int balance{1000};
int& budget{balance};
int pro_computer_wheels{699};
budget -= pro_computer_wheels;
// budget is now 301;
// balance is also 301;
किसी reference का जुड़ाव बदलना संभव नहीं है, यानी उसे किसी दूसरे वेरिएबल से नहीं जोड़ा जा सकता।
बिना इनिशियलाइज़ किया हुआ reference नहीं रखा जा सकता।
References को किसी पहले से मौजूद वेरिएबल से इनिशियलाइज़ करना ज़रूरी है।
int main_acc{1'000'000};
int side_acc{-20};
int& savings{main_acc};
// => main_acc and savings are 1'000'000
// try to reseat savings to use main account
savings = side_acc;
// savings and main_acc are now -20
// as this uses the **value** of side_acc
savings += 20;
// savings and main_acc are now 0, side_acc is still -20
int& future_budget;
// => compiler error, reference must be bound!
void
references की शक्ति का उपयोग करके आपको किसी फंक्शन से कोई वैल्यू लौटाने की ज़रूरत ही न पड़े।
ऐसी स्थिति में रिटर्न टाइप के तौर पर void का उपयोग किया जाता है।
void increase_power(int& level) {
level += 500;
}
int goku{8700};
increase_power(goku);
// goku's power level?
// It's over 9000!
निर्देश
आपके पास के एक स्थानीय स्कूल में छात्रों का संघ बहुत सक्रिय है।
इस छात्र संघ का संचालन एक अध्यक्ष करता है, और हर 2 साल में एक बार नया अध्यक्ष चुनने के लिए चुनाव कराए जाते हैं।
इस साल के चुनाव में यह तय हुआ कि वोट गिनने के लिए एक नया डिजिटल सिस्टम चाहिए। स्कूल को यह नया सिस्टम बनाने में आपकी मदद चाहिए।
1. एक ElectionResult से वोटों की संख्या प्राप्त कीजिए
नए सिस्टम को किसी काउंटर से वोटों की संख्या निकालने का तरीका चाहिए।
चुनाव परिणाम वाला स्ट्रक्चर आपके लिए पहले ही बना दिया गया है और इसे ऐसे परिभाषित किया गया है:
struct ElectionResult {
// Name of the candidate
std::string name{};
// Number of votes the candidate has
int votes{};
};
चूँकि struct के सारे मेंबर public हैं, इसलिए ElectionResult ऑब्जेक्ट को इनिशियलाइज़ करने के लिए आपको constructor लिखने की ज़रूरत नहीं है।
इसके बजाय आप initializer list इस्तेमाल कर सकते हैं:
ElectionResult hamilton{"Alex", 1804};
// => the hamilton object was initialized with the name "Alex" and 1804 votes.
एक फंक्शन vote_count बनाइए जो आर्गुमेंट के तौर पर एक ElectionResult का रेफरेंस लेता है और ElectionResult में मौजूद वोटों की संख्या लौटाता है।
vote_count(hamilton);
// => 1804
2. एक ElectionResult के वोट बढ़ाइए
अब वोटों को प्रोसेस करने का समय आ गया है!
अब आपको ElectionResult के वोट बढ़ाने का तरीका चाहिए।
एक void फंक्शन increment_vote_count बनाइए, जो एक ElectionResult का रेफरेंस और वोटों की एक संख्या आर्गुमेंट के तौर पर लेगा और ElectionResult को उतने वोटों से बढ़ा देगा।
ElectionResult burr{"Aaron " 1801};
increment_vote_count(burr, 3);
vote_count(burr);
// => 1804
3. वोटों की गिनती और अध्यक्षता
स्कूल ने अपने वोट जमा कर दिए हैं, और अब परिणाम देखकर यह पता लगाने का समय है कि विजेता कौन है।
एक फंक्शन determine_result बनाइए जो अंतिम गिनती का रेफरेंस लेता है और नए अध्यक्ष के ElectionResult का रेफरेंस लौटाता है।
इसे विजेता के नाम के आगे "President" जोड़कर उसका नाम भी बदलना चाहिए।
अंतिम गिनती std::vector<ElectionResult> के reference के रूप में दी जाती है। इस वेक्टर में सभी भाग लेने वाले उम्मीदवारों के ElectionResults होते हैं।
ElectionResult sanchez{"Pedro", 471};
ElectionResult wheatley{"Summer", 340};
std::vector<ElectionResult> final_count{sanchez, wheatley};
ElectionResult& winner = determine_result(final_count);
winner.name;
// => "President Pedro"
चीज़ों को आसान रखने के लिए आप यह मान सकते हैं:
-
vector में कम से कम एक एलिमेंट होगा।
- पहले स्थान के लिए कोई बराबरी नहीं होगी।
सीखने का अभ्यास
