C Data Type Range

C Data Type Range: जब हम अपनी जरूरत के आधार पर विभिन्न प्रकार के Identifier Declare करते हैं, तब किस प्रकार का Identifier Memory में Minimum व Maximum कितने मान तक की संख्‍या को Hold कर सकता है, इस बात की जानकारी “C” Language के साथ मिलने वाली “limits.h” नाम की Header File में दी गई है।

यदि हम चाहें तो इस Header File को जो कि ..\include नाम के Folder में होती है, Open करके विभिन्न Data Types द्वारा Store की जा सकने वाली Minimum व Maximum Range का पता लगा सकते हैं। जहां विभिन्न Data Type द्वारा प्रदान की जाने वाली Minimum व Maximum Range को कुछ Preprocessor Directives के रूप में Define किया गया है। लेकिन यदि हम Header File को Open करके ना देखना चाहें, तो निम्नानुसार एक Program बना कर भी हम विभिन्न Data Types द्वारा प्रदान की जाने वाली Minimum व Maximum Range का पता लगा सकते हैं।

चूंकि इन विभिन्न प्रकार के Directives को “limits.h” नाम की Header File में Define किया गया है, इसलिए इन Directives को Access करने के लिए हमें “limits.h” नाम की Header File को अपने Program में Include करना जरूरी होता है।

//Program:
#include <stdio.h>
#include <conio.h>
#include <limits.h>
#include <float.h>
#define _ printf("\n Minimum
#define __ printf("\n Maximum

void main(){
 _ short|short int|signed short|signed short int : %d ", SHRT_MIN );
 __ short|short int|signed short|signed short int : %d ", SHRT_MAX );
 _ unsigned short|unsigned short int : %u", 0 );
 __ unsigned short|unsigned short int : %u ", USHRT_MAX );
 _ int|signed int : %d ", INT_MIN );
 __ int|signed int : %d ", INT_MAX );
 _ unsigned int : %u ", 0 );
 __ unsigned int : %u ", UINT_MAX );
 _ long|long int|signed long|signed long int : %ld ", LONG_MIN );
 __ long|long int|signed long|signed long int : %ld ", LONG_MAX );
 _ unsigned long|unsigned long int : %lu ", 0 );
 __ unsigned long|unsigned long int : %lu", ULONG_MAX );
 _ float : %e", FLT_MIN);
 __ float : %e", FLT_MAX);
 _ double : %e", DBL_MIN);
 __ double : %e", DBL_MAX);
 _ long double : %Le", LDBL_MIN);
 __ long double : %Le", LDBL_MAX);
}

ये Program देखने में बहुत अजीब लग सकता है, लेकिन इस Program में हमने Underscore व Double Underscore Symbol से printf() Function के कुछ Part को Directive के रूप में परिभाषित कर लिया है।

