C "int" 2 बाइट्स या 4 बाइट्स का आकार है?

Question

C के 2 बाइट्स या 4 बाइट्स में एक इंटेगर वेरिएबल होता है? वे कौन से कारक हैं जो इस पर निर्भर करते हैं?

अधिकांश पाठ्यपुस्तकों का कहना है कि पूर्णांक चर 2 बाइट्स हैं। लेकिन जब मैं पूर्णांकों की एक सरणी के क्रमिक पतों को प्रिंट करने वाला कार्यक्रम चलाता हूं तो यह 4 के अंतर को दर्शाता है।

Comments

en.wikipedia.org/wiki/…

— इवान मुलवस्की

intकई पूर्णांक प्रकारों में से एक है। आपने "पूर्णांक" के आकार के बारे में पूछा; आप शायद आकार के बारे में पूछना चाहते थे int।

— कीथ थॉम्पसन

और आपको बेहतर पाठ्यपुस्तकें ढूंढनी चाहिए। एक पाठ्यपुस्तक जो कहती है कि int2 बाइट्स (ए) संभवतः एक पुरानी प्रणाली को संदर्भित करता है, और (बी) यह स्पष्ट करने में विफल रहता है कि आकार एक सिस्टम से दूसरे सिस्टम में भिन्न होगा। C पर सबसे अच्छी पुस्तक "द सी प्रोग्रामिंग लैंग्वेज" है, जिसे कार्निघन और रिची ने लिखा है, हालांकि यह कुछ प्रोग्रामिंग अनुभव को मानता है। भी की 18.10 प्रश्न देखें comp.lang.c पूछे जाने वाले प्रश्न ।

— कीथ थॉम्पसन

#define int int64_t64-बिट प्लेटफ़ॉर्म पर प्रयास करें , तो न तो। बस उपयोग करें sizeof। ;-)

— नेटकोडर

C ++ मानक के आकार का

— फुल्विक

Answer 1

मुझे पता है कि यह बराबर है sizeof(int)। एक का आकार intवास्तव में संकलक पर निर्भर है। दिन में वापस, जब प्रोसेसर 16 बिट थे, एक int2 बाइट्स था। आजकल, यह 32-बिट के साथ-साथ 64-बिट सिस्टम पर सबसे अधिक बार 4 बाइट्स है।

फिर भी, sizeof(int)विशिष्ट सिस्टम के लिए प्रोग्राम को निष्पादित करने के लिए पूर्णांक के आकार को प्राप्त करने का सबसे अच्छा तरीका है।

EDIT:int अधिकांश 64-बिट सिस्टम पर 8 बाइट्स के साथ फिक्स्ड गलत स्टेटमेंट । उदाहरण के लिए, यह 64-बिट GCC पर 4 बाइट्स है।

Comments

@ राजीवप्रताप: ठीक है, यह कंपाइलर-डिपेंडेंट है, लेकिन कंपाइलर तय करता है कि यह मशीन पर निर्भर है या नहीं। :)

— user541686

यदि आपको प्रीप्रोसेसर के लिए आकार की आवश्यकता है, तो आप INT_MAX जैसे पूर्वनिर्धारित मैक्रो की जांच कर सकते हैं। यदि मूल्य आपके कोड द्वारा अपेक्षित नहीं है, तो वर्तमान कंपाइलर / प्लेटफॉर्म संयोजन पर इंट का बाइट आकार अलग है।

— वॉल्ट सेलर्स

सिर्फ मशीन पर निर्भर नहीं, यह मशीन पर चल रहे ऑपरेटिंग सिस्टम पर भी निर्भर करता है। उदाहरण के लिए Win64 में लंबा 4 बाइट्स है जबकि Linux64 में लंबा 8 बाइट्स है।

— केम कल्याणको

गलत। अधिकांश 64-बिट सिस्टम int पर अभी भी 4 बाइट्स हैं en.wikipedia.org/wiki/64-bit_computing#64-bit_data_models

— phuclv

sizeof(int)किसी भी मूल्य से हो सकता है 1। एक बाइट को 8 बिट्स की आवश्यकता नहीं होती है और कुछ मशीनों में 8 बिट एड्रेसेबल यूनिट नहीं होती है (जो मूल रूप से मानक में बाइट की परिभाषा है )। अधिक जानकारी के बिना उत्तर सही नहीं है।

