C++ चर और प्रकार: Int, Char, Float, Double, स्ट्रिंग और बूल

C++ परिवर्तनीय डेटा प्रकार

C++ आदिम प्रकारों के एक पूरे सेट को परिभाषित करता है

RSI शून्य प्रकार के साथ कोई संबद्ध मान नहीं होता है और इसका उपयोग केवल कुछ ही परिस्थितियों में किया जा सकता है। यह आमतौर पर उन फ़ंक्शन के रिटर्न प्रकार के रूप में होता है जो मान नहीं लौटाते हैं।

RSI अंकगणितीय प्रकार इसमें वर्ण, पूर्णांक, बूलियन मान और फ़्लोटिंग-पॉइंट संख्याएँ शामिल हैं। अंकगणितीय प्रकार को यदि 2 श्रेणियों में विभाजित किया जाए

1. फ़्लोटिंग-पॉइंट प्रकारफ्लोट (या फ़्लोटिंग प्रकार) दशमलव संख्याओं का प्रतिनिधित्व करते हैं। IEEE मानक महत्वपूर्ण अंकों की न्यूनतम संख्या निर्दिष्ट करता है। अधिकांश संकलक आमतौर पर निर्दिष्ट न्यूनतम से अधिक परिशुद्धता प्रदान करते हैं। आम तौर पर, फ़्लोट को 32 बिट्स, डबल्स को 64 बिट्स और लॉन्ग डबल्स को 96 या 128 बिट्स में दर्शाया जाता है।
2. अभिन्न प्रकार (जिसमें वर्ण, पूर्णांक और बूलियन प्रकार शामिल हैं)। बूलियन प्रकार के केवल दो प्रकार के मान हैं: सत्य या असत्य। कई हैं टैंक प्रकार, जिनमें से अधिकांश अंतर्राष्ट्रीयकरण का समर्थन करने के लिए मौजूद हैं। सबसे बुनियादी वर्ण प्रकार char है। एक char एक मशीन बाइट के समान आकार का होता है, जिसका अर्थ है एक बाइट।

RSI अभिन्न प्रकार हस्ताक्षरित या अहस्ताक्षरित हो सकता है।

हस्ताक्षरित प्रकार: वे नकारात्मक या सकारात्मक संख्याओं (शून्य सहित) का प्रतिनिधित्व करते हैं। एक हस्ताक्षरित प्रकार में, सीमा को +ve और -ve मानों के बीच समान रूप से विभाजित किया जाना चाहिए। इस प्रकार, एक 8-बिट हस्ताक्षरित वर्ण -127 से 127 तक के मान रखेगा।

अहस्ताक्षरित प्रकार: एक अहस्ताक्षरित प्रकार में, सभी मान >= 0 होते हैं। एक 8-बिट अहस्ताक्षरित वर्ण में 0 से 255 तक (दोनों सम्मिलित) हो सकते हैं।

चर नाम या पहचानकर्ता

पहचानकर्ता कुछ अक्षरों, अंकों और अंडरस्कोर वर्ण या उनके कुछ संयोजन से बना हो सकता है। नाम की लंबाई पर कोई सीमा नहीं लगाई गई है।

पहचानकर्ताओं को अवश्य

• किसी अक्षर या अंडरस्कोर ('_') से शुरू करें।
• और केस-सेंसिटिव हैं; बड़े और छोटे अक्षर अलग-अलग हैं:

// चार अलग-अलग int चर परिभाषित करता है

int guru99, gurU99, GuRu99, GURU99;

RSI C++ भाषा ने अपने प्रयोग के लिए कुछ नाम सुरक्षित रखे हैं।

चरों के नामकरण के लिए कई स्वीकृत परंपराएँ हैं विभिन्न प्रोग्रामिंग भाषाएँइन परंपराओं का पालन करने से कार्यक्रम की पठनीयता में सुधार हो सकता है।