जब इस Program को Compile करते हैं, तब Program Compile होने से पहले Underscore ( _ ) Symbol के स्थान पर “printf(“\n Minimum” String को व Double Underscore Symbol ( __ ) के स्थान पर “printf(“\n Maximum” String को Replace कर देता है। Preprocess होने के बाद जब Program Compile होकर Run होता है, तब हमें इस Program का Output निम्नानुसार प्राप्त होता है:

limits.h नाम की Header File में विभिन्न प्रकार के Integers से सम्बंधित Range की जानकारी होती है, उसी तरह से Float से सम्बंधित विभिन्न प्रकार के Range की जानकारी के लिए हम “float.h” नाम की Header File को Open करके देख सकते हैं। इसीलिए हमने हमारे Program में Float व Double से सम्बंधित Range की जानकारी के लिए “float.h” नाम की Header File को भी Include किया है।

यदि हम ये जानना चाहें कि विभिन्न प्रकार के Data Type के Identifiers Memory में कितने Bytes की Space Reserve करते हैं, तो इस बात का पता लगाने के लिए हम sizeof() Operator का प्रयोग कर सकते हैं। ये Operator Argument के रूप में उस Identifier या Data Type को लेता है, जिसकी Size को हम जानना चाहते हैं और हमें उस Data Type या Identifier की Size Return करता है। यानी इस Operator के Parenthesis के बीच में हम जिस Identifier या Data Type को लिख देते हैं, हमें उसी Data Type की Size का पता चल जाता है।

सामान्‍यतया Integer Data Type के अलावा सभी Data Types सभी प्रकार के Processors युक्‍त Computers में समान Memory Occupy करते हैं, लेकिन Integer Data Type, Memory में CPU यानी Microprocessor के Registers की Size के बराबर Space Occupy करता है। इसलिए 16-bit CPU के लिए Integers की Size 16-bit या 2-Byte ही होती है, जबकि 32-bit CPU के लिए Integers की Size 32-bit या 4-Byte ही होती है।

Microprocessors पर Execute होने वाले Machine Codes को Generate करने वाला Compiler and Interpreter, Underlying Microprocessor के Architecture (16-bit, 31-bit or 64-bit) को ध्‍यान में रखते हुए ही Develop किए जाते हैं।  अत: यदि हम 16-Bit Compiler (Turbo C) में अपना Program Compile करते हैं, तो हमें प्राप्‍त होने वाला Output 16-Bit Processor Supported Output होता है, जबकि 32-Bit System (Borland C) में अपना Program Compile करते हैं, तो हमें प्राप्‍त होने वाला Output 32-bit Processor Supported Output होता है।

हालांकि 16-bit Program, 32-bit Processors पर Run हो सकते हैं, लेकिन 32-bit Programs, 16-bit Processor युक्‍त Computers पर Run नहीं हो सकते। क्‍योंकि 32-bit Supported Compilers में CPU Registers की Size को 16-bit मानते हुए Machine Code Generate किया जाता है, जिसकी वजह से उस Machine Code में Integer की Size 4-Byte होती है। जबकि 16-bit Supported Compilers में CPU Registers की Size को 16-bit मानते हुए Machine Code Generate किया जाता है, परिणामस्‍वरूप इस Compiler से Generate होने वाले Machine Code में Integer की Size 2-Byte ही होती है।

परिणामस्‍वरूप 32-bit Processor Supported Compilers द्वारा Generate होने वाले Machine Codes केा जब 16-bit Processor पर Run करते हैं, तो Integers की Size Match नहीं हो पाती, जिसकी वजह से 32-bit Processor Supported Compilers द्वारा Generated Machine Codes, 16-bit Processor Supported Computers पर Run नहीं हो पाते।

इसलिए हम जिस Compiler को Use करते हुए अपना प्रोग्राम कम्‍पाईल कर रहे हैं, उस Compiler द्वारा विभिन्न प्रकार के Basic Data Type द्वारा Occupy की जाने वाली Memory का पता हम निम्न Program द्वारा लगा सकते हैं:

Program
#include <stdio.h>
#include <conio.h>

void main()
{
 printf("char          :   %d Bytes\n",   sizeof(char));
 printf("short         :   %d Bytes\n",   sizeof(short));
 printf("int           :   %d Bytes\n",   sizeof(int));
 printf("long          :   %d Bytes\n\n", sizeof(long));

 printf("signed char   :   %d Bytes\n",   sizeof(signed char));
 printf("signed short  :   %d Bytes\n",   sizeof(signed short));
 printf("signed int    :   %d Bytes\n",   sizeof(signed int));
 printf("signed long   :   %d Bytes\n\n", sizeof(signed long));

 printf("unsigned char :   %d Bytes\n",   sizeof(unsigned char));
 printf("unsigned short:   %d Bytes\n",   sizeof(unsigned short));
 printf("unsigned int  :   %d Bytes\n",   sizeof(unsigned int));
 printf("unsigned long :   %d Bytes\n\n", sizeof(unsigned long));

 printf("float         :   %d Bytes\n", sizeof(float));
 printf("double        :   %d Bytes\n", sizeof(double));
 printf("long double   :   %d Bytes\n", sizeof(long double));
 getch();
}