C ++ में int और long के बीच क्या अंतर है?


120

अगर मैं ग़लत हूं तो मेरी गलती सुझाएं,

int 4 बाइट्स है, जिसमें मानों की श्रेणी -2,147,483,648 से 2,147,483,647 (2 ^ 31)
लंबी है, 4 बाइट्स है, जिसमें मानों की श्रेणी -2,147,483,648 से 2,147,483,647 (2 ^ 31) है।

C ++ में क्या अंतर है? क्या उनका परस्पर उपयोग किया जा सकता है?


32 बिट प्रोसेसर पर चलने वाले मेरे वीएस 200 में, इंट का डिफ़ॉल्ट आकार 4 बाइट्स है।


यदि आप पोर्टेबल कोड लिखना चाहते हैं, #include <stdint.h>तो उपयोग करने पर विचार करें और फिर प्रकार जो आकार बताते हैं। जैसे uint32_t। एक नए प्लेटफ़ॉर्म पर, फिर आपको केवल यह सुनिश्चित करने की आवश्यकता है कि यह उस विशेष प्लेटफ़ॉर्म के लिए सही हो जाए और आपका कोड इच्छित तरीके से काम करे।
BitTickler

जवाबों:


112

यह कार्यान्वयन पर निर्भर है।

उदाहरण के लिए, विंडोज के तहत वे समान हैं, लेकिन उदाहरण के लिए अल्फा सिस्टम पर एक लंबा 64 बिट्स था जबकि एक इंट 32 बिट्स था। यह आलेख वैरिएबल प्लेटफ़ॉर्म पर Intel C ++ कंपाइलर के नियमों को कवर करता है। संक्षेप में:

  OS           arch           size
Windows       IA-32        4 bytes
Windows       Intel 64     4 bytes
Windows       IA-64        4 bytes
Linux         IA-32        4 bytes
Linux         Intel 64     8 bytes
Linux         IA-64        8 bytes
Mac OS X      IA-32        4 bytes
Mac OS X      Intel 64     8 bytes  

मुझे लगता है कि हमें C ++ मानक के बारे में नीचे दिए गए कुछ विवरणों के साथ इस उत्तर (उदाहरण के लिए एक उत्तर) के संयोजन पर विचार करना चाहिए। C ++ 0x का मसौदा खुले-std.org/JTC1/SC22/WG21/docs/papers/2008/n2798.pdf पर है और इसे चिह्नित किया गया है ताकि आप इसके और अंतिम संशोधन के बीच अंतर देख सकें।
पैट्रिक जॉम्नेयर

प्रकारों की पैदावार के आकार-प्रकार के क्रम पर कुछ शामिल करने से विभिन्न प्लेटफार्मों के लिए आकार की गणना की तुलना में अधिक जानकारी प्राप्त होती है - जैसे @ केविन राज्यों में इतनी अच्छी तरह से। (-1vote)
xtofl

2
कुछ संकलक में भी झंडे होते हैं जो आपको int और long के डिफ़ॉल्ट आकार को संशोधित करने की अनुमति देते हैं अर्थात उन्हें 8 या 16 आदि के लिए बाध्य करते हैं। विवरण के लिए आप संकलक प्रलेखन देखें।
मार्टिन यॉर्क

7
NB कि ये लंबे समय
रेजरपैक

1
कृपया int के आकार को भी शामिल करें।
सीगप्रकाश

82

आपके पास एकमात्र गारंटी है:

sizeof(char) == 1
sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)

// FROM @KTC. The C++ standard also has:
sizeof(signed char)   == 1
sizeof(unsigned char) == 1

// NOTE: These size are not specified explicitly in the standard.
//       They are implied by the minimum/maximum values that MUST be supported
//       for the type. These limits are defined in limits.h
sizeof(short)     * CHAR_BIT >= 16
sizeof(int)       * CHAR_BIT >= 16
sizeof(long)      * CHAR_BIT >= 32
sizeof(long long) * CHAR_BIT >= 64
CHAR_BIT         >= 8   // Number of bits in a byte

यह भी देखें: क्या longकम से कम 32 बिट्स होने की गारंटी है?


1
हम्म, यह धारण नहीं करता है, अगर आकार (छोटा)> = आकार (चार) हम केवल उस आकार (लघु)> = 1 (नहीं> = 2) को जानते हैं, जो कि सभी प्रकार के लिए जाता है। इस आकार के अनुसार (किसी भी अभिन्न प्रकार)> = 1. जो सच है, उदाहरण के लिए मुझे Z80 पर आकार (int) == 1 याद है, लेकिन क्या लंबे समय तक इसकी कोई मजबूत गारंटी नहीं है?
एंड्रियास मैग्नेसन