• किसी पहचानकर्ता को अपने अर्थ का कम से कम कुछ संकेत तो देना ही चाहिए।
• चर नाम आमतौर पर लोअरकेस होते हैं - गुरु99, न कि गुरु99 या गुरु99।
• हम जो कक्षाएं परिभाषित करते हैं वे आमतौर पर बड़े अक्षर से शुरू होती हैं।
• ऐसे पहचानकर्ता जिनमें कई शब्द हों, उन्हें हर शब्द को अलग-अलग तरीके से पहचानना चाहिए। उदाहरण के लिए, guru99_website न कि guru99website।

C++ चर घोषणा और परिभाषा

किसी चर की घोषणा उस दायरे में प्रोग्राम को एक नाम बताती है जिसमें उसे परिभाषित किया गया है। उदाहरण:

int a=5;
int b;
char c='A'; 

int a,b;
a=b=1000;

List initialization
int a(5);
int b{5};

कॉन्स्ट क्वालीफायर इन C++

मान लीजिए कि एक वैरिएबल buffsize है जो यूजर से लिए जाने वाले इनपुट की संख्या बताता है। यहाँ, हम पूरे प्रोग्राम में buffsize का मान नहीं बदलना चाहते हैं। हम एक ऐसा वैरिएबल परिभाषित करना चाहते हैं जिसका मान हम जानते हैं कि नहीं बदलना चाहिए।

ऐसी स्थिति में, const कीवर्ड का उपयोग करें

const int bufSize = 512;    // input buffer size

यह bufSize को स्थिरांक के रूप में परिभाषित करता है। bufSize को असाइन करने या बदलने का कोई भी प्रयास त्रुटि देता है।

यहाँ, हम const ऑब्जेक्ट बनाने के बाद उसका मान नहीं बदल सकते, इसे अनिवार्य रूप से घोषित और आरंभीकृत किया जाना चाहिए। अन्यथा कंपाइलर एक त्रुटि फेंकता है।

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int i = 42;
const int ci = i;    	   // ok: the value in i is copied into ci 

चरों का दायरा C++

स्कोप किसी प्रोग्राम का वह हिस्सा होता है जहाँ किसी वेरिएबल का कोई मतलब होता है। ज़्यादातर एक ही नाम का इस्तेमाल अलग-अलग स्कोप में अलग-अलग इकाइयों को संदर्भित करने के लिए किया जा सकता है। वेरिएबल उस बिंदु से दिखाई देते हैं जहाँ उन्हें घोषित किया जाता है, उस स्कोप के अंत तक जहाँ उनकी घोषणा दिखाई देती है।

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}	 

यह प्रोग्राम 3 नाम परिभाषित करता है, अर्थात, main, sum, और val. यह नेमस्पेस नाम std के साथ-साथ उस नेमस्पेस से दो अन्य नामों - cout और endl का उपयोग करता है.

• फ़ंक्शन नाम “main” को कर्ली ब्रेसेज़ के बाहर परिभाषित किया गया है। फ़ंक्शन नाम main—फ़ंक्शन के बाहर परिभाषित अधिकांश अन्य नामों की तरह—का एक वैश्विक दायरा है। जिसका अर्थ है कि एक बार घोषित होने के बाद, जो नाम सबसे ऊपर हैं वैश्विक कार्यक्षेत्र पूरे कार्यक्रम के दौरान उपलब्ध हैं।
• वेरिएबल योग को ब्लॉक के दायरे में परिभाषित किया गया है जो मुख्य फ़ंक्शन का मुख्य भाग है। इसे इसके घोषणा बिंदु से और मुख्य फ़ंक्शन के बाकी हिस्से में एक्सेस किया जा सकता है। हालाँकि, इसके बाहर नहीं। इसका मतलब है कि वेरिएबल योग में ब्लॉक स्कोप.
• वैरिएबल val को “for स्टेटमेंट” के दायरे में परिभाषित किया गया है। इसे उस स्टेटमेंट में आसानी से इस्तेमाल किया जा सकता है लेकिन मेन फंक्शन में कहीं और नहीं। इसमें स्थानीय दायरा.

