C Language => जानकारी का प्रकार

टिप्पणियों

जबकि char को 1 बाइट की आवश्यकता होती है, 1 बाइट को 8 बिट्स (अक्सर इसे ऑक्टेट भी कहा जाता है) की आवश्यकता नहीं होती है, भले ही अधिकांश आधुनिक कंप्यूटर प्लेटफॉर्म इसे 8 बिट्स के रूप में परिभाषित करते हैं। कार्यान्वयन की संख्या प्रति char बिट्स CHAR_BIT मैक्रो द्वारा प्रदान की जाती है, जिसे <limits.h> में परिभाषित किया गया है। POSIX को 8 बिट होने के लिए 1 बाइट की आवश्यकता होती है।
निश्चित चौड़ाई पूर्णांक प्रकारों का उपयोग किया जाना चाहिए, C के अंतर्निहित प्रकार हर वास्तुकला पर प्राकृतिक होने के लिए डिज़ाइन किए गए हैं, निश्चित चौड़ाई प्रकारों का उपयोग केवल तभी किया जाना चाहिए जब आपको स्पष्ट रूप से आकार के पूर्णांक (नेटवर्किंग के लिए उदाहरण के लिए) की आवश्यकता हो।

पूर्णांक प्रकार और स्थिरांक

पर हस्ताक्षर किए पूर्णांक इन प्रकार के हो सकते ( int के बाद short , या long वैकल्पिक है):

signed char c = 127; /* required to be 1 byte, see remarks for further information. */
signed short int si = 32767; /* required to be at least 16 bits. */
signed int i = 32767; /* required to be at least 16 bits */
signed long int li = 2147483647; /* required to be at least 32 bits. */

C99

signed long long int li = 2147483647; /* required to be at least 64 bits */

इन हस्ताक्षरित पूर्णांक प्रकारों में से प्रत्येक में एक अहस्ताक्षरित संस्करण है।

unsigned int i = 65535;
unsigned short = 2767;
unsigned char = 255;

लेकिन सभी प्रकार के लिए char signed है, तो संस्करण माना जाता है signed या unsigned हिस्सा छोड़ दिया जाता है। प्रकार char एक तीसरे वर्ण प्रकार का गठन करता है, signed char और unsigned char से अलग और unsigned char (या नहीं) मंच पर निर्भर करता है।

पूर्णांक स्थिरांक (सी शब्दजाल में शाब्दिक कहा जाता है) के विभिन्न प्रकार विभिन्न ठिकानों में लिखा जा सकता है और अलग अलग चौड़ाई, उनके उपसर्ग या प्रत्यय पर आधारित है।

/* the following variables are initialized to the same value: */
int d = 42;   /* decimal constant (base10) */
int o = 052;  /* octal constant (base8) */
int x = 0xaf; /* hexadecimal constants (base16) */
int X = 0XAf; /* (letters 'a' through 'f' (case insensitive) represent 10 through 15) */

दशमलव स्थिरांक पर हमेशा signed । हेक्साडेसिमल स्थिरांक 0x या 0X शुरू होते हैं और अष्टक स्थिरांक केवल 0 शुरू होते हैं। बाद के दो कर रहे हैं signed या unsigned पर कि क्या हस्ताक्षर किए प्रकार में मूल्य फिट है या नहीं निर्भर करता है।

/* suffixes to describe width and signedness : */
long int i = 0x32; /* no suffix represent int, or long int */
unsigned int ui = 65535u; /* u or U represent unsigned int, or long int */
long int li = 65536l; /* l or L represent long int */

एक प्रत्यय निरंतर पहले प्रकार है कि अपने मूल्य फिट बैठता है के बिना, कि एक दशमलव निरंतर से बड़ा है INT_MAX प्रकार का है long यदि संभव हो तो, या long long अन्यथा।

शीर्ष लेख फ़ाइल <limits.h> पूर्णांक की सीमाओं का वर्णन इस प्रकार है। उनके कार्यान्वयन-परिभाषित मूल्य समान संकेत के साथ नीचे दिखाए गए लोगों के लिए परिमाण (निरपेक्ष मूल्य) में समान या अधिक होंगे।