6
C ++ मानक का 3.9.1.2 निर्दिष्ट करता है कि आकार (लंबा)> = आकार (इंट)> = आकार (छोटा)> = आकार (चार) सी ++ का 5.3.3.1 मानक निर्दिष्ट करते हैं कि आकार (चार), आकार (अनिश्चित चार) , और आकारोफ़ (हस्ताक्षरित चार) 1 के बराबर है (कॉन्टेस्ट ...)
केटीसी

4
(... cont) अभिन्न प्रकारों के द्वारा दर्शाए जाने वाले अधिकतम और न्यूनतम मान को <सीमाएँ .h> (और इसलिए <जलवायु>) में मैक्रो के रूप में परिभाषित किया गया है। C (1990) मानक के अनुलग्नक E, जो C ++ मानक के संदर्भ द्वारा शामिल किए गए हैं, इन मैक्रो के न्यूनतम परिमाण को निर्दिष्ट करते हैं। (cont ...)
KTC

4
(... प्रतियोगिता) और वे हैं (2 ^ 15) -1, (2 ^ 15) -1, (2 ^ 31) -1, क्रमशः लघु, अंतर और लंबे समय के लिए, जो मान के रूप में कार्य करता है मार्टिन ने अपनी प्रतिक्रिया में यहां पोस्ट किया अगर CHAR_BIT 8 (जो इसका न्यूनतम मूल्य भी है)।
KTC

2
@ गिल्स: क्या ऐसा नहीं है जो मैंने ऊपर कहा है? sizeof (छोटा) * CHAR_BITS> = 16. कुछ अन्य चीजों पर ध्यान दें। :-)
मार्टिन यॉर्क

13

X64 के लिए संकलन करते समय, int और long के बीच का अंतर कहीं 0 और 4 बाइट्स के बीच होता है, यह इस बात पर निर्भर करता है कि आप किस कंपाइलर का उपयोग करते हैं।

जीसीसी एलपी 64 मॉडल का उपयोग करता है, जिसका अर्थ है कि इनट्स 32-बिट हैं, लेकिन लोंग 64-बिट मोड के तहत 64-बिट हैं।

उदाहरण के लिए MSVC LLP64 मॉडल का उपयोग करता है, जिसका अर्थ है कि 64-बिट मोड में भी इनट्स और लोंग दोनों 32-बिट हैं।


संभवतः 0 बाइट्स? हम्म
rogerdpack

12

सी ++ ही विनिर्देश (पुराना संस्करण है, लेकिन इस के लिए काफी अच्छा) इस खुला छोड़ देता है।

चार हस्ताक्षरित पूर्णांक प्रकार हैं: ' signed char', ' short int', ' int', और ' long int'। इस सूची में, प्रत्येक प्रकार कम से कम उतना भंडारण प्रदान करता है जितना कि सूची में आने से पहले। प्लेन इन्ट्स के पास निष्पादन पर्यावरण की वास्तुकला द्वारा सुझाए गए प्राकृतिक आकार हैं *;

[फुटनोट: अर्थात, INT_MIN और INT_MAX की श्रेणी में कोई भी मान सम्‍मिलित करने के लिए काफी बड़ा है, जैसा कि शीर्ष लेख में परिभाषित किया गया है <climits>। --- अंतिम फ़ूनोट]


7

जैसा कि केविन हैन्स बताते हैं, इन्टस का निष्पादन आकार द्वारा सुझाया गया प्राकृतिक आकार है, जिसे INT_MIN और INT_MAX में फिट होना है।

C89 मानक बताता है कि UINT_MAXकम से कम 2 ^ 16-1, USHRT_MAX2 ^ 16-1 और ULONG_MAX2 ^ 32-1 होना चाहिए। यह लघु और अंतर के लिए कम से कम 16 की एक बिट-गिनती बनाता है, और लंबे समय तक 32। चार के लिए यह स्पष्ट रूप से कहा गया है कि इसमें कम से कम 8 बिट्स ( CHAR_BIT) होना चाहिए । C ++ उन नियमों को इनहेरिट करता है। लिमिट फ़ाइल के लिए, इसलिए C ++ में हमारे पास उन मूल्यों के लिए समान मूलभूत आवश्यकताएं हैं। हालाँकि आपको इस बात से व्युत्पन्न नहीं होना चाहिए कि इंट कम से कम 2 बाइट है। सैद्धांतिक रूप से, चार, इंट और लंबे सभी 1 बाइट हो सकते हैं, जिस स्थिति CHAR_BITमें कम से कम 32 होना चाहिए। बस याद रखें कि "बाइट" हमेशा एक चार के आकार का होता है, इसलिए यदि चार बड़ा है, तो एक बाइट केवल 8 बिट्स नहीं है अधिक।