नेस्टेड स्कोप

स्कोप में अन्य स्कोप शामिल हो सकते हैं। निहित (या नेस्टेड) ​​स्कोप को आंतरिक स्कोप कहा जाता है। युक्त स्कोप बाहरी स्कोप है।

#include <iostream>	
using namespace std;	
// Program for illustration purposes only: It is bad style for a function	
// to use a global variable and also define a local variable with the same name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}	 

आउटपुट #1 पुनः उपयोग की स्थानीय परिभाषा से पहले प्रकट होता है। इस प्रकार, यह आउटपुट

कथन वह है जो वैश्विक दायरे में परिभाषित नाम का पुन: उपयोग करता है। यह कथन आउटपुट देता है

42 0

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

0 0

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

42 0

चर प्रकार रूपांतरण

एक प्रकार के चर को दूसरे प्रकार में बदला जा सकता है। इसे "प्रकार रूपांतरण" के रूप में जाना जाता है। आइए विभिन्न चर को दूसरे प्रकार में बदलने के नियमों को देखें। C++ चर प्रकार:

यदि मान 0 है तो bool चर को non-bool निर्दिष्ट करने पर false प्राप्त होता है, अन्यथा true प्राप्त होता है।

bool b = 42;            // b is true

किसी बूल को अन्य अंकगणितीय प्रकारों में से किसी एक को सौंपने पर यदि बूल सत्य है तो 1 प्राप्त होता है, तथा यदि बूल असत्य है तो 0 प्राप्त होता है।

bool b = true;
int i = b;              // i has value 1

int प्रकार के चर को फ़्लोटिंग-पॉइंट मान असाइन करने से वह मान प्राप्त होता है जिसे काट दिया जाता है। संग्रहीत मान दशमलव बिंदु से पहले का भाग होता है।

int i = 3.14;               // i has value 3

फ्लोट प्रकार के चर को int मान निर्दिष्ट करने से भिन्नात्मक भाग शून्य हो जाता है। यदि पूर्णांक में फ्लोटिंग चर की क्षमता से अधिक बिट्स हों तो आमतौर पर सटीकता खो जाती है।

Int i=3;
double pi = i;          // pi has value 3.0

यदि हम किसी अहस्ताक्षरित प्रकार के चर को सीमा से बाहर का मान निर्दिष्ट करने का प्रयास करते हैं, तो परिणाम मान का शेष %(मॉड्यूलो) होता है

उदाहरण के लिए, 8-बिट अनसाइनड चार प्रकार 0 से लेकर 255 तक के मान रख सकता है। इस सीमा के बाहर मान निर्दिष्ट करने पर कंपाइलर उस मान के शेष भाग को 256 के मॉड्यूलो के अनुसार निर्दिष्ट करेगा। इसलिए, ऊपर दिए गए तर्क के अनुसार, 1-बिट अनसाइनड चार को -8 असाइन करने पर उस ऑब्जेक्ट को 255 मान मिलता है।

unsigned char c = -1;   // assuming 8-bit chars, c has value 255

यदि हम हस्ताक्षरित प्रकार के ऑब्जेक्ट को आउट-ऑफ-रेंज मान असाइन करने का प्रयास करते हैं, तो परिणाम अप्रत्याशित होता है। यह अपरिभाषित है। प्रोग्राम बाहर से काम करता हुआ दिखाई दे सकता है, या यह क्रैश हो सकता है, या यह कचरा मान उत्पन्न कर सकता है।

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

जब हम एक प्रकार का मान प्रयोग करते हैं, जहां अन्य प्रकार का मान अपेक्षित होता है, तो कंपाइलर इसी प्रकार के रूपांतरण लागू करता है।

int i = 42;
if (i) // condition will evaluate as true
i = 0; 