— इस साइट

Answer 2

यह C में से एक बिंदु है जो पहली बार में भ्रमित हो सकता है, लेकिन C मानक केवल पूर्णांक प्रकारों के लिए एक न्यूनतम सीमा निर्दिष्ट करता है जो समर्थित होने की गारंटी है। int-32767 से 32767 तक रखने में सक्षम होने की गारंटी है, जिसके लिए 16 बिट्स की आवश्यकता होती है। उस मामले में int, 2 बाइट्स है। हालांकि, कार्यान्वयन उस न्यूनतम से आगे जाने के लिए स्वतंत्र हैं, जैसा कि आप देखेंगे कि कई आधुनिक कंपाइलर int32-बिट बनाते हैं (जिसका अर्थ है 4 बाइट्स सुंदर रूप से)।

आपकी पुस्तक 2 बाइट्स कहती है कि शायद यह सबसे पुराना है। एक समय, यह आदर्श था। सामान्य तौर पर, आपको हमेशा sizeofऑपरेटर का उपयोग करना चाहिए यदि आपको यह पता लगाने की आवश्यकता है कि आपके द्वारा उपयोग किए जा रहे प्लेटफॉर्म पर कितने बाइट्स हैं।

इसे संबोधित करने के लिए, C99 ने नए प्रकार जोड़े जहाँ आप स्पष्ट रूप से एक निश्चित आकार के पूर्णांक के लिए पूछ सकते हैं, उदाहरण के लिए int16_tया int32_t। इससे पहले, एक विशिष्ट चौड़ाई का पूर्णांक प्राप्त करने का कोई सार्वभौमिक तरीका नहीं था (हालांकि अधिकांश प्लेटफॉर्म प्रति-प्लेटफॉर्म के आधार पर इसी प्रकार प्रदान करते हैं)।

Comments

@nevanking: एक दो के पूरक मशीन पर (जो हर मशीन है जो मुझे पता है ...), हाँ। लेकिन, सी यह मामला होने की गारंटी नहीं देता है।

— फाटलएरर

@nevanking मैं C के लिए पूरी तरह से नया हूँ, लेकिन क्या यह 32767 नहीं है क्योंकि अन्यथा यह एक और बिट का उपयोग करेगा? बाइट | कल्पना कीजिए, मैं 3 अंक (0 या 1) पकड़ सकता हूं, इसलिए मैं 000 से 111 (जो दशमलव 7 है) जा सकता हूं। 7 एक घातांक 2 से ठीक पहले है। अगर मैं 8 (1000) तक जा सकता था, तो मैं उन 4 अंकों का उपयोग कर सकता था जो 15 तक हो सकते हैं! जैसे 32767 2 के घातांक से ठीक पहले है, सभी बिट्स को समाप्त कर रहा है। बाइट्स यह उपलब्ध है।

— RGS

@Rerrao मैं सी विशेषज्ञ नहीं हूं, लेकिन सकारात्मक संख्या के लिए AFAIK यह अधिकतम नकारात्मक संख्या से कम है। तो -8 से 7, -256 से 255 और इतने पर। ऋणात्मक संख्याओं को शून्य की गणना नहीं करनी है।

— नीवन राजा

"16 बिट्स। उस मामले में, int, 2 बाइट्स है" गलत हो सकता है, अगर CHAR_BIT 16 है, साइज़ोफ़ (int) 1 बाइट (या चार) हो सकता है।

— 12431234123412341234123

@nevanking: केवल तभी जब आप हस्ताक्षर के लिए 2 के पूरक प्रतिनिधित्व को मानते हैं int। C वह धारणा नहीं बनाता है। 1 के पूरक और साइन-परिमाण सिस्टम -3276816 बिट्स में प्रतिनिधित्व नहीं कर सकते हैं ; बल्कि, उनके पास शून्य (सकारात्मक और नकारात्मक) के लिए दो अभ्यावेदन हैं। यही कारण है कि एक के लिए न्यूनतम सीमा intहै [-32767..32767]।

— जॉन बोड

