C++ में कन्वर्टिंग कंस्ट्रक्टर क्या है?

कन्वर्टिंग कंस्ट्रक्टर (Conversion Constructor)

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

जब एक कंस्ट्रक्टर केवल एक आर्गुमेंट लेता है तो इस प्रकार के कंस्ट्रक्टर्स **कन्वर्जन कंस्ट्रक्टर** बन जाते हैं। इस प्रकार का कंस्ट्रक्टर क्लास में बनाए जा रहे ऑब्जेक्ट के लिए ऑटोमैटिक कन्वर्जन की अनुमति देता है।

उदाहरण

#include <iostream>
using namespace std;

class MyClass {
private:
    int my_var;
public:
    // कन्वर्जन कंस्ट्रक्टर (सिंगल पैरामीटर)
    MyClass(int x) {
        this->my_var = x;
    }
    
    void display() {
        cout << "The value of my_var is: " << my_var << endl;
    }
};

int main() {
    MyClass my_obj(10);  // डायरेक्ट इनिशियलाइज़ेशन
    my_obj.display();
    
    my_obj = 50;  // यहां कन्वर्जन कंस्ट्रक्टर कॉल होता है!
    // समतुल्य: my_obj = MyClass(50);
    my_obj.display();
    
    return 0;
}

आउटपुट

The value of my_var is: 10
The value of my_var is: 50

कन्वर्जन कंस्ट्रक्टर की विशेषताएं

• **सिंगल पैरामीटर** (या डिफ़ॉल्ट आर्गुमेंट्स वाले मल्टीपल पैरामीटर्स जहां केवल एक अनिवार्य है)
• इम्प्लिसिट कन्वर्जन सक्षम करता है: Type obj = value;
• फ़ंक्शन कॉल्स में इम्प्लिसिट कन्वर्जन: func(obj) जहां func(Type) अपेक्षित है
• कंपाइलर द्वारा ऑटोमैटिकली लागू (जब तक explicit न हो)

इम्प्लिसिट कन्वर्जन रोकना: explicit कीवर्ड

class MyClass {
    int value;
public:
    // explicit कन्वर्जन कंस्ट्रक्टर - इम्प्लिसिट कन्वर्जन रोकता है
    explicit MyClass(int x) : value(x) {}
    
    void display() const { cout << value << endl; }
};

int main() {
    MyClass obj(10);        // ठीक: डायरेक्ट इनिशियलाइज़ेशन
    // MyClass obj2 = 20;   // त्रुटि: इम्प्लिसिट कन्वर्जन ब्लॉक्ड
    MyClass obj3 = MyClass(20);  // ठीक: एक्सप्लिसिट कंस्ट्रक्शन
    
    // func(obj);  // यदि func(MyClass) अपेक्षित है तो ठीक
    // func(10);   // त्रुटि: इम्प्लिसिट कन्वर्जन नहीं
}

कॉपी इंनिशियलाइज़ेशन vs डायरेक्ट इंनिशियलाइज़ेशन

MyClass a(10);        // डायरेक्ट इंनिशियलाइज़ेशन - explicit की परवाह किए बिना काम करता है
MyClass b = 10;       // कॉपी इंनिशियलाइज़ेशन - explicit होने पर ब्लॉक होता है
MyClass c = MyClass(10); // कॉपी इंनिशियलाइज़ेशन लेकिन एक्सप्लिसिट टाइप - काम करता है
MyClass d{10};        // लिस्ट इंनिशियलाइज़ेशन (C++11) - explicit का सम्मान करता है

अन्य कन्वर्जन कंस्ट्रक्टर उदाहरण

class String {
    char* data;
    size_t len;
public:
    // const char* से कन्वर्जन
    String(const char* s) : len(strlen(s)) {
        data = new char[len + 1];
        strcpy(data, s);
    }
    
    // C++11: std::string से कन्वर्जन
    String(const std::string& s) : len(s.size()) {
        data = new char[len + 1];
        strcpy(data, s.c_str());
    }
};

// उपयोग:
String s1 = "Hello";        // const char* कंस्ट्रक्टर
String s2 = std::string("World"); // std::string कंस्ट्रक्टर