यदि यह मान = 0 है, तो शर्त गलत है; अन्य सभी (गैर-शून्य) मान सत्य देते हैं। इसी अवधारणा के अनुसार, जब हम अंकगणितीय अभिव्यक्ति में बूल का उपयोग करते हैं, तो इसका मान हमेशा 0 या 1 में परिवर्तित हो जाता है। परिणामस्वरूप, अंकगणितीय अभिव्यक्ति में बूल का उपयोग करना आमतौर पर लगभग निश्चित रूप से गलत होता है।

सावधानी: हस्ताक्षरित और अहस्ताक्षरित प्रकारों को मिश्रित न करें

हस्ताक्षरित और अहस्ताक्षरित को मिलाने वाले व्यंजक तब आश्चर्यजनक और गलत परिणाम दे सकते हैं जब हस्ताक्षरित मान ऋणात्मक हो। जैसा कि ऊपर चर्चा की गई है, हस्ताक्षरित मान स्वचालित रूप से अहस्ताक्षरित में परिवर्तित हो जाते हैं।

उदाहरण के लिए, एक अंकगणितीय अभिव्यक्ति में जैसे

x* y

यदि x -1 है और y 1 है, तथा यदि x और y दोनों int हैं, तो मान, जैसा कि अपेक्षित है, -1 होगा।

यदि x int है और y अहस्ताक्षरित है, तो इस अभिव्यक्ति का मान इस बात पर निर्भर करता है कि कम्पाइलिंग मशीन पर पूर्णांक में कितने बिट्स हैं। हमारी मशीन पर, यह अभिव्यक्ति 4294967295 देती है।

वैरिएबल पंजीकृत करें

रजिस्टर वैरिएबल को मेमोरी वैरिएबल की तुलना में एक्सेस करना तेज़ होता है। इसलिए, वे वैरिएबल जो अक्सर किसी प्रोग्राम में इस्तेमाल किए जाते हैं, उन्हें रजिस्टर वैरिएबल कहा जाता है। C++ प्रोग्राम को रजिस्टरों में डाला जा सकता है रजिस्टर कीवर्ड। रजिस्टर कीवर्ड कंपाइलर को दिए गए वैरिएबल को रजिस्टर में स्टोर करने के लिए कहता है। यह कंपाइलर की पसंद है कि उसे रजिस्टर में रखना है या नहीं। आम तौर पर, कंपाइलर खुद ही कई तरह के ऑप्टिमाइजेशन करते हैं, जिसमें कुछ वैरिएबल को रजिस्टर में रखना शामिल है। रजिस्टर में वैरिएबल की संख्या पर कोई सीमा नहीं है। C++ प्रोग्राम। लेकिन कंपाइलर वैरिएबल को रजिस्टर में स्टोर नहीं कर सकता। ऐसा इसलिए है क्योंकि रजिस्टर मेमोरी बहुत सीमित होती है और इसका इस्तेमाल आमतौर पर OS द्वारा किया जाता है।

परिभाषित करने के लिए:

register int i;

टिप्पणियाँ

टिप्पणियाँ कोड के वे हिस्से हैं जिन्हें संकलक द्वारा अनदेखा किया जाता है। यह प्रोग्रामर को स्रोत कोड/प्रोग्राम के प्रासंगिक क्षेत्रों में नोट्स बनाने की अनुमति देता है। टिप्पणियाँ या तो ब्लॉक फ़ॉर्म में या एकल पंक्तियों में आती हैं। प्रोग्राम टिप्पणियाँ व्याख्यात्मक कथन हैं। इसे इसमें शामिल किया जा सकता है C++ कोड जो इसके स्रोत कोड को पढ़ने वाले किसी भी व्यक्ति की मदद करता है। सभी प्रोग्रामिंग भाषाएँ किसी न किसी रूप में टिप्पणियों की अनुमति देती हैं। C++ एकल-पंक्ति और बहु-पंक्ति दोनों टिप्पणियों का समर्थन करता है।

