यहां हम देखेंगे कि C++ में explicit कीवर्ड का क्या प्रभाव होता है। इससे पहले कि हम उस पर चर्चा करें, आइए एक उदाहरण कोड देखें और उसके आउटपुट का पता लगाने का प्रयास करें।
उदाहरण: implicit conversion के बिना explicit
#include <iostream>
using namespace std;
class Point {
private:
double x, y;
public:
Point(double a = 0.0, double b = 0.0) : x(a), y(b) {
// कंस्ट्रक्टर
}
bool operator==(Point p2) {
if (p2.x == this->x && p2.y == this->y)
return true;
return false;
}
};
int main() {
Point p(5, 0);
if (p == 5)
cout << "वे समान हैं";
else
cout << "वे समान नहीं हैं";
return 0;
}
आउटपुट
वे समान हैं
यह ठीक काम कर रहा है क्योंकि हम जानते हैं कि यदि एक कंस्ट्रक्टर को केवल एक आर्गुमेंट का उपयोग करके बुलाया जा सकता है, तो यह एक रूपांतरण कंस्ट्रक्टर (conversion constructor) में परिवर्तित हो जाएगा। लेकिन हम इस तरह के रूपांतरण से बच सकते हैं, क्योंकि यह कुछ अविश्वसनीय परिणाम उत्पन्न कर सकता है।
इस रूपांतरण को प्रतिबंधित करने के लिए, हम कंस्ट्रक्टर के साथ explicit मॉडिफायर का उपयोग कर सकते हैं। उस स्थिति में, यह परिवर्तित नहीं होगा। यदि उपरोक्त प्रोग्राम को explicit कीवर्ड के साथ उपयोग किया जाता है, तो यह कंपाइलेशन त्रुटि उत्पन्न करेगा।
उदाहरण: explicit कंस्ट्रक्टर के साथ
#include <iostream>
using namespace std;
class Point {
private:
double x, y;
public:
explicit Point(double a = 0.0, double b = 0.0) : x(a), y(b) {
// कंस्ट्रक्टर
}
bool operator==(Point p2) {
if (p2.x == this->x && p2.y == this->y)
return true;
return false;
}
};
int main() {
Point p(5, 0);
if (p == 5)
cout << "वे समान हैं";
else
cout << "वे समान नहीं हैं";
return 0;
}
आउटपुट
[Error] 'operator==' के लिए कोई मेल नहीं (ऑपरेंड प्रकार 'Point' और 'int' हैं) [Note] उम्मीदवार: bool Point::operator==(Point)
अब इंट से Point में इम्प्लिसिट रूपांतरण अवरुद्ध है, इसलिए तुलना विफल होती है।
Explicit कास्टिंग के साथ अभी भी रूपांतरण संभव
हम अभी भी explicit कास्टिंग का उपयोग करके किसी मान को Point टाइप में टाइपकास्ट कर सकते हैं।
उदाहरण
#include <iostream>
using namespace std;
class Point {
private:
double x, y;
public:
explicit Point(double a = 0.0, double b = 0.0) : x(a), y(b) {}
bool operator==(Point p2) {
return (p2.x == this->x && p2.y == this->y);
}
};
int main() {
Point p(5, 0);
if (p == (Point)5) // explicit कास्ट
cout << "वे समान हैं";
else
cout << "वे समान नहीं हैं";
return 0;
}
आउटपुट
वे समान हैं
explicit कीवर्ड: मुख्य बिंदु
| स्थिति | बिना explicit | explicit के साथ |
|---|---|---|
| इम्प्लिसिट रूपांतरण | अनुमत | अवरुद्ध |
| डायरेक्ट इनिशियलाइज़ेशन | काम करता है | काम करता है |
| कॉपी इनिशियलाइज़ेशन | काम करता है | त्रुटि |
| Explicit कास्ट | काम करता है | काम करता है |
| फंक्शन आर्गुमेंट पासिंग | इम्प्लिसिट रूपांतरण | Explicit कास्ट आवश्यक |
C++11: explicit ऑपरेटर्स
C++11 से, रूपांतरण ऑपरेटर्स भी explicit हो सकते हैं:
class Wrapper {
int value;
public:
explicit operator bool() const { return value != 0; }
explicit operator int() const { return value; }
};
Wrapper w(5);
if (w) { } // OK: explicit bool कन्वर्जन if में अनुमत
int x = w; // त्रुटि: explicit int कन्वर्जन
int y = (int)w; // OK: explicit कास्ट
सर्वोत्तम अभ्यास
- डिफ़ॉल्ट रूप से explicit का उपयोग करें सिंगल-आर्गुमेंट कंस्ट्रक्टर्स और रूपांतरण ऑपरेटर्स के लिए।
- केवल तभी implicit अनुमति दें जब यह स्पष्ट रूप से सुरक्षित और वांछित हो (जैसे स्मार्ट पॉइंटर्स के लिए
operator bool())। - यह अप्रत्याशित व्यवहार और बग्स को रोकता है।