मुझे नहीं लगता था कि byteC ++ में डेटा प्रकार मौजूद है। यह नहीं है, यह करता है? यदि यह करता है, और byte8 बिट्स की तुलना में अन्य आकार हो सकते हैं, तो यह केवल विशुद्ध रूप से बेवकूफ है। वे इसे एक बाइट क्यों कहेंगे जब तक कि यह जरूरी नहीं कि 8 बिट्स हो?
अग्रनाथ

6

यह आपके कंपाइलर पर निर्भर करता है। आपको गारंटी दी जाती है कि एक इंट के रूप में कम से कम एक बड़ा होगा, लेकिन आपको गारंटी नहीं है कि यह अब होगा।


5

अधिकांश भाग के लिए, बाइट्स की संख्या और मूल्यों की सीमा सीपीयू की वास्तुकला द्वारा निर्धारित की जाती है न कि सी ++ द्वारा। हालाँकि, C ++ न्यूनतम आवश्यकताओं को निर्धारित करता है, जिसे litb ने ठीक से समझाया और मार्टिन यॉर्क ने केवल कुछ गलतियाँ कीं।

कारण यह है कि आप इंट और लंबे समय तक एक दूसरे का उपयोग नहीं कर सकते हैं क्योंकि वे हमेशा एक ही लंबाई के नहीं होते हैं। C का आविष्कार एक PDP-11 पर किया गया था, जहां एक बाइट में 8 बिट्स थे, int दो बाइट्स थे और सीधे हार्डवेयर निर्देशों द्वारा नियंत्रित किए जा सकते थे। चूंकि सी प्रोग्रामर को अक्सर चार-बाइट अंकगणित की आवश्यकता होती है, इसलिए लंबे समय तक आविष्कार किया गया था और यह चार बाइट्स था, पुस्तकालय कार्यों द्वारा नियंत्रित किया गया था। अन्य मशीनों में अलग-अलग विनिर्देश थे। सी मानक ने कुछ न्यूनतम आवश्यकताओं को लगाया।


5

संकलक प्रकार के आकारों के कंपाइलर विक्रेता के कार्यान्वयन पर भरोसा करना, यदि आप कभी भी किसी अन्य मशीन आर्किटेक्चर, ओएस, या किसी अन्य विक्रेता के कंपाइलर पर अपना कोड संकलित करते हैं, तो आपको वापस आना होगा।

अधिकांश कंपाइलर विक्रेता एक हेडर फ़ाइल प्रदान करते हैं जो कि खोज प्रकारों के साथ आदिम प्रकारों को परिभाषित करता है। इन आदिम प्रकारों का उपयोग तब किया जाना चाहिए जब कभी कोड को संभावित रूप से किसी अन्य संकलक के रूप में पोर्ट किया जा सकता है (इसे कभी भी उदाहरण के रूप में पढ़ें)। उदाहरण के लिए, अधिकांश UNIX संकलक हैं int8_t uint8_t int16_t int32_t uint32_t। Microsoft के पास है INT8 UINT8 INT16 UINT16 INT32 UINT32। मैं बोरलैंड / कोडगियर पसंद करता हूं int8 uint8 int16 uint16 int32 uint32। ये नाम इच्छित मान के आकार / श्रेणी का थोड़ा अनुस्मारक भी देते हैं।

वर्षों से मैंने बोरलैंड के स्पष्ट आदिम प्रकार के नामों और #includeनिम्न C / C ++ हेडर फ़ाइल (primitive.h) का उपयोग किया है, जिसका उद्देश्य किसी भी C / C ++ कंपाइलर के लिए इन नामों के साथ स्पष्ट आदिम प्रकारों को परिभाषित करना है (यह हेडर फ़ाइल वास्तव में प्रत्येक के लिए नहीं हो सकती है संकलक लेकिन इसमें विंडोज, यूनिक्स और लिनक्स पर उपयोग किए जाने वाले कई संकलक शामिल हैं, यह 64 बिट प्रकारों को परिभाषित (अभी तक) नहीं करता है।