• एकल-पंक्ति टिप्पणियाँ वे हैं जो // से शुरू होते हैं और पंक्ति के अंत तक चलते हैं। यदि किसी टिप्पणी पंक्ति में अंतिम वर्ण \ है तो टिप्पणी अगली पंक्ति में जारी रहेगी।
• बहु-पंक्ति टिप्पणियाँ वे हैं जो /* से शुरू होते हैं और */ पर ख़त्म होते हैं।

/* This is a comment */
/* C++ comments can  also 
* span multiple lines 
*/

भागने के क्रम

कुछ वर्ण, जैसे बैकस्पेस और कंट्रोल वर्ण, की कोई दृश्यमान छवि नहीं होती। ऐसे वर्णों को गैर-मुद्रण योग्य वर्ण कहा जाता है। अन्य वर्ण (एकल और दोहरे उद्धरण चिह्न, प्रश्न चिह्न और बैकस्लैश) का कई प्रोग्रामिंग भाषाओं में विशेष अर्थ होता है।

हमारे प्रोग्राम इनमें से किसी भी अक्षर का सीधे इस्तेमाल नहीं कर सकते। इसके बजाय, हम ऐसे अक्षर को दर्शाने के लिए एस्केप अनुक्रम का इस्तेमाल कर सकते हैं। एस्केप अनुक्रम बैकस्लैश से शुरू होता है।

RSI C++ प्रोग्रामिंग भाषा कई एस्केप अनुक्रम परिभाषित करता है:

यह क्या करता है?	चरित्र
नई पंक्ति	\n
लंबवत टैब	\v
बैकस्लैश	\\
कैरिज रिटर्न	\r
क्षैतिज टैब	\t
बैकस्पेस	\b
प्रश्न चिन्ह	\?
फ़ीड बनाएं	\f
चेतावनी (घंटी)	\a
Double उद्धरण	\ "
एकल बोली	\'

हम एस्केप अनुक्रम का प्रयोग इस प्रकार करते हैं जैसे कि वह एक एकल वर्ण हो:

cout << '\n';        // prints a newline
cout << "\tguru99!\n";   // prints a tab followed by "guru99!" and a newline 

हम सामान्यीकृत एस्केप अनुक्रम \x के बाद एक या अधिक हेक्साडेसिमल अंक भी लिख सकते हैं। या हम \ के बाद एक, या दो, या तीन अष्टाधारी अंक का उपयोग करते हैं। सामान्यीकृत एस्केप अनुक्रम वर्ण के संख्यात्मक मान को दर्शाता है। कुछ उदाहरण (लैटिन-1 वर्ण सेट मानते हुए):

\7 (bell)    \12 (newline)      \40 (blank)
\0 (null)    \115 ('M')         \x4d ('M') 

हम पूर्व-निर्धारित एस्केप अनुक्रम का उपयोग कर सकते हैं, जैसे कि हम किसी अन्य वर्ण का उपयोग कर रहे हैं।

cout << "Hi \x4dO\115!\n";  // prints Hi MOM! followed by a newline
cout << '\115' << '\n';     // prints M followed by a newline 

सारांश

• A C++ यह वेरिएबल हमें नामित भंडारण क्षमता प्रदान करता है।
• C++ चर प्रकार: int, double, टैंक, फ्लोट, स्ट्रिंग, बूल, आदि.
• निहित (या नेस्टेड) ​​स्कोप को आंतरिक स्कोप कहा जाता है, तथा निहित स्कोप को बाहरी स्कोप कहा जाता है।
• एक प्रकार के चर को दूसरे में बदला जा सकता है। इसे "प्रकार रूपांतरण" के रूप में जाना जाता है।
• मेमोरी वैरिएबल्स की तुलना में रजिस्टर वैरिएबल्स तक पहुंच अधिक तेज होती है।
• टिप्पणियाँ कोड के वे भाग हैं जिन्हें कंपाइलर द्वारा अनदेखा कर दिया जाता है।
• कुछ वर्णों, जैसे बैकस्पेस और कंट्रोल वर्णों की कोई दृश्य छवि नहीं होती।