C++ में static_cast vs C-स्टाइल कास्टिंग का अंतर

C++ में static_cast और C-स्टाइल कास्टिंग दोनों टाइप कन्वर्जन के लिए उपयोग होते हैं, लेकिन उनके व्यवहार और सुरक्षा में महत्वपूर्ण अंतर हैं।

सिंटैक्स तुलना

// C-स्टाइल कास्ट
int x = (int)3.14;
int* ptr = (int*)&someChar;

// C++ static_cast
int y = static_cast<int>(3.14);
// int* ptr = static_cast<int*>(&someChar); // कंपाइल एरर!

मुख्य अंतर

उदाहरण: static_cast सुरक्षा

#include <iostream>
using namespace std;

class Base { virtual void f() {} };
class Derived : public Base {};
class Unrelated {};

int main() {
    Derived d;
    Base* b = &d;
    
    // 1. अपकास्ट (Derived* → Base*) - दोनों काम करते हैं
    Base* b1 = static_cast<Base*>(&d);  // OK
    Base* b2 = (Base*)&d;                 // OK
    
    // 2. डाउनकास्ट (Base* → Derived*) - static_cast अनसेफ लेकिन अनुमत
    Derived* d1 = static_cast<Derived*>(b);  // OK (प्रोग्रामर की जिम्मेदारी)
    Derived* d2 = (Derived*)b;               // OK
    
    // 3. असंबंधित क्लासेज - static_cast ब्लॉक करता है!
    Unrelated* u1 = static_cast<Unrelated*>(&d);  // COMPILE ERROR!
    // Unrelated* u2 = (Unrelated*)&d;             // C-स्टाइल: कंपाइल होता है लेकिन UB!
    
    // 4. const हटाना - static_cast नहीं करता
    const int ci = 10;
    // int* p1 = static_cast<int*>(&ci);  // COMPILE ERROR!
    // int* p2 = (int*)&ci;                 // C-स्टाइल: कंपाइल होता है लेकिन UB!
    
    // 5. बेसिक टाइप कन्वर्जन - दोनों काम करते हैं
    double pi = 3.14159;
    int i1 = static_cast<int>(pi);  // 3
    int i2 = (int)pi;               // 3
    
    cout << "static_cast और C-स्टाइल दोनों बेसिक टाइप्स के लिए काम करते हैं।\n";
    cout << "लेकिन static_cast पॉइंटर टाइप सेफ्टी लागू करता है।\n";
    
    return 0;
}

आउटपुट

static_cast और C-स्टाइल दोनों बेसिक टाइप्स के लिए काम करते हैं।
लेकिन static_cast पॉइंटर टाइप सेफ्टी लागू करता है।

कब कौन सा उपयोग करें?

• static_cast: सामान्य टाइप कन्वर्जन (numeric, related pointers, enums)
• dynamic_cast: पॉलीमॉर्फिक डाउनकास्ट (RTTI आवश्यक, रनटाइम चेक)
• const_cast: const/volatile क्वालिफायर हटाने/जोड़ने के लिए
• reinterpret_cast: लो-लेवल रीइंटरप्रिटेशन (पॉइंटर↔इंटीजर, असंबंधित पॉइंटर्स)
• C-स्टाइल कास्ट: बचें आधुनिक C++ में। यह ऊपर के सभी का कॉम्बिनेशन करता है अनजाने में।

बेस्ट प्रैक्टिस

// ✅ अच्छा: स्पष्ट इरादा
double d = 3.14;
int i = static_cast<int>(d);

// ✅ अच्छा: पॉलीमॉर्फिक डाउनकास्ट
if (Derived* dp = dynamic_cast<Derived*>(bp)) {
    // सुरक्षित उपयोग
}

// ✅ अच्छा: const हटाना (दुर्लभ, सावधानी से)
void legacyApi(int* p);
const int ci = 42;
legacyApi(const_cast<int*>(&ci)); // केवल यदि legacyApi modify नहीं करता

// ❌ बुरा: C-स्टाइल कास्ट
int* p = (int*)someVoidPtr;  // क्या इरादा है? static? reinterpret? const_cast?