मैक्रो	प्रकार	मूल्य
`CHAR_BIT`	सबसे छोटी वस्तु जो बिट-फील्ड नहीं है (बाइट)	8
`SCHAR_MIN`	`signed char`	-127 / - (2 ⁷ - 1)
`SCHAR_MAX`	`signed char`	+127 / 2 ⁷ - 1
`UCHAR_MAX`	`unsigned char`	255/2 ⁸ - 1
`CHAR_MIN`	`char`	निचे देखो
`CHAR_MAX`	`char`	निचे देखो
`SHRT_MIN`	`short int`	-32767 / - (2 ¹⁵ - 1)
`SHRT_MAX`	`short int`	+32767 / 2 ¹⁵ - 1
`USHRT_MAX`	`unsigned short int`	65535/2 ¹⁶ - 1
`INT_MIN`	`int`	-32767 / - (2 ¹⁵ - 1)
`INT_MAX`	`int`	+32767 / 2 ¹⁵ - 1
`UINT_MAX`	`unsigned int`	65535/2 ¹⁶ - 1
`LONG_MIN`	`long int`	-2147483647 / - (2 ³¹ - 1)
`LONG_MAX`	`long int`	+2147483647 / 2 ³¹ - 1
`ULONG_MAX`	`unsigned long int`	4294967295/2 ³² - 1

C99

मैक्रो	प्रकार	मूल्य
`LLONG_MIN`	`long long int`	-922337203685474775807 / - (2 ⁶³ - 1)
`LLONG_MAX`	`long long int`	+922337203685474775807 / 2 ⁶³ - 1
`ULLONG_MAX`	`unsigned long long int`	18446744073709551615/2 ⁶⁴ - 1

अगर की एक वस्तु का मान प्रकार char साइन-फैली जब एक अभिव्यक्ति में इस्तेमाल किया, का मूल्य CHAR_MIN की तरह ही होगा SCHAR_MIN और का मूल्य CHAR_MAX की तरह ही होगा SCHAR_MAX । यदि अभिव्यक्ति में उपयोग किए जाने पर प्रकार char ऑब्जेक्ट का मान साइन- CHAR_MIN नहीं करता है, तो CHAR_MIN का मान 0 होगा और CHAR_MAX का मूल्य UCHAR_MAX के समान होगा।

C99

C99 मानक में एक नया हेडर जोड़ा गया, <stdint.h> , जिसमें निश्चित चौड़ाई पूर्णांक के लिए परिभाषाएँ हैं। अधिक गहराई से स्पष्टीकरण के लिए निश्चित चौड़ाई पूर्णांक उदाहरण देखें।

स्ट्रिंग साहित्य

सी में एक स्ट्रिंग शाब्दिक वर्णों का एक क्रम है, जिसे शाब्दिक शून्य द्वारा समाप्त किया गया है।

char* str = "hello, world"; /* string literal */

/* string literals can be used to initialize arrays */
char a1[] = "abc"; /* a1 is char[4] holding {'a','b','c','\0'} */
char a2[4] = "abc"; /* same as a1 */
char a3[3] = "abc"; /* a1 is char[3] holding {'a','b','c'}, missing the '\0' */

स्ट्रिंग शाब्दिक रूप से परिवर्तनीय नहीं हैं (और वास्तव में केवल-पढ़ने के लिए स्मृति में रखा जा सकता है जैसे कि .rodata)। उनके मूल्यों में फेरबदल करने का प्रयास अपरिभाषित व्यवहार के परिणामस्वरूप होता है।

char* s = "foobar";
s[0] = 'F'; /* undefined behaviour */

/* it's good practice to denote string literals as such, by using `const` */
char const* s1 = "foobar";
s1[0] = 'F'; /* compiler error! */

कई स्ट्रिंग शाब्दिक संकलन समय पर सम्‍मिलित किए जाते हैं, जिसका अर्थ है कि आप इन जैसे निर्माण लिख सकते हैं।

C99

/* only two narrow or two wide string literals may be concatenated */
char* s = "Hello, " "World";

C99

/* since C99, more than two can be concatenated */
/* concatenation is implementation defined */
char* s1 = "Hello" ", " "World";

/* common usages are concatenations of format strings */
char* fmt = "%" PRId16; /* PRId16 macro since C99 */

