2.3 — Variable के sizes और sizeof operator

2.3 — Variable के sizes और sizeof operator

जैसा की आपने lesson 2.1 -- Basic addressing और variable definition में देखा, आधुनिक machine में memory byte size के इकाइयों में व्यवस्थित होती है जिसमे से प्रत्येक इकाई (unit) का एक अद्वितीय memory address होता है । अभी तक, memory को mailboxes, जहाँ हम information store कर सकते हैं और उपयोग के अनुसार वापस पा सकते हैं, और variables को, ऐसे नाम जिनकी सहायता से उन mailboxes को access किया जा सकता है, की तरह समझना उपयोगी साबित हुआ ।
फिर भी, एक तरह से देखा जाये तो हमारी ये सोच सही नहीं है -- ज्यादातर variables memory में 1 से ज्यादा bytes store करते हैं (या अपने लिए सुरक्षित करते हैं) । फलस्वरूप, एक variable 2, 4 या फिर 8 memory addresses भी सुरक्षित कर सकता है । Variable कितना memory लेगा, ये इसके data type पर निर्भर करता है । लेकिन क्यूंकि हम variables को सामान्यतः उनके नाम से, ना की उनके memory address से access करते हैं, compiler विभिन्न size के variables की details हमसे छुपाने और इनके साथ काम करने में आने वाली परेशानियों से हमे बचाने में पूर्णतः सक्षम है ।

फिर भी कुछ कारणों से हमारा ये जानना ज़रूरी है की एक variable memory में कितना space ले सकता है:

पहला, variable जितना memory लेगा, ये उतना ही अधिक information store कर पायेगा । क्यूंकि एक bit केवल 0 या 1 का value store कर सकता है, हम ये कह सकते हैं की एक bit में मात्र दो values आ सकते हैं ।

2 bits 4 possible values store कर सकते हैं:

bit 0	bit 1
0	0
0	1
1	0
1	1

3 bits 8 possible values store कर सकते हैं:

bit 0	bit 1	bit 2
0	0	0
0	0	1
0	1	0
0	1	1
1	0	0
1	0	1
1	1	0
1	1	1

सीधे शब्दों में कहा जाये, तो n bits का एक variable 2ⁿ (2 का घात n, जिसे 2^n भी लिखा जाता है) possible values store कर सकता है । क्यूंकि एक byte 8 bits का समूह है, इसलिए ये 2⁸ (256) possible values store कर सकता है ।

Variable का size इसके information store करने की क्षमता को दर्शाता है -- variables जो ज्यादा bytes के होते हैं, वे ज्यादा से ज्यादा values store कर सकते हैं । हम इस मुद्दे पर और चर्चा करेंगे, जब हम अलग-अलग types के variables के बारे में विस्तार से जानेंगे ।

दूसरा, computers में एक निश्चित सीमा तक ही free memory होता है । जब भी हम कोई variable declare करते हैं, free memory का एक छोटा सा हिस्सा उसके लिए सुरक्षित कर लिया जाता है और ये memory variable के लिए तब तक store रहता है जब तक variable scope से बाहर नहीं जाता । Modern computers में memory की कोई कमी नहीं है, इसलिए यदि आप बस कुछ variables define कर रहे हैं, तो memory की चिंता करने की ज़रूरत नहीं है । फिर भी, जिन programs में अत्यधिक variables की ज़रूरत होती है (जैसे 100,000), वहाँ 1 byte और 8 byte variables के बीच का अंतर काफी मायने रखता है ।
आप अपने computer system पर ये पता लगा सकते हैं की variables (विशेषतः int, जो अक्सर 4 byte के होते हैं) अपने लिए 1 byte से ज्यादा memory सुरक्षित रखते हैं ।

C++ basic data types के sizes

अब आपका अगला प्रश्न होगा, “विभिन्न data types के variables अपने लिए कितना memory सुरक्षित करते हैं ?” आपको ये जानकार आश्चर्य हो सकता है की अलग-अलग compiler और computers के अनुसार विभिन्न data types के variables अलग-अलग मात्रा में अपने लिए memory सुरक्षित करते हैं !

C++ ये guarantee देता है की variables कम से कम निम्नलिखित sizes के ज़रूर होंगे:

Category	Type	Minimum Size	Note
boolean	bool	1 byte
character	char	1 byte	signed या unsigned हो सकता है
	wchar_t	1 byte
	char16_t	2 bytes	C++11 type
	char32_t	4 bytes	C++11 type
integer	short	2 bytes
	int	2 bytes
	long	4 bytes
	long long	8 bytes	C99/C++11 type
floating point	float	4 bytes
	double	8 bytes
	long double	8 bytes

Variables की वास्तविक size आपके machine में table में दी गयी sizes से अलग भी हो सकती है । अलग-अलग machines में data type की size का पता लगाने के लिए C++ में एक operator मौजूद है: sizeof operator । Sizeof operator एक unary operator है, जो operand के रूप में एक data type, या किसी data type का एक variable लेता है और result के रूप में इसका size return करता है (bytes में) । आप नीचे दिए गए program को अपने machine में compile कर के ये पता लगा सकते हैं की आपके machine में ये variables (या ये data types) कितना memory लेते हैं :

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

#include <iostream> int main() {     using namespace std;     cout << "bool:\t\t" << sizeof(bool) << " bytes" << endl;     cout << "char:\t\t" << sizeof(char) << " bytes" << endl;     cout << "wchar_t:\t" << sizeof(wchar_t) << " bytes" << endl;     cout << "char16_t:\t" << sizeof(char16_t) << " bytes" << endl; // C++11 से पहचान में आया, आपका compiler इसे नहीं भी support कर सकता है     cout << "char32_t:\t" << sizeof(char32_t) << " bytes" << endl; // C++11 से पहचान में आया, आपका compiler इसे नहीं भी support कर सकता है     cout << "short:\t\t" << sizeof(short) << " bytes" << endl;     cout << "int:\t\t" << sizeof(int) << " bytes" << endl;     cout << "long:\t\t" << sizeof(long) << " bytes" << endl;     cout << "long long:\t" << sizeof(long long) << " bytes" << endl; C++11 से पहचान में आया, आपका compiler इसे नहीं भी support कर सकता है     cout << "float:\t\t" << sizeof(float) << " bytes" << endl;     cout << "double:\t\t" << sizeof(double) << " bytes" << endl;     cout << "long double:\t" << sizeof(long double) << " bytes" << endl;     return 0; }

Alex के x64 machine (2015) में Visual Studio 2013 का प्रयोग करते हुए, इस program का result कुछ ऐसा है, :

bool:           1 bytes

char:           1 bytes

wchar_t:        2 bytes

char16_t:       2 bytes

char32_t:       4 bytes

short:          2 bytes

int:            4 bytes

long:           4 bytes

long long:      8 bytes

float:          4 bytes

double:         8 bytes

long double:    8 bytes

यदि आप कोई दूसरा machine या compiler इस्तेमाल कर रहे हैं, तो उनमें ये results अलग हो सकते हैं । ध्यान दे की आप sizeof का प्रयोग void data type पे नहीं कर सकते हैं, क्यूंकि इसका कोई size नहीं होता । ऐसा करने से आपको compiler error मिलेगा ।

यदि आप ये सोच रहें हैं की ऊपर के program में ‘\t’ क्या है, तो बता दूँ की ये एक special symbol है जो output करते वक़्त एक tab दिखाता है । ऊपर दिए गए example में हम इसका प्रयोग output को अच्छी तरह से format करने के लिए कर रहे हैं । char data type पर चर्चा करते वक़्त हम इसके और इसके साथ अलग-अलग special symbol के बारे में विस्तार से जानेंगे ।

ध्यान देने की बात है, की sizeof operator C++ में उन तीन operators में से एक है जिनके लिए symbol की जगह नाम, जैसे की यहाँ sizeof, का इस्तेमाल किया जाता है । new और delete ऐसे ही दो operators हैं ।

आप sizeof operator का इस्तेमाल variables के नाम पर भी कर सकते हैं :

1 2	int x;     cout << "x is " << sizeof(x) << " bytes"<<endl;

x is 4 bytes

आने वाले lessons में हम विभिन्न data types के sizes के बारे में और अधिक चर्चा करेंगे ।