C++ में size_t और int में क्या अंतर है?

मुख्य अंतर

यदि हम मानक पर विचार करें, तो दोनों 16-बिट आकार के इंटीजर्स हैं। लेकिन वास्तविक कार्यान्वयन में महत्वपूर्ण अंतर हैं:

1. साइन्डनेस (Signedness)

• int साइन्ड है (ऋणात्मक मान संभाल सकता है)
• size_t अनसाइन्ड है (केवल गैर-ऋणात्मक मान)

2. आकार आर्किटेक्चर पर निर्भर करता है

एक विशिष्ट 64-बिट सिस्टम पर, size_t 64-बिट होगा, लेकिन unsigned int 32-बिट होगा। इसलिए हम उन्हें परस्पर विनिमय नहीं कर सकते।

3. मानक अनुशंसा

एक मानक अनुशंसा है कि size_t अधिकतम unsigned long जितना बड़ा हो। इसलिए आप सोच सकते हैं कि हम size_t के स्थान पर unsigned long का उपयोग कर सकते हैं, लेकिन 64-बिट सिस्टम पर, यदि OS विंडोज है, तो unsigned long 32-बिट का होगा, लेकिन size_t 64-बिट का होगा।

4. उद्देश्य

• size_t: ऑब्जेक्ट्स के आकार और सरणी इंडेक्सिंग के लिए डिज़ाइन किया गया (sizeof ऑपरेटर का परिणाम)
• int: सामान्य प्रयोजन साइन्ड इंटीजर

व्यावहारिक प्रभाव

लूप इंडेक्सिंग

// संभावित चेतावनी: signed/unsigned mismatch
for (int i = 0; i < vector.size(); ++i) { ... }

// बेहतर: size_t का उपयोग करें
for (size_t i = 0; i < vector.size(); ++i) { ... }

// या C++11 रेंज-बेस्ड फॉर लूप
for (auto& elem : vector) { ... }

फंक्शन पैरामीटर्स

// खराब: int आकार को सीमित करता है
void process(int size) { ... }

// बेहतर: size_t पूर्ण रेंज की अनुमति देता है
void process(size_t size) { ... }

पॉइंटर अंकगणित

// ptrdiff_t पॉइंटर अंतर के लिए सही टाइप है
ptrdiff_t diff = ptr2 - ptr1;  // ptrdiff_t साइन्ड है
size_t dist = ptr2 - ptr1;     // केवल तभी जब ptr2 >= ptr1

सर्वोत्तम अभ्यास

• कंटेनर साइज़, इंडेक्सिंग और sizeof परिणामों के लिए size_t का उपयोग करें
• सामान्य गणना के लिए int का उपयोग करें जहां ऋणात्मक मान समझ में आते हैं
• दोनों के बीच मिश्रण से बचें; यदि आवश्यक हो तो एक्सप्लिसिट कास्ट करें
• पॉइंटर अंतर के लिए ptrdiff_t का उपयोग करें
• फिक्स्ड-विड्थ आवश्यकताओं के लिए <cstdint> टाइप्स (int32_t, uint64_t, आदि) पर विचार करें