स्ट्रिंग शाब्दिक, चरित्र स्थिरांक के समान, विभिन्न वर्ण सेटों का समर्थन करते हैं।

/* normal string literal, of type char[] */
char* s1 = "abc";

/* wide character string literal, of type wchar_t[] */
wchar_t* s2 = L"abc";

C11

/* UTF-8 string literal, of type char[] */
char* s3 = u8"abc";

/* 16-bit wide string literal, of type char16_t[] */
char16_t* s4 = u"abc";

/* 32-bit wide string literal, of type char32_t[] */
char32_t* s5 = U"abc";

निश्चित चौड़ाई पूर्णांक प्रकार (C99 के बाद से)

C99

शीर्ष लेख <stdint.h> कई निश्चित-चौड़ाई पूर्णांक प्रकार की परिभाषाएँ प्रदान करता है। ये प्रकार वैकल्पिक होते हैं और केवल तब प्रदान किए जाते हैं यदि प्लेटफ़ॉर्म में पूर्णांक प्रकार की संबंधित चौड़ाई होती है, और यदि संबंधित हस्ताक्षरित प्रकार में नकारात्मक मानों का दो का पूरक प्रतिनिधित्व होता है।

निश्चित चौड़ाई प्रकारों के उपयोग संकेत के लिए टिप्पणी अनुभाग देखें।

/* commonly used types include */
uint32_t u32 = 32; /* exactly 32-bits wide */

uint8_t u8 = 255;  /* exactly 8-bits wide */

int64_t i64 = -65  /* exactly 64 bit in two's complement representation */

फ़्लोटिंग पॉइंट कॉन्स्टेंट्स

सी भाषा में तीन अनिवार्य वास्तविक फ्लोटिंग पॉइंट प्रकार, float , double और long double ।

float f = 0.314f;        /* suffix f or F denotes type float */
double d = 0.314;        /* no suffix denotes double */
long double ld = 0.314l; /* suffix l or L denotes long double */

/* the different parts of a floating point definition are optional */
double x = 1.; /* valid, fractional part is optional */
double y = .1; /* valid, whole-number part is optional */

/* they can also defined in scientific notation */
double sd = 1.2e3; /* decimal fraction 1.2 is scaled by 10^3, that is 1200.0 */

शीर्ष लेख <float.h> फ़्लोटिंग पॉइंट ऑपरेशंस के लिए विभिन्न सीमाओं को परिभाषित करता है।

फ्लोटिंग पॉइंट अंकगणित को कार्यान्वयन परिभाषित किया गया है। हालाँकि, अधिकांश आधुनिक प्लेटफ़ॉर्म (आर्म, x86, x86_64, MIPS) IEEE 754 फ़्लोटिंग पॉइंट ऑपरेशन का उपयोग करते हैं।

C में तीन वैकल्पिक जटिल फ्लोटिंग पॉइंट प्रकार भी हैं जो ऊपर से प्राप्त होते हैं।

घोषणाओं की व्याख्या

सी की एक विशिष्ट वाक्यविन्यास विशिष्टता यह है कि घोषणाएं घोषित वस्तु के उपयोग को प्रतिबिंबित करती हैं क्योंकि यह एक सामान्य अभिव्यक्ति में होगा।

समान पूर्वता और सहानुभूति के साथ ऑपरेटरों के निम्नलिखित सेट को पुन: घोषणाकर्ता में पुन: उपयोग किया जाता है, अर्थात्:

unary * "dereference" ऑपरेटर जो एक सूचक को दर्शाता है;
बाइनरी [] "सरणी सदस्यता" ऑपरेटर जो एक सरणी को दर्शाता है;
(1 + n) -ary () "फ़ंक्शन कॉल" ऑपरेटर जो फ़ंक्शन को दर्शाता है;
() समूहबद्ध कोष्ठक जो कि शेष सूचीबद्ध संचालकों की पूर्वता और सहानुभूति से अधिक है।

उपर्युक्त तीनों संचालकों में निम्नलिखित पूर्ववर्तीता और समरूपता है:

ऑपरेटर	रिश्तेदार पूर्ववर्तीता	संबद्धता
`[]` (सरणी सदस्यता)	1	बाएं से दाएं
`()` (फ़ंक्शन कॉल)	1	बाएं से दाएं
`*` (डीरेसीफिकेशन)	2	दाएं से बाएं

घोषणाओं की व्याख्या करते समय, किसी को पहचानकर्ता से बाहर की ओर शुरू करना होता है और उपरोक्त तालिका के अनुसार आसन्न ऑपरेटरों को सही क्रम में लागू करना होता है। एक ऑपरेटर के प्रत्येक आवेदन को निम्नलिखित अंग्रेजी शब्दों के साथ प्रतिस्थापित किया जा सकता है:

अभिव्यक्ति	व्याख्या
`thing[X]`	आकार `X` की एक सरणी ...
`thing(t1, t2, t3)`	एक फ़ंक्शन `t1` , `t2` , `t3` और वापस ले रहा है ...
`*thing`	एक सूचक को ...

यह इस प्रकार है कि अंग्रेजी व्याख्या की शुरुआत हमेशा पहचानकर्ता के साथ शुरू होगी और उस प्रकार के साथ समाप्त होगी जो घोषणा के बाईं ओर खड़ी है।

उदाहरण

char *names[20];

[] * पर पूर्वता लेता है, इसलिए व्याख्या यह है: names एक पॉइंटर के आकार 20 से char की एक सरणी है।

char (*place)[10];

पूर्वता को ओवरराइड करने के लिए कोष्ठक का उपयोग करने के मामले में, * पहले लागू किया जाता है: place char के आकार 10 की सरणी के लिए एक संकेतक है।

int fn(long, short);

यहाँ चिंता करने की कोई पूर्वता नहीं है: fn एक ऐसा कार्य है जिसमें long , short और लौटने वाले int ।

int *fn(void);

() पहले लागू किया गया है: fn void लेने और int लिए एक पॉइंटर वापस करने के लिए एक फ़ंक्शन है।

int (*fp)(void);

() की पूर्वता को ओवरराइड करना: fp void लेने और int वापस लौटने वाले फ़ंक्शन का एक संकेतक है।

int arr[5][8];

बहुआयामी सरणियों नियम का अपवाद नहीं हैं; [] ऑपरेटरों तालिका में संबद्धता के अनुसार बाएँ-से-सही क्रम में लागू होते हैं: arr के 8 आकार की एक सरणी के 5 आकार की एक सरणी है int ।

int **ptr;

दो डेरेक्शन ऑपरेटरों के बीच समान रूप से समानता होती है, इसलिए संबद्धता प्रभावी होती है। ऑपरेटरों को दाएं-से-बाएं क्रम में लागू किया जाता है: ptr एक सूचक से एक int सूचक है।

एकाधिक घोषणाएँ

अल्पविराम को एक बयान में कई घोषणाओं को रद्द करने के लिए एक विभाजक के रूप में इस्तेमाल किया जा सकता है (* नहीं * अल्पविराम ऑपरेटर की तरह)। निम्नलिखित कथन में पाँच घोषणाएँ हैं:

int fn(void), *ptr, (*fp)(int), arr[10][20], num;

उपरोक्त उदाहरण में घोषित वस्तुएँ हैं:

fn : एक फ़ंक्शन void ले रहा void और int वापस आ रहा है;
ptr : int सूचक;
fp : एक समारोह लेने के लिए सूचक int और लौटने int ;
arr : आकार की एक सरणी 10 आकार की एक सरणी 20 int ;
num : int ।

वैकल्पिक व्याख्या

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

/*
 * Subscripting "arr" and dereferencing it yields a "char" result.
 * Particularly: *arr[5] is of type "char".
 */
char *arr[20];

/*
 * Calling "fn" yields an "int" result.
 * Particularly: fn('b') is of type "int".
 */
int fn(char);

/*
 * Dereferencing "fp" and then calling it yields an "int" result.
 * Particularly: (*fp)() is of type "int".
 */
int (*fp)(void);

/*
 * Subscripting "strings" twice and dereferencing it yields a "char" result.
 * Particularly: *strings[5][15] is of type "char"
 */
char *strings[10][20];

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

C Language
जानकारी का प्रकार

खोज…