CHAPTER 2.1 — Basic addressing और variable का definition

CHAPTER 2

2.1 — Basic addressing और variable का definition

Memory को address करना

ये lesson “1.3 -- Variables, initialization, और assignment पर एक नज़र” section के आधार पर बनाया गया है ।
Variables के पिछले lesson में हमने जाना की variables memory के टुकड़े का एक नाम है जिसमे information store किया जा सकता है । संक्षिप्त रूप में कहा जाये, तो computers में एक random access memory (RAM) होता है जिसका इस्तेमाल programs करते है । जब कोई variable define किया जाता है, memory का एक टुकड़ा उस variable के लिए सुरक्षित कर लिया जाता है ।

Memory की सबसे छोटी इकाई binary digit या bit है, जो केवल 0 या 1 value hold कर सकता है । आप bit को इस प्रकार समझ सकते हैं, एक साधारण सा light switch – जो केवल या तो on (1) रह सकता है, या फिर off (0) । इसके अलावा switch किसी दूसरी स्थिति में नहीं हो सकता । यदि आप memory के किसी हिस्से को देखोगे, तो उसमे आपको केवल …011010100101010… या फिर 0 और 1 का ऐसा ही कोई pattern दिखेगा । Memory क्रमवार रूप से व्यवस्थित इकाइयों में access किया जाता है, जिन्हें addresses कहा जाता है । जैसे किसी address का उपयोग दिए गए घर को खोजने में किया जा सकता है, उसी तरह एक memory address हमे किसी दिए गए memory location में उपस्थित contents को access करने की अनुमति देता है । आश्चर्यजनक रूप से, आजकल के computers में किसी bit का अपना कोई address नहीं होता । Memory की सबसे छोटी इकाई जिसे address किया जा सके, वो 8 bits का एक समूह होता है जिसे byte कहते है ।

नीचे दी गयी तस्वीर में कुछ sequential (क्रमवार रूप में व्यवस्थित) memory addresses दिखाए गए हैं,:

क्यूंकि computer में data केवल bits का ही एक sequence है, हमे data type का प्रयोग कर computer को ये बताना पड़ता है की memory के contents को सार्थक (meaningful) रूप में कैसे interpret (प्रस्तुत) करना है । आप data type का एक उदाहरण पहले ही देख चुके हो: Integer । जब हम किसी variable को integer के रूप में define करते हैं, हम compiler को ये बता रहे होते हैं की “ये variable memory के जिस भाग को address कर रहा है, वो एक पूर्ण संख्या (whole number) ही store कर सकता है” ।
जब आप data type को कोई value assign करते हो, उस value को दिए गए data type के लिए bit के सुव्यवस्थित pattern में encode करने की सारी जिम्मेवारी compiler और CPU के ऊपर होती है। जब आप उस value को वापस पाना चाहते हो, तो इसे memory में स्थित bits के सुव्यवस्थित pattern के आधार पर “फिर से बना लिया जाता है” ।

Integer के अलावा C++ में कई और data types हैं, जिनमे से अधिकांश के बारे में हम कुछ ही देर में जानेंगे । संक्षिप्त रूप में, हम किसी variable के “data type” को उसके “type” से सूचित करते हैं ।
Fundamental data types
C++ में कुछ data types built-in हैं, अर्थात ये data types C++ के साथ ही आते हैं । इन्हें fundamental data types के नाम से जाना जाता है (C++ specification के अनुसार) । साधारण तौर पर इन्हें basic types, primitive types या built-in types भी कहा जाता है ।

यहाँ fundamental data types का एक list दिया गया है, जिनमे से कुछ को आप पहले ही देख चुके हो:

Category	Types	Meaning	Example	Notes
boolean	Bool	true या false	True
character	char, wchar_t, char16_t, char32_t	single ASCII character	‘c’	char16_t, char32_t केवल C++11 में हैं
floating point	float, double, long double	Decimal (दशमलव .) के साथ कोई number	3.14159
integer	short, int, long, long long	एक पूर्ण संख्या (whole number)	64	long long केवल C99/C++11 में हैं
void	कोई type नहीं	void	n/a

ये chapter इन्हीं data types के विस्तृत अध्ययन के लिए बनाया गया है ।

एक variable define करना

“Basic C++” section से आपको पहले ही पता है की integers कैसे define किये जाते हैं:

1	int nVarName; // यहाँ int data type और nVarName variable का नाम है

दुसरे data type के variables define करने के लिए हम कुछ इस तरह के syntax का प्रयोग करेंगे:

1	type varName;  // यहाँ type एक data type है (जैसे की int) और varName variable का नाम है