#ifndef primitiveH
#define primitiveH
// Header file primitive.h
// Primitive types
// For C and/or C++
// This header file is intended to define a set of primitive types
// that will always be the same number bytes on any operating operating systems
// and/or for several popular C/C++ compiler vendors.
// Currently the type definitions cover:
// Windows (16 or 32 bit)
// Linux
// UNIX (HP/US, Solaris)
// And the following compiler vendors
// Microsoft, Borland/Imprise/CodeGear, SunStudio,  HP/UX
// (maybe GNU C/C++)
// This does not currently include 64bit primitives.
#define float64 double
#define float32 float
// Some old C++ compilers didn't have bool type
// If your compiler does not have bool then add   emulate_bool
// to your command line -D option or defined macros.
#ifdef emulate_bool
#   ifdef TVISION
#     define bool int
#     define true 1
#     define false 0
#   else
#     ifdef __BCPLUSPLUS__
      //BC++ bool type not available until 5.0
#        define BI_NO_BOOL
#        include <classlib/defs.h>
#     else
#        define bool int
#        define true 1
#        define false 0
#     endif
#  endif
#endif
#ifdef __BCPLUSPLUS__
#  include <systypes.h>
#else
#  ifdef unix
#     ifdef hpux
#        include <sys/_inttypes.h>
#     endif
#     ifdef sun
#        include <sys/int_types.h>
#     endif
#     ifdef linux
#        include <idna.h>
#     endif
#     define int8 int8_t
#     define uint8 uint8_t
#     define int16 int16_t
#     define int32 int32_t
#     define uint16 uint16_t
#     define uint32 uint32_t
#  else
#     ifdef  _MSC_VER
#        include <BaseTSD.h>
#        define int8 INT8
#        define uint8 UINT8
#        define int16 INT16
#        define int32 INT32
#        define uint16 UINT16
#        define uint32 UINT32
#     else
#        ifndef OWL6
//          OWL version 6 already defines these types
#           define int8 char
#           define uint8 unsigned char
#           ifdef __WIN32_
#              define int16 short int
#              define int32 long
#              define uint16 unsigned short int
#              define uint32 unsigned long
#           else
#              define int16 int
#              define int32 long
#              define uint16 unsigned int
#              define uint32 unsigned long
#           endif
#        endif
#      endif
#  endif
#endif
typedef int8   sint8;
typedef int16  sint16;
typedef int32  sint32;
typedef uint8  nat8;
typedef uint16 nat16;
typedef uint32 nat32;
typedef const char * cASCIIz;    // constant null terminated char array
typedef char *       ASCIIz;     // null terminated char array
#endif
//primitive.h

C99 यह कहता है कि टाइप-डी जो कि int32_t, uint64_t, आदि की तरह दिखते हैं, कंपाइलर द्वारा परिभाषित किए गए हैं और जैसा कि नाम से पता चलता है, ठीक वैसे ही कई बिट्स हैं। अधिकांश सी ++ कंपाइलर (जी ++ सहित) आपको सी + + कोड में इन स्थिरांक का उपयोग करने की अनुमति देगा।
rmeador 4

5

सी ++ स्टैंडर्ड इसे इस तरह कहते हैं:

3.9.1, .12:

पाँच हस्ताक्षरित पूर्णांक प्रकार हैं: "हस्ताक्षरित चार", "लघु int", "int", "long int", और "long long"। इस सूची में, प्रत्येक प्रकार कम से कम उतना भंडारण प्रदान करता है जितना कि सूची में पूर्ववर्ती। प्लेन इन्ट्स का निष्पादन आकार (44) की वास्तुकला द्वारा सुझाए गए प्राकृतिक आकार है; अन्य हस्ताक्षरित पूर्णांक प्रकार विशेष आवश्यकताओं को पूरा करने के लिए प्रदान किए जाते हैं।

(४४) जो कि, INT_MIN और INT_MAX की सीमा में किसी भी मान को सम्‍मिलित करने के लिए काफी बड़ा है, जैसा कि हेडर में परिभाषित किया गया है <climits>

निष्कर्ष: यह इस बात पर निर्भर करता है कि आप किस आर्किटेक्चर पर काम कर रहे हैं। कोई अन्य धारणा झूठी है।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.