C++ में int और long में कितने बाइट होते हैं? मानक अप्रत्याशित उत्तर देता है

आकारों की पहेली: क्यों int और long विभिन्न कंपाइलरों पर अलग-अलग व्यवहार करते हैं?

जिसने भी गंभीरता से C++ का अध्ययन किया है, वह देर-सबेर इस पहेली का सामना करता है। आप एक सरल कोड लिखते हैं:

#include <iostream>\n\nint main() {\n    std::cout << "int का आकार: " << sizeof(int) << " बाइट\\n";\n    std::cout << "long का आकार: " << sizeof(long) << " बाइट\\n";\n    std::cout << "long long का आकार: " << sizeof(long long) << " बाइट\\n";\n    return 0;\n}

इसे अपने लैपटॉप पर चलाएँ — आपको 4, 4, 8 मिलता है। Linux सर्वर पर चलाएँ — 4, 8, 8। और पुराने 16-बिट सिस्टम पर (हाँ, ऐसे अभी भी जीवित हैं!) — 2, 4, 8। क्या चाल है? C++, एक भाषा जो अपनी शक्ति और नियंत्रण के लिए प्रसिद्ध है, ऐसी अनिश्चितता क्यों स्वीकार करती है?

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

आइए समझें कि C++ मानक (C++98 से C++23 तक) वास्तव में क्या गारंटी देता है और प्लेटफ़ॉर्म निर्भरता के जाल में कैसे न फँसें।

C++ मानक क्या गारंटी देता है? न्यूनतम आकार और पदानुक्रम

"int 4 बाइट है" कहने के बजाय, मानक न्यूनतम मान श्रेणियाँ और आकारों का सख्त पदानुक्रम स्थापित करता है। मानक ड्राफ्ट (अनुभाग [basic.fundamental]) से मुख्य नियम यहाँ दिए गए हैं:

\n
• char का न्यूनतम आकार: 1 बाइट (8 बिट, हालाँकि औपचारिक रूप से C++ में बाइट इससे बड़ा भी हो सकता है)।
\n
• आकारों का पदानुक्रम: sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long)।
\n
• न्यूनतम बिट्स:\n
  \n
  • short: कम से कम 16 बिट।
  \n
  • int: कम से कम 16 बिट।
  \n
  • long: कम से कम 32 बिट।
  \n
  • long long: कम से कम 64 बिट (C++11 में जोड़ा गया)।
  \n
  \n
\n
• int का आकार: मानक अनुशंसा करता है कि int का लक्ष्य आर्किटेक्चर के लिए "प्राकृतिक आकार" हो (आमतौर पर 32/64-बिट सिस्टम पर 4 बाइट)।
\n

ध्यान दें: long, int (32-बिट Windows पर) या long long (64-बिट Linux पर) के बराबर हो सकता है। यह पूरी तरह से कानूनी है!

व्यावहारिक उदाहरण: अपने सिस्टम पर जाँच करें

इस कोड को चलाएँ और परिणामों की तुलना विभिन्न OS के सहकर्मियों से करें:

#include <iostream>\n#include <climits> // INT_MAX, LONG_MAX आदि के लिए\n\nint main() {\n    std::cout << "बाइट्स में आकार:\\n";\n    std::cout << "short: " << sizeof(short) << "\\n";\n    std::cout << "int: " << sizeof(int) << "\\n";\n    std::cout << "long: " << sizeof(long) << "\\n";\n    std::cout << "long long: " << sizeof(long long) << "\\n\\n";\n\n    std::cout << "अधिकतम मान:\\n";\n    std::cout << "INT_MAX: " << INT_MAX << "\\n";\n    std::cout << "LONG_MAX: " << LONG_MAX << "\\n";\n    std::cout << "LLONG_MAX: " << LLONG_MAX << "\\n";\n    return 0;\n}

आप देखेंगे कि Windows (MSVC) पर long अक्सर 4 बाइट के बराबर होता है, जबकि Linux (GCC/Clang) पर 8 बाइट के बराबर होता है। प्लेटफार्मों के बीच कोड स्थानांतरित करते समय यह बग का एक क्लासिक स्रोत है।

मानक आकार तय क्यों नहीं करता? ऐतिहासिक संदर्भ

1970 के दशक की कल्पना करें। प्रोसेसर 8-बिट, 16-बिट थे, और 32-बिट अभी उभर रहे थे। C के निर्माता (और