Answer 3

कोई विशिष्ट उत्तर नहीं है। यह प्लेटफॉर्म पर निर्भर करता है। यह कार्यान्वयन-परिभाषित है। यह 2, 4 या कुछ और हो सकता है।

इसके पीछे विचार intयह था कि दिए गए प्लेटफ़ॉर्म पर प्राकृतिक "शब्द" आकार का मिलान करना था: 16-बिट प्लेटफ़ॉर्म पर 16 बिट, 32-बिट प्लेटफ़ॉर्म पर 32 बिट, 64-बिट प्लेटफ़ॉर्म पर 64 बिट, आपको विचार मिलता है। हालांकि, पिछड़े संगतता उद्देश्यों के लिए कुछ कंपाइलर्स int64-बिट प्लेटफॉर्म पर भी 32-बिट से चिपके रहना पसंद करते हैं ।

intजब तक आप 16-बिट शब्द आकार के साथ कुछ एम्बेडेड प्लेटफॉर्म का उपयोग नहीं कर रहे हैं, तब तक 2-बाइट का समय लंबा हो गया है (16-बिट प्लेटफॉर्म?)। आपकी पाठ्य पुस्तकें शायद बहुत पुरानी हैं।

Comments

The idea behind int was that it was supposed to match the natural "word" size on the given platform- यह वही है जिसे मैं देख रहा था। किसी भी विचार कारण क्या हो सकता है? एक स्वतंत्र दुनिया में, इंट मेमोरी में किसी भी संख्या में लगातार बाइट्स पर कब्जा कर सकता है? 8, 16 जो भी

— bhagagabbar

Answer 4

इस प्रश्न का उत्तर इस बात पर निर्भर करता है कि आप किस प्लेटफॉर्म का उपयोग कर रहे हैं।
लेकिन मंच के बावजूद, आप मज़बूती से निम्न प्रकार ग्रहण कर सकते हैं:

 [8-bit] signed char: -127 to 127
 [8-bit] unsigned char: 0 to 255
 [16-bit]signed short: -32767 to 32767
 [16-bit]unsigned short: 0 to 65535
 [32-bit]signed long: -2147483647 to 2147483647
 [32-bit]unsigned long: 0 to 4294967295
 [64-bit]signed long long: -9223372036854775807 to 9223372036854775807
 [64-bit]unsigned long long: 0 to 18446744073709551615

Comments

किसी ने आपके पोस्ट को श्रेणियों को "ठीक" करने के लिए संपादित किया है, लेकिन मुझे यकीन नहीं है कि आपका संपादन आपके इरादे को पर्याप्त रूप से दर्शाता है। यह एक दो के पूरक कार्यान्वयन को मानता है, जो ज्यादातर मामलों में सही होगा , लेकिन सभी नहीं। चूंकि आपका उत्तर विशेष रूप से कार्यान्वयन-निर्भरता को इंगित करता है, इसलिए मैं सोच रहा हूं कि संपादन संभवतः गलत है। यदि आप सहमत हैं, तो कृपया संपादन वापस करना सुनिश्चित करें।

— कोड़ी ग्रे

@ k06a आपका संपादन गलत था । आपने विशेष रूप से मूल श्रेणियों को 2-पूरक श्रेणियों में बदल दिया है - ये सी मानक में निर्दिष्ट नहीं हैं।

— एंटिटी हापाला

@ कोडीअरे यह आगे और पीछे उतार-चढ़ाव कर रहा है, पिछले 3 वर्षों से 1 पूरक पूरक है और ओपी कुछ भी नहीं कह रहा है इसलिए मैंने एक संपादन को वापस कर दिया है जिसने इसे "फिक्स रेंज" के साथ 2 के पूरक में बदल दिया है, क्योंकि यह कहता है कि आप मज़बूती से मान सकते हैं " , जो अभी भी बिल्कुल सच नहीं है।

— एंटी हापला

Answer 5

C के 2 बाइट्स या 4 बाइट्स में एक इंटेगर वेरिएबल होता है?

