फ्रीलांसर दरें

C++ में संख्याओं के जो डेटा टाइप पहले से मौजूद हैं, उन्हें दो हिस्सों में बाँटा जा सकता है: पूर्णांक और दशमलव संख्याएँ। पूर्णांक ऐसी संख्याएँ होती हैं जिनमें दशमलव बिंदु नहीं होता, जैसे 0, 691 या -2. दशमलव संख्याओं में दशमलव बिंदु होता है, जैसे 6.02214076, 0.1 या -1.616.

पूर्णांक

नीचे दिया गया उदाहरण चार अलग-अलग वेरिएबल घोषित करने और उन्हें शुरुआती वैल्यू देने का तरीका दिखाता है

int m_morales{9241};              // base 10: 0-9
int a_apaec{0x24CD};              // base 16: 0-9 and A-F
int m_gargan{0b10010000011001};   // base  2: 0-1
int b_reilly{022031};             // base  8: 0-7
                                  // Leading with a 0 not the letter o.

जब आप किसी int वेरिएबल को कोई वैल्यू असाइन करते हैं, तो आप सीधे एक लिटरल से ऐसा कर सकते हैं. लिटरल कोड में सीधे लिखी गई संख्या होती है, जैसे 9241. संख्या लिखने के अलग-अलग आधारों के लिए अलग-अलग पूर्णांक लिटरल होते हैं. आधार 10 वाले पूर्णांक लिटरल सबसे आम हैं और इनमें 0 से 9 तक के अंक इस्तेमाल होते हैं. 0x जैसा कोई खास प्रिफिक्स लगाकर दूसरे आधार भी इस्तेमाल किए जा सकते हैं. ऊपर का उदाहरण संख्या 9241 को उसके चारों रूपों और प्रिफिक्सों के साथ दिखाता है. सभी वेरिएबल को एक ही वैल्यू दी गई है.

अलग-अलग निरूपण प्रणालियों के बारे में और जानने के लिए एक छोटा ट्यूटोरियल देखिए.

पढ़ने में आसानी के लिए आप अंकों को अलग करने हेतु अपॉस्ट्रॉफी लगा सकते हैं. 9'241 और 0b0100'100'0001'1001 या 92'4'1 एक ही हैं.

दशमलव संख्याएँ

दशमलव संख्याओं के लिटरल दो तरह के होते हैं. 0.0024 लिखने के अलावा आप इसका वैज्ञानिक संकेतन 2.4e-3 भी इस्तेमाल कर सकते हैं. सबसे आम दशमलव संख्या टाइप double है.

अंकगणित

एक्सप्रेशन बनाने के लिए C++ में +, -, *, /, ( और ) तथा % इस्तेमाल किए जा सकते हैं. दो पूर्णांकों के बीच किए गए ऑपरेशन का परिणाम भी एक पूर्णांक ही होता है. 5 / 2 का परिणाम 2 मिलेगा. जब इनमें से कोई एक टाइप दशमलव संख्या का हो, तो परिणाम भी दशमलव संख्या ही होगा. 5.0 / 2 और 5 / 2.0 का परिणाम 2.5 मिलेगा. % शेष ऑपरेटर है और पूर्णांक विभाजन का शेष देता है: 5%3 का परिणाम 2 है.

असाइनमेंट ऑपरेटर

असाइनमेंट ऑपरेटर एक लिटरल की मदद से किसी वेरिएबल को वैल्यू देता है. यह हमेशा दाएँ से बाएँ होता है, कभी उलटा नहीं.

int length = 5;
int width = 2;
length = width;

यहाँ पूर्णांक वैल्यू 5 को length वेरिएबल को असाइन किया गया है. फिर पूर्णांक वैल्यू 2 को width वेरिएबल को असाइन किया जाता है. अंत में width की वैल्यू length वेरिएबल में कॉपी हो जाती है और पहले वाली वैल्यू 5 खत्म हो जाती है. यह भी ध्यान रखिए कि असाइनमेंट ऑपरेशन के समय हम width की वैल्यू केवल length में असाइन कर रहे होते हैं. इसलिए अगर बाद में width की वैल्यू बदल भी जाए, तो length की वैल्यू पर उसका कोई असर नहीं पड़ेगा.

असाइनमेंट ऑपरेटर को दूसरे ऑपरेटरों (अंकगणितीय और बिटवाइज़) के साथ जोड़ा जा सकता है; इन्हें compound assignment ऑपरेटर कहते हैं: +=, -=, *=, /=, %=. ये ऑपरेटर वेरिएबल की मौजूदा वैल्यू पर कोई ऑपरेशन करके उसे बदल देते हैं.

// we start with 0 people
int people{};
// we need 0 eggs
int eggs{};
// two people joined:
people += 2;
// people is now 2
// let's add 3 eggs per person
eggs += 3 * people;
// eggs is now 6

people और eggs वेरिएबल को शुरू में 0 वैल्यू दी गई है. फिर हम people वेरिएबल की मौजूदा वैल्यू 0 में पूर्णांक वैल्यू 2 जोड़ते हैं और परिणाम को वापस people में असाइन कर देते हैं. अब people की वैल्यू 2 हो जाती है. इसके बाद हम हर व्यक्ति के लिए 3 अंडे जोड़ते हैं, यानी कुल 6 अंडे. अब इस 6 को eggs वेरिएबल की मौजूदा वैल्यू 0 में जोड़कर वापस eggs में असाइन कर दीजिए. अब eggs की वैल्यू 6 हो जाएगी. इसके बराबर एक्सप्रेशन ये होंगे: people = people + 2 और eggs = eggs + (3 * people).