इस उदाहरण में, हम 5 अलग-अलग data types के 5 अलग-अलग variables define कर रहे हैं ।

1 2 3 4 5

bool bValue; char chValue; int nValue; float fValue; double dValue;

Variable initialization

जब variable को define किया जाता है, तो इसे उसी वक़्त कोई value assign करना संभव है । इसे initialization कहा जाता है ।

जब हम किसी defined variable को assignment operator ( “=” sign) की सहायता से कोई value assign करते हैं तो इसे explicit initialization कहा जाता है:

1	int nValue = 5; // explicit initialization

जब कोई variable define किया जाता है, आप इसे implicit initialization की सहायता से भी value assign कर सकते हैं:

1	int nValue(5); // implicit initialization

Implicit initialization काफी हद तक किसी function call की तरह दिखता है, फिर भी compiler को पता होता है की कौन से नाम variables हैं और कौन functions ताकि वे अच्छी तरह से काम करें ।
Implicit initialization कुछ data types के लिए explicit initialization से बेहतर काम कर सकता है, और साथ ही इसके कई फायदे भी हैं जिनके बारे में हम तब जानेंगे जब classes के बारे में चर्चा की जाएगी । इसके उपयोग से हमे initialization और assignment के बीच अंतर का भी पता लग जाता है । कुल मिलाकर, हमारी सलाह है की आप ज्यादा से ज्यादा implicit initialization का ही प्रयोग करें ।

Rule: जहाँ तक सम्भव हो, explicit initialization की जगह पर implicit initialization का ही प्रयोग करें

C++11 में Uniform initialization
Explicit और implicit forms variables के केवल कुछ ही प्रकार में काम करते हैं (उदाहरण के लिए, आप values के एक list को initialize करने के लिए इनका प्रयोग नहीं कर सकते) ।
Initialization का एक ऐसा तरीका जो सभी data types के साथ काम कर सके, प्रदान करने के लिए C++11 ने initialization के नए तरीके को शामिल किया जिसे uniform initialization कहा जाता है:

1	int value{5};

एक खाली brace के साथ किसी variable का initialization default Initializion कहलाता है । Default initialization किसी variable को value 0 के साथ initialize करता है (या फिर बिना किसी value के, यदि दिए गये data type के लिए ये ज्यादा उपयुक्त है) ।

1	int value{}; //  value 0 के साथ initialize किया गया

Uniform initialization, type conversion (किसी variable को इसके value के अनुसार दुसरे data type में बदलना) की अनुमति नहीं देते, इसलिए, उदाहरण के लिए, किसी integer को uniform initialization की सहायता से non-integer value के साथ initialize करना एक compiler error देगा:

1	int value{4.5}; // 4.5 integer नहीं है, इसलिए compile error

ये वाकई में एक अच्छी बात है, क्यूंकि ये गलत values के साथ variables को initialize करने से बचाता है ।

Uniform initialization को list initialization के नाम से भी जाना जाता है, लेकिन हम “uniform initialization” शब्द का प्रयोग करने की सलाह देते हैं क्यूंकि इसका प्रयोग करने के लिए initializer या variable, दोनों में से किसी को भी किसी तरह का कोई list होने की जरुरत नहीं है ।

Rule: यदि आप C++11 को support करने वाला कोई compiler इस्तेमाल कर रहे हैं, तो uniform initialization का ही प्रयोग करें

Variable assignment

जब variable के define होने के बाद इसे कोई value assign किया जाता है, तो इसे assignment कहते हैं (ध्यान दे की ये initialization से किस प्रकार अलग है) ।

1 2	int nValue; nValue = 5; // explicit assignment

C++ के पास implicit assignment के लिए पहले से कोई तरीका मौजूद नहीं है ।

Multiple variables define करना

एक ही statement में, variables के नामो को comma से अलग करते हुए, एक ही type के एक से ज्यादा variables define करना संभव है । नीचे के दोनों codes बिलकुल एक जैसा ही काम करेंगे:

1	int a, b;
1 2	int a; int b;

आप एक ही line में define किये गए variables को उसी जगह initialize भी कर सकते हो:

1 2 3

int a = 5, b = 6; int c(7), d(8); int e{9}, f{10}

एक ही statement में एक से ज्यादा variable define करते वक्त नए programmers मुख्यतः तीन गलतियाँ करते हैं ।
इनमे पहला है, define किये जा रहे हर एक variable के आगे इसका data type लिख देना । ये कोई बड़ी गलती नहीं है क्यूंकि compiler आपको इसके बारे में बता देगा ।

1 2 3

int a, int b; // गलत है(compiler error मिलेगा) int a, b; // बिलकुल ठीक है

