C++ में Dynamic_cast और static_cast

static_cast

static_cast: यह सामान्य/साधारण टाइप कन्वर्जन के लिए उपयोग किया जाता है। यह इम्प्लिसिट टाइप कोएरशन के लिए भी जिम्मेदार कास्ट है और इसे एक्सप्लिसिटली भी बुलाया जा सकता है। आपको इसका उपयोग फ्लोट से इंट, चार से इंट, आदि जैसे मामलों में करना चाहिए। यह संबंधित टाइप क्लासेस को कास्ट कर सकता है। यदि टाइप्स समान नहीं हैं तो यह कुछ एरर उत्पन्न करेगा।

उदाहरण

#include <iostream>
using namespace std;

class Base {};
class Derived : public Base {};
class MyClass {};

int main() {
    Derived* d = new Derived;
    Base* b = static_cast<Base*>(d);  // ठीक: अपकास्ट (हमेशा सुरक्षित)
    
    MyClass* x = static_cast<MyClass*>(d);  // त्रुटि: असंबंधित टाइप्स
    // कंपाइल-टाइम एरर: invalid static_cast
    
    delete d;
    return 0;
}

आउटपुट

[Error] invalid static_cast from type 'Derived*' to type 'MyClass*'

dynamic_cast

dynamic_cast: यह कास्ट पॉलीमॉर्फिज्म को संभालने के लिए उपयोग किया जाता है। आपको इसका उपयोग केवल तब करना चाहिए जब आप डेराइव्ड क्लास में कास्ट कर रहे हों। यह विशेष रूप से इनहेरिटेंस में उपयोग किया जाता है जब आप बेस क्लास से डेराइव्ड क्लास में कास्ट करते हैं।

आवश्यकताएं

• सोर्स टाइप पॉलीमॉर्फिक होना चाहिए (कम से कम एक वर्चुअल फ़ंक्शन)
• रनटाइम टाइप चेक करता है (RTTI आवश्यक)
• पॉइंटर के लिए: विफलता पर nullptr रिटर्न करता है
• रेफरेंस के लिए: विफलता पर std::bad_cast थ्रो करता है

उदाहरण

#include <iostream>
using namespace std;

class MyClass1 {
public:
    virtual void print() const {
        cout << "This is from MyClass1\n";
    }
    virtual ~MyClass1() {}  // वर्चुअल डिस्ट्रक्टर आवश्यक
};

class MyClass2 {
public:
    virtual void print() const {
        cout << "This is from MyClass2\n";
    }
    virtual ~MyClass2() {}
};

class MyClass3 : public MyClass1, public MyClass2 {
public:
    void print() const override {
        cout << "This is from MyClass3\n";
    }
};

int main() {
    MyClass1* a = new MyClass1;
    MyClass2* b = new MyClass2;
    MyClass3* c = new MyClass3;
    
    a->print();
    b->print();
    c->print();
    
    // डाउनकास्ट प्रयास: MyClass1* से MyClass2* (असंबंधित)
    b = dynamic_cast<MyClass2*>(a);  // विफल होगा
    if (b)
        b->print();
    else
        cout << "no MyClass2\n";
    
    // अपकास्ट: MyClass3* से MyClass1* (हमेशा काम करता है)
    a = c;
    a->print();  // MyClass3 से प्रिंट (पॉलीमॉर्फिज्म)
    
    // डाउनकास्ट: MyClass1* से MyClass2* (सफल - वास्तव में MyClass3 है)
    b = dynamic_cast<MyClass2*>(a);  // सफलतापूर्वक कास्ट किया गया
    if (b)
        b->print();
    else
        cout << "no MyClass2\n";
    
    delete a;  // MyClass3 ऑब्जेक्ट डिलीट
    return 0;
}

आउटपुट

This is from MyClass1
This is from MyClass2
This is from MyClass3
no MyClass2
This is from MyClass3
This is from MyClass3

तुलना तालिका

अन्य कास्ट्स

• const_cast: const/volatile क्वालिफायर जोड़ता/हटाता है
• reinterpret_cast: लो-लेवल रीइंटरप्रिटेशन (खतरनाक)
• C-स्टाइल कास्ट से बचें: (Type)expr - यह const_cast + static_cast + reinterpret_cast को जोड़ता है

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

• संबंधित टाइप्स के लिए static_cast (अपकास्ट, संख्यात्मक कन्वर्जन)
• पॉलीमॉर्फिक डाउनकास्ट/क्रॉस-कास्ट के लिए dynamic_cast
• जहां संभव हो कास्टिंग से बचें - पॉलीमॉर्फिज्म/टेम्पलेट्स का उपयोग करें
• पॉइंटर्स के लिए dynamic_cast परिणाम की हमेशा जांच करें