यह आपके द्वारा उपयोग किए जा रहे प्लेटफ़ॉर्म पर निर्भर करता है, साथ ही साथ आपके कंपाइलर को कैसे कॉन्फ़िगर किया गया है। एकमात्र आधिकारिक उत्तर sizeofऑपरेटर को यह देखने के लिए उपयोग करना है कि आपकी विशिष्ट स्थिति में एक पूर्णांक कितना बड़ा है।

---

वे कौन से कारक हैं जो इस पर निर्भर करते हैं?

रेंज को आकार के बजाय सबसे अच्छा माना जा सकता है । दोनों व्यवहार में अलग-अलग होंगे, हालांकि यह आकार के अनुसार रेंज प्रकारों को चुनने के लिए बहुत अधिक मूर्ख-सबूत है जैसा कि हम देखेंगे। यह भी ध्यान रखना महत्वपूर्ण है कि मानक हमें आकार के बजाय सीमा के आधार पर हमारे पूर्णांक प्रकारों को चुनने पर विचार करने के लिए प्रोत्साहित करता है , लेकिन अब हम मानक अभ्यास की उपेक्षा करते हैं , और हमारी जिज्ञासा का पता लगाने , बाइट्स और पूर्णांक प्रतिनिधित्व करते हैं ... चलो नीचे फेंक देते हैं खरगोश छेद और इसे अपने लिए देखें ...sizeofCHAR_BIT

---

sizeofबाइट्स और CHAR_BIT

सी मानक (ऊपर से जुड़ा हुआ) से लिया गया निम्न कथन, इस शब्दों में वर्णन करता है कि मुझे नहीं लगता कि इसमें सुधार किया जा सकता है।

sizeofऑपरेटर अपनी संकार्य के आकार (बाइट्स में) है, जो एक अभिव्यक्ति या एक प्रकार की parenthesized नाम हो सकता है अर्जित करता है। आकार ऑपरेंड के प्रकार से निर्धारित होता है।

स्पष्ट समझ के अनुसार हमें बाइट्स के बारे में चर्चा करनी होगी । यह आमतौर पर माना जाता है कि एक बाइट आठ बिट्स है, जब वास्तव में CHAR_BITआपको बताता है कि एक बाइट में कितने बिट्स हैं । यह उन बारीकियों में से केवल एक है जो आम दो (या चार) बाइट पूर्णांक के बारे में बात करते समय नहीं माना जाता है ।

आइए अब तक चीजों को लपेटें:

• sizeof => बाइट्स में आकार, और
• CHAR_BIT => बाइट में बिट्स की संख्या

इस प्रकार, आपके सिस्टम के आधार पर, शून्य से अधिक कोई भी मान sizeof (unsigned int)हो सकता है (केवल 2 या 4 नहीं), जैसे कि 16 है, तो एक एकल (सोलह-बिट) बाइट में पर्याप्त बिट्स होते हैं जो सोलह बिट पूर्णांक द्वारा वर्णित का प्रतिनिधित्व करते हैं। मानकों (नीचे उद्धृत) यह जरूरी जानकारी नहीं है, यह है? चलो गहरी तल्लीन ...CHAR_BIT

---

पूर्णांक प्रतिनिधित्व

C मानक यहाँ सभी मानक पूर्णांक प्रकारों (और CHAR_BIT, भी, fwiw) के लिए न्यूनतम परिशुद्धता / श्रेणी निर्दिष्ट करता है । इस से, हम एक न्यूनतम प्राप्त कर सकते हैं कि मूल्य को संग्रहीत करने के लिए कितने बिट्स की आवश्यकता होती है , लेकिन हम बस श्रेणियों के आधार पर हमारे चर का चयन कर सकते हैं । बहरहाल, इस उत्तर के लिए आवश्यक विवरण का एक बड़ा हिस्सा यहां रहता है। उदाहरण के लिए, मानक unsigned intको कम से कम सोलह बिट्स भंडारण की आवश्यकता होती है:

UINT_MAX                                65535 // 2¹⁶ - 1

इस प्रकार हम देख सकते हैं कि कम से कमunsigned int ( 16) बिट्स की आवश्यकता है , जो कि आपको दो बाइट्स मिलती है (मान लिया गया है CHAR_BITकि 8 है) ... और बाद में जब यह सीमा बढ़ गई 2³² - 1, तो लोग इसके बजाय 4 बाइट्स बता रहे थे। यह आपके द्वारा देखी गई घटनाओं की व्याख्या करता है:

अधिकांश पाठ्यपुस्तकों का कहना है कि पूर्णांक चर 2 बाइट्स हैं। लेकिन जब मैं पूर्णांकों की एक सरणी के क्रमिक पतों को प्रिंट करने वाला कार्यक्रम चलाता हूं तो यह 4 के अंतर को दर्शाता है।

आप एक प्राचीन पाठ्यपुस्तक और संकलक का उपयोग कर रहे हैं जो आपको गैर-पोर्टेबल सी सिखा रहा है; लेखक, जिसने आपकी पाठ्यपुस्तक लिखी हो, को भी इसकी जानकारी नहीं होगी CHAR_BIT। आपको अपनी पाठ्यपुस्तक (और संकलक) को अपग्रेड करना चाहिए , और यह याद रखने का प्रयास करना चाहिए कि आईटी एक हमेशा विकसित क्षेत्र है जिसे प्रतिस्पर्धा करने के लिए आपको आगे रहने की आवश्यकता है ... इसके बारे में पर्याप्त है, हालांकि; आइए देखते हैं कि अन्य गैर-पोर्टेबल रहस्य उन अंतर्निहित पूर्णांक बाइट्स स्टोर क्या हैं ...

मूल्य बिट्स हैं जो आम गलतफहमी की गिनती के लिए दिखाई देते हैं। उपरोक्त उदाहरण एक unsignedपूर्णांक प्रकार का उपयोग करता है जिसमें आम तौर पर केवल मूल्य बिट्स होते हैं, इसलिए विस्तार में शैतान को याद करना आसान होता है।

साइन बिट्स ... उपरोक्त उदाहरण में मैंने UINT_MAXऊपरी सीमा के रूप में उद्धृत किया unsigned intक्योंकि यह 16टिप्पणी से मूल्य निकालने के लिए एक मामूली उदाहरण है । हस्ताक्षरित प्रकारों के लिए, सकारात्मक और नकारात्मक मूल्यों (जो कि संकेत है) के बीच अंतर करने के लिए, हमें साइन बिट को भी शामिल करना होगा।

INT_MIN                                -32768 // -(2¹⁵)
INT_MAX                                +32767 // 2¹⁵ - 1

पैडिंग बिट्स ... जबकि पूर्णांक में बिट्स वाले कंप्यूटरों का सामना करना आम नहीं है, तो C मानक ऐसा करने की अनुमति देता है; कुछ मशीनें (यानी यह एक ) दो छोटे (हस्ताक्षरित) पूर्णांक मानों को एक साथ जोड़कर बड़े पूर्णांक प्रकारों को लागू करती हैं ... और जब आप हस्ताक्षर किए गए पूर्णांकों को जोड़ते हैं, तो आपको एक व्यर्थ साइन बिट मिलता है। उस व्यर्थ बिट को सी में पैडिंग माना जाता है। पैडिंग बिट्स के अन्य उदाहरणों में समता बिट्स और ट्रैप बिट्स शामिल हो सकते हैं ।

---

जैसा कि आप देख सकते हैं, मानक पूर्णांक प्रकारों का चयन करते समय मानक जैसे मानकINT_MIN .. INT_MAXऔर अन्य न्यूनतम / अधिकतम मानों को प्रोत्साहित करने के लिए लगता है , और आकार पर निर्भर होने वाले हतोत्साहित करते हैं क्योंकि अन्य सूक्ष्म कारकों को भूल जाने की संभावना है जैसे कि CHAR_BITऔर पैडिंग बिट्स जो मूल्य को प्रभावित कर सकता है sizeof (int)(यानी दो-बाइट और चार-बाइट पूर्णांकों की आम गलतफहमी इन विवरणों की उपेक्षा करती है)।

Answer 6

C99 N1256 मानक ड्राफ्ट

http://www.open-std.org/JTC1/SC22/WG14/www/docs/n1256.pdf

के आकार intऔर अन्य सभी पूर्णांक प्रकार के कार्यान्वयन को परिभाषित किया गया है, C99 केवल निर्दिष्ट करता है:

• न्यूनतम आकार की गारंटी
• प्रकारों के बीच सापेक्ष आकार

5.2.4.2.1 "पूर्णांक प्रकारों का आकार <limits.h>" न्यूनतम आकार देता है:

1 [...] उनके कार्यान्वयन-परिभाषित मूल्य दिखाए गए लोगों के लिए परिमाण (निरपेक्ष मूल्य) के बराबर या अधिक होंगे [...]

• UCHAR_MAX 255 // 2 8 - 1
• USHRT_MAX 65535 // 2 16 - 1
• UINT_MAX 65535 // 2 16 - 1
• ULONG_MAX 4294967295 // 2 32 - 1
• ULLONG_MAX 18446744073709551615 // 2 64 - 1

6.2.5 "प्रकार" तब कहते हैं:

8 किसी भी दो पूर्णांक प्रकारों के लिए समान हस्ताक्षर और अलग पूर्णांक रूपांतरण रैंक (देखें 6.3.1.1), छोटे पूर्णांक रूपांतरण रैंक के साथ प्रकार के मानों की श्रेणी अन्य प्रकार के मूल्यों की एक व्यवस्था है।

और 6.3.1.1 "बुलियन, वर्ण और पूर्णांक" सापेक्ष रूपांतरण रैंक निर्धारित करता है:

1 प्रत्येक पूर्णांक प्रकार में एक पूर्णांक रूपांतरण रैंक होता है जिसे निम्नानुसार परिभाषित किया जाता है:

• लंबे लंबे int की रैंक लंबी int की रैंक से अधिक होगी, जो int की रैंक से अधिक होगी, जो कि शॉर्ट इंट की रैंक से अधिक होगी, जो हस्ताक्षरित चार्ट की रैंक से अधिक होगी।
• किसी भी अहस्ताक्षरित पूर्णांक प्रकार की रैंक, यदि कोई हो, संबंधित हस्ताक्षरित पूर्णांक प्रकार के रैंक के बराबर होगी।
• सभी पूर्णांक प्रकारों के लिए T1, T2 और T3, यदि T1 की T2 से अधिक रैंक है और T2 की T3 से अधिक रैंक है, तो T1 की T3 से अधिक रैंक है

Answer 7

केवल गारंटी देता हैं कि charहोना चाहिए कम से कम 8 बिट विस्तृत, shortऔर intहोना चाहिए कम से कम 16 बिट विस्तृत, और longहोना चाहिए कम से कम 32 बिट विस्तृत, और कहा कि sizeof (char)<= sizeof (short)<= sizeof (int)<= sizeof (long)(एक ही उन प्रकार की अहस्ताक्षरित संस्करण के लिए सच है )।

int प्लेटफॉर्म के आधार पर 16 से 64 बिट्स चौड़ा हो सकता है।

Answer 8

C "int" 2 बाइट्स या 4 बाइट्स का आकार है?

उत्तर है "हाँ" / "नहीं" / "शायद" / "शायद नहीं"।

C प्रोग्रामिंग भाषा निम्नलिखित निर्दिष्ट करती है: सबसे छोटी पता योग्य इकाई, charजिसे "बाइट" भी कहा जाता है, जिसे वास्तव में CHAR_BITबिट्स चौड़ा कहा जाता है , जहां CHAR_BITकम से कम 8 है।

तो, सी में एक बाइट जरूरी एक ओकटेट नहीं है , यानी 8 बिट्स। सी कोड (और यूनिक्स) को चलाने के लिए पहले प्लेटफार्मों में से एक में 4-बाइट था int- लेकिन कुल intमें 36 बिट्स थे, क्योंकि CHAR_BIT9!

intउस प्लेटफ़ॉर्म के लिए प्राकृतिक पूर्णांक आकार माना जाता है जिसमें कम से कम-32767 ... 32767 रेंज हो । आप intप्लेटफ़ॉर्म बाइट्स का आकार प्राप्त कर सकते हैं sizeof(int); जब आप इस मूल्य को गुणा CHAR_BITकरेंगे तो आपको पता चलेगा कि यह बिट्स में कितना चौड़ा है।

---