दूसरा, एक ही statement में अलग-अलग data type के variables को define करने की कोशिश करना । ये syntactically गलत है, अलग-अलग data type के variables को अलग-अलग statements में लिखा होना चाहिए । ये भी कोई बड़ी गलती नहीं है, क्यूंकि compiler इसे भी समझ जायेगा ।

1 2 3 4 5 6 7

int a, double b; // गलत है(compiler error मिलेगा) int a; double b; // ठीक है (पर ऐसा न किया जाये तो बेहतर है) // बिलकुल ठीक है (पढने/समझने में आसान) int a; double b;

आखरी गलती programmers के लिए तकलीफदेह साबित हो सकता है । यहाँ पे, programmer गलती से दो या अधिक variables को केवल एक assignment statement की सहायता से initialize करने की कोशिश करता है:

1 2 3

int a, b = 5; // गलत है (a uninitialized रह गया!) int a= 5, b= 5; // बिलकुल ठीक है

इस code के सबसे पहले वाले statement में, variable a uninitialized रह जाएगा, पर compiler इसकी complain कर भी सकता है और नहीं भी कर सकता है । यदि ये कोई complain नहीं करता है, तो ये code program के crash होने या अजीबो-गरीब results देने का एक बढ़िया कारण है ।

ऐसी गलती करने से बचने का सबसे अच्छा तरीका, initialization के लिए implicit initialization या brace-initialization का उपयोग करना है:

1 2	int a, b(5); int c, d{5};

यह इस चीज़ को थोडा और स्पष्ट कर देता है की value 5 केवल variable b को ही assign किया जा रहा है ।
एक से ज्यादा variables को एक ही statement/line में define करके initialize करना गलतियाँ करने की संभावना को बढ़ा देता है, इसलिए हमारी सलाह है की आप एक line/statement में variables को तब ही define करें यदि आपको उन्हें initialize नहीं करना है ।
Rule: यदि variables को initialize करना है तो उन्हें एक ही line/statement में define ना करें ।

Variables कहाँ define किये जाये

पुराने C compilers में ये ज़रूरी था की function के सारे variables को function में सबसे ऊपर define किया जाये:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

int main() {     // सारे variables यहाँ ऊपर     int x;     int y;     // code     using namespace std;     cout << "Enter a number: ";     cin >> x;     cout << "Enter another number: ";     cin >> y;     cout << "The sum is: " << x + y << endl;     return 0; }

ये style अब प्रचलित नहीं है । C++ के compilers में ये ज़रूरी बिलकुल भी नहीं है की function में इस्तेमाल होने वाले सारे variables function में सबसे ऊपर ही define किये जाये । C++ में variables को उनके पहले use के ठीक पहले define करना सबसे अच्छा तरीका माना जाता है:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int main() {     using namespace std;     cout << "Enter a number: ";     int x; // हमे x की ज़रूरत अगले line में है, इसलिए हम इसे यहाँ declare कर रहे हैं । इस प्रकार x इसके पहले use के बिलकुल करीब define किया गया है ।     cin >> x; // x का पहला use     cout << "Enter another number: ";     int y; // हमे इसकी ज़रूरत अब तक नहीं थी, इसलिए y को यहाँ define किया जा रहा है ।     cin >> y; // y का पहला use     cout << "The sum is: " << x + y << endl;     return 0; }

ऐसा करने के कई फायदे हैं ।
सबसे पहला, variables जिन्हें ज़रूरत के मुताबिक सही जगह पर define किया जाता है, के आसपास के statements से ही इसके define होने की ज़रूरत का पता लग जाता है । यदि कोई variable x function में सबसे ऊपर define किया जाता है, तो हम अंदाज़ा नहीं लगा सकते की इसे किस तरह से और कहाँ use किया गया है । ये सब जानने के लिए हमे function की पूरी छानबीन करनी होगी । इसके विपरीत x को input/output statements के आसपास कहीं define करने से ये पता लग जायेगा की ये variable (x) input/output के लिए उपयोग किया जा रहा है ।

दूसरा, variable को इसके use की जगह define करना ये स्पष्ट करता है की ये variable इसके ऊपर कही भी use नहीं किया गया है । ये हमारे program को पढने या समझने में आसान तो बनाता ही है, साथ ही code में scroll करने की ज़रूरत को भी कम करता है ।
आखिर में, ये variable को भूल से uninitialized छोड़ देने की गलती होने से भी बचाता है, क्यूंकि हम variable को define कर तुरंत उसे हमारे पसंद के किसी value के साथ initialize कर सकते हैं ।
Rule: variables को उनके पहले use के जितना हो सके, उतना करीब ही define करें ।