C/C++ में पूर्णांक को फ्लोट में असाइन करना और तुलना

डेटा प्रकार

पूर्णांक को फ्लोट में असाइन करना

float f = 23;
unsigned int x = 23;
// दोनों 23 संग्रहीत करते हैं

f = 0xFFFFFFFF;  // 4,294,967,295
x = 0xFFFFFFFF;  // 4,294,967,295

// आउटपुट:
f = 4.29497e+09  // वैज्ञानिक संकेतन, परिशुद्धता हानि!
x = 4294967295   // सटीक मान

फ्लोट को पूर्णांक में असाइन करना

float f = 23.768;
unsigned int x = 23.768;

// आउटपुट:
f = 23.768
x = 23  // दशमलव भाग काट दिया गया!

तुलना व्यवहार

float f = 0xFFFFFFFF;  // 4.29497e+09
unsigned int x = 0xFFFFFFFF;  // 4294967295

if (f == x)
    printf("TRUE");  // प्रिंट होता है TRUE!
else
    printf("FALSE");

क्यों TRUE?

• तुलना में, unsigned int को float में प्रोमोट किया जाता है
• दोनों का आंतरिक प्रतिनिधित्व समान बिट पैटर्न बन जाता है
• हालांकि, फ्लोट में परिशुद्धता हानि होती है बड़े पूर्णांकों के लिए

खतरनाक तुलना उदाहरण

#include <stdio.h>

int main() {
    float f = 16777217.0f;  // 2^24 + 1
    int i = 16777217;
    
    printf("f = %.0f\n", f);   // 16777216 (परिशुद्धता हानि!)
    printf("i = %d\n", i);     // 16777217
    
    if (f == i)
        printf("बराबर (गलत!)\n");
    else
        printf("असमान (सही)\n");
    
    return 0;
}

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

1. फ्लोट और पूर्णांक की सीधी तुलना से बचें
2. तुलना के लिए ईप्सिलॉन का उपयोग करें: fabs(f - i) < 0.0001
3. बड़े पूर्णांकों के लिए double का उपयोग करें (53-बिट मंटिसा)
4. स्पष्ट कास्टिंग का उपयोग करें: (float)i या (int)f

IEEE 754 प्रतिनिधित्व

float (32-बिट):  1 साइन | 8 एक्सपोनेंट | 23 मंटिसा
double (64-बिट): 1 साइन | 11 एक्सपोनेंट | 52 मंटिसा

पूर्णांक परिशुद्धता सीमा:
float:  ±16,777,216 (2^24) तक सटीक
double: ±9,007,199,254,740,992 (2^53) तक सटीक