जबकि 36-बिट मशीनें ज्यादातर मृत हैं, फिर भी गैर-8-बिट बाइट्स के साथ प्लेटफ़ॉर्म हैं। कल ही टेक्सास इंस्ट्रूमेंट्स MCU के बारे में 16-बिट बाइट्स के बारे में एक सवाल था , जिसमें C99, C11- कंपाइलर कंपाइलर है।

पर TMS320C28x ऐसा लगता है कि char, shortऔर intकर रहे हैं सभी 16 बिट विस्तृत, और इसलिए एक बाइट। long int2 बाइट्स है और long long int4 बाइट्स है। सी की सुंदरता यह है कि एक अभी भी इस तरह एक मंच के लिए एक कुशल कार्यक्रम लिख सकता है, और यहां तक ​​कि एक पोर्टेबल तरीके से भी कर सकता है!

Comments

"क्योंकि CHAR_BIT 9 था!" - वे 362880 बिट कंप्यूटिंग वापस तो था !? प्रभावशाली।

— जोश डेसमंड

Answer 9

ज्यादातर यह मंच आप यह प्रयोग कर रहे हैं पर निर्भर करता है compilers के अधिकांश में compiler.Nowadays को संकलक से निर्भर करता है पूर्णांक की है 4 बाइट । आप अपने संकलक आप उपयोग कर सकते हैं उपयोग कर रहा है जांच करना चाहते हैं sizeof(int)।

main()
{
    printf("%d",sizeof(int));
    printf("%d",sizeof(short));
    printf("%d",sizeof(long));
}

केवल एक चीज सी कंपाइलर वादा यह है कि शॉर्ट का साइज इंट के बराबर या उससे कम होना चाहिए और साइज का लॉन्ग के बराबर या उससे ज्यादा होना चाहिए। अगर इंट का साइज 4 है, तो शॉर्ट का साइज 2 या 4 हो सकता है, लेकिन बड़ा नहीं की तुलना में। लंबे और int के लिए सच है। यह भी कहता है कि छोटे और लंबे का आकार समान नहीं हो सकता है।

Comments

%dएक size_tपैरामीटर के लिए उपयोग करना यूबी है।

— पॉल आर

Answer 10

यह कार्यान्वयन पर निर्भर करता है, लेकिन आमतौर पर x86 पर और अन्य लोकप्रिय आर्किटेक्चर जैसे एआरएम int4 बाइट्स लेते हैं। आप हमेशा संकलन समय का उपयोग करके sizeof(int)या जो भी अन्य प्रकार आप जांचना चाहते हैं, उसकी जांच कर सकते हैं।

यदि आप यह सुनिश्चित करना चाहते हैं कि आप एक विशिष्ट आकार का उपयोग करें, तो इन प्रकारों का उपयोग करें <stdint.h>

Answer 11

#include <stdio.h>

int main(void) {
    printf("size of int: %d", (int)sizeof(int));
    return 0;
}

यह 4 रिटर्न देता है, लेकिन यह शायद मशीन पर निर्भर है।

Answer 12

C "int" 2 बाइट्स या 4 बाइट्स का आकार है?

C के 2 बाइट्स या 4 बाइट्स में एक इंटेगर वेरिएबल होता है?

सी "बाइट्स" को "बाइट" प्रति 8 बिट्स के अलावा कुछ और होने देता है।

CHAR_BIT सबसे छोटी वस्तु के लिए बिट्स की संख्या जो बिट-फ़ील्ड नहीं है (बाइट) C11dr .25.2.4.2.2.1

8 से अधिक किसी वस्तु का मान असामान्य रूप से बढ़ रहा है। अधिकतम पोर्टेबिलिटी के लिए, CHAR_BIT8. के ​​बजाय का उपयोग करें । C intमें बिट्स का आकार है sizeof(int) * CHAR_BIT।

#include <limits.h>
printf("(int) Bit size %zu\n", sizeof(int) * CHAR_BIT);

---

वे कौन से कारक हैं जो इस पर निर्भर करते हैं?

intबिट आकार आमतौर पर 32 या 16 बिट है। सी निर्दिष्ट न्यूनतम रेंज :

एक प्रकार की वस्तु के लिए न्यूनतम मूल्य int INT_MIN-32767 प्रकार की वस्तु के
लिए अधिकतम मूल्य int INT_MAX+32767
C11dr .25.2.4.4.1 1

न्यूनतम सीमा के लिए intबलों सा आकार होने के लिए कम से कम 16 - भले ही प्रोसेसर था "8 बिट"। विशेष प्रोसेसर में 64 बिट्स जैसा आकार देखा जाता है। अन्य मूल्य जैसे 18, 24, 36 इत्यादि ऐतिहासिक प्लेटफार्मों पर हुए हैं या कम से कम सैद्धांतिक रूप से संभव हैं। आधुनिक कोडिंग शायद ही कभी गैर-शक्ति-2 intबिट आकारों के बारे में चिंता करता है ।

कंप्यूटर का प्रोसेसर और आर्किटेक्चर intबिट साइज सिलेक्शन को ड्राइव करता है ।

64-बिट प्रोसेसर के साथ भी, कम्पाइलर का intआकार संगतता कारणों से 32-बिट हो सकता है क्योंकि बड़े कोड बेस int32-बिट (या 32/16) पर निर्भर करते हैं ।

Answer 13

इस प्रश्न का उत्तर देने के लिए यह एक अच्छा स्रोत है।

लेकिन यह सवाल एक तरह का सत्य है जिसका उत्तर "हां। दोनों।"

यह आपकी वास्तुकला पर निर्भर करता है। यदि आप 16-बिट मशीन या उससे कम पर काम करने जा रहे हैं, तो यह 4 बाइट (= 32 बिट) नहीं हो सकता है। यदि आप 32-बिट या बेहतर मशीन पर काम कर रहे हैं, तो इसकी लंबाई 32-बिट है।

यह पता लगाने के लिए, आप कुछ पठनीय आउटपुट करने के लिए प्रोग्राम तैयार करें और "आकार" फ़ंक्शन का उपयोग करें। यह आपके घोषित डेटाटाइप के बाइट्स में आकार देता है। लेकिन सरणियों के साथ इसका उपयोग करके कैरिफुल बनें।

यदि आप घोषणा कर रहे हैं तो int t[12];यह 12 * 4 बाइट लौटाएगा। इस सरणी की लंबाई पाने के लिए, बस का उपयोग करें sizeof(t)/sizeof(t[0])। यदि आप एक फ़ंक्शन का निर्माण करने जा रहे हैं, तो यह एक भेजने वाले सरणी के आकार की गणना करना चाहिए, याद रखें कि यदि

typedef int array[12];
int function(array t){
    int size_of_t = sizeof(t)/sizeof(t[0]);
    return size_of_t;
}
void main(){
    array t = {1,1,1};  //remember: t= [1,1,1,0,...,0]
    int a = function(t);    //remember: sending t is just a pointer and equal to int* t
   print(a);   // output will be 1, since t will be interpreted as an int itselve. 
}

तो यह भी कुछ अलग नहीं लौटेगा। यदि आप एक सरणी को परिभाषित करते हैं और बाद में लंबाई प्राप्त करने का प्रयास करते हैं, तो आकार का उपयोग करें। यदि आप किसी फ़ंक्शन में एक सरणी भेजते हैं, तो याद रखें कि भेजने का मूल्य पहले तत्व पर सिर्फ एक संकेतक है। लेकिन एक मामले में, आप हमेशा जानते हैं कि आपके सरणी का आकार क्या है। केस दो को दो कार्यों को परिभाषित करके और कुछ प्रदर्शन से चूक सकते हैं। फ़ंक्शन (सरणी t) को परिभाषित करें और function2 (array t, int size_of_t) को परिभाषित करें। कॉल "फ़ंक्शन (टी)" कुछ कॉपी-कार्य द्वारा लंबाई को मापता है और फ़ंक्शन 2 को परिणाम भेजता है, जहां आप चर सरणी-आकारों पर जो चाहें कर सकते हैं।

Comments

लिंक प्रदान की गई जानकारी का एक बुरा स्रोत है क्योंकि यह उन चीजों को मानता है जो हमेशा सच नहीं होती हैं (जैसे charहमेशा होती है signed)

— आंद्रेई डेमियन-फ़ेकेटी