c++ - स्पष्ट कीवर्ड का क्या अर्थ है?

इस पर पहले ही चर्चा की जा चुकी है ( स्पष्ट कन्स्ट्रक्टर क्या है )। लेकिन मुझे कहना होगा कि इसमें यहां दिए गए विस्तृत विवरणों की कमी है।

इसके अलावा, यह हमेशा एक अच्छा कोडिंग अभ्यास है जो आपके एक तर्क कन्स्ट्रक्टर (जिसमें Arg2, arg3, ... के लिए डिफ़ॉल्ट मान वाले हैं) शामिल हैं। सी ++ के साथ हमेशा की तरह: यदि आप नहीं करते हैं - तो आप चाहेंगे कि आपने किया ...

कक्षाओं के लिए एक और अच्छा अभ्यास कॉपी निर्माण और असाइनमेंट निजी (उर्फ इसे अक्षम करें) बनाना है जब तक कि आपको वास्तव में इसे लागू करने की आवश्यकता न हो। यह उन तरीकों का उपयोग करते समय पॉइंटर्स की अंतिम प्रतियां प्राप्त करता है जो डिफ़ॉल्ट रूप से C ++ आपके लिए बनाएंगे। ऐसा करने का एक और तरीका बूस्ट :: noncopyable से प्राप्त होता है।

मान लीजिए, आपके पास एक वर्ग String :

class String {
public:
    String(int n); // allocate n bytes to the String object
    String(const char *p); // initializes object with char *p
};

अब, यदि आप कोशिश करते हैं:

String mystring = 'x';

चरित्र 'x' को अंतर्निहित रूप से int परिवर्तित किया जाएगा और फिर String(int) कन्स्ट्रक्टर को बुलाया जाएगा। लेकिन, ऐसा नहीं है कि उपयोगकर्ता का इरादा हो सकता है। इसलिए, ऐसी स्थितियों को रोकने के लिए, हम निर्माता को explicit रूप से परिभाषित करेंगे:

class String {
public:
    explicit String (int n); //allocate n bytes
    String(const char *p); // initialize sobject with string p
};

यह उत्तर एक स्पष्ट कन्स्ट्रक्टर के साथ / बिना ऑब्जेक्ट सृजन के बारे में है क्योंकि यह अन्य उत्तरों में शामिल नहीं है।

एक स्पष्ट निर्माता के बिना निम्न वर्ग पर विचार करें:

class Foo
{
public:
    Foo(int x) : m_x(x)
    {
    }

private:
    int m_x;
};

कक्षा फू के ऑब्जेक्ट्स 2 तरीकों से बनाया जा सकता है:

Foo bar1(10);

Foo bar2 = 20;

कार्यान्वयन के आधार पर, कक्षा फू को तत्काल करने का दूसरा तरीका भ्रमित हो सकता है, या प्रोग्रामर का इरादा नहीं है। कन्स्ट्रक्टर को explicit कीवर्ड उपसर्ग करना Foo bar2 = 20; पर एक कंपाइलर त्रुटि उत्पन्न करेगा Foo bar2 = 20; ।

एकल-तर्क रचनाकारों को explicit रूप से घोषित करना आमतौर पर अच्छा अभ्यास होता है, जब तक कि आपका कार्यान्वयन विशेष रूप से प्रतिबंधित न हो।

ध्यान दें कि साथ रचनाकार

• सभी मानकों के लिए डिफ़ॉल्ट तर्क, या
• दूसरे पैरामीटर के लिए डिफ़ॉल्ट तर्क

दोनों एकल-तर्क कन्स्ट्रक्टर के रूप में इस्तेमाल किया जा सकता है। तो आप इन्हें भी explicit करना चाहते हैं।

एक उदाहरण जब आप जानबूझकर अपने सिंगल-तर्क कन्स्ट्रक्टर को स्पष्ट नहीं करना चाहते हैं तो यह है कि यदि आप एक मजेदार बना रहे हैं ( this उत्तर में घोषित 'add_x' स्ट्रक्चर देखें)। ऐसे मामले में, add_x add30 = 30; रूप में ऑब्जेक्ट बनाना add_x add30 = 30; शायद समझ में आता है।

Here स्पष्ट रचनाकारों पर एक अच्छा लेखन है।

सी ++ में, केवल एक आवश्यक पैरामीटर वाला एक कन्स्ट्रक्टर एक अंतर्निहित रूपांतरण फ़ंक्शन माना जाता है। यह पैरामीटर प्रकार को कक्षा प्रकार में परिवर्तित करता है। चाहे यह एक अच्छी बात है या नहीं, कन्स्ट्रक्टर के अर्थशास्त्र पर निर्भर करता है।

उदाहरण के लिए, यदि आपके पास कन्स्ट्रक्टर String(const char* s) साथ एक स्ट्रिंग क्लास है, तो शायद यह वही है जो आप चाहते हैं। आप String अपेक्षा रखने वाले फ़ंक्शन में एक const char* पास कर सकते हैं, और कंपाइलर स्वचालित रूप से आपके लिए एक अस्थायी String ऑब्जेक्ट का निर्माण करेगा।

दूसरी तरफ, यदि आपके पास बफर क्लास है जिसका कन्स्ट्रक्टर Buffer(int size) बाइट्स में बफर का आकार लेता है, तो शायद आप नहीं चाहते कि संकलक चुपचाप Buffer एस में Buffer । इसे रोकने के लिए, आप explicit कीवर्ड के साथ निर्माता को घोषित करते हैं:

class Buffer { explicit Buffer(int size); ... }

उस तरफ,

void useBuffer(Buffer& buf);
useBuffer(4);

संकलन-समय त्रुटि बन जाती है। यदि आप अस्थायी Buffer ऑब्जेक्ट को पास करना चाहते हैं, तो आपको स्पष्ट रूप से ऐसा करना होगा:

useBuffer(Buffer(4));

संक्षेप में, यदि आपका एकल-पैरामीटर कन्स्ट्रक्टर पैरामीटर को आपकी कक्षा के किसी ऑब्जेक्ट में परिवर्तित करता है, तो शायद आप explicit कीवर्ड का उपयोग नहीं करना चाहते हैं। लेकिन अगर आपके पास एक कन्स्ट्रक्टर है जो केवल एक पैरामीटर लेने के लिए होता है, तो आपको संकलक को अप्रत्याशित रूपांतरणों से आश्चर्यचकित करने से रोकने के लिए इसे explicit रूप से घोषित करना चाहिए।

सीपीपी संदर्भ हमेशा मददगार है !!! स्पष्ट विनिर्देशक के बारे में विवरण here पाया जा सकता here । आपको निहित रूपांतरण और copy-initialization भी देखने की आवश्यकता हो सकती है।

त्वरित देखो

स्पष्ट विनिर्देशक निर्दिष्ट करता है कि एक कन्स्ट्रक्टर या रूपांतरण फ़ंक्शन (सी ++ 11 के बाद) अंतर्निहित रूपांतरण या प्रति-प्रारंभिकरण की अनुमति नहीं देता है।

उदाहरण निम्नानुसार है:

struct A
{
    A(int) { }      // converting constructor
    A(int, int) { } // converting constructor (C++11)
    operator bool() const { return true; }
};

struct B
{
    explicit B(int) { }
    explicit B(int, int) { }
    explicit operator bool() const { return true; }
};

int main()
{
    A a1 = 1;      // OK: copy-initialization selects A::A(int)
    A a2(2);       // OK: direct-initialization selects A::A(int)
    A a3 {4, 5};   // OK: direct-list-initialization selects A::A(int, int)
    A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
    A a5 = (A)1;   // OK: explicit cast performs static_cast
    if (a1) cout << "true" << endl; // OK: A::operator bool()
    bool na1 = a1; // OK: copy-initialization selects A::operator bool()
    bool na2 = static_cast<bool>(a1); // OK: static_cast performs direct-initialization

//  B b1 = 1;      // error: copy-initialization does not consider B::B(int)
    B b2(2);       // OK: direct-initialization selects B::B(int)
    B b3 {4, 5};   // OK: direct-list-initialization selects B::B(int, int)
//  B b4 = {4, 5}; // error: copy-list-initialization does not consider B::B(int,int)
    B b5 = (B)1;   // OK: explicit cast performs static_cast
    if (b5) cout << "true" << endl; // OK: B::operator bool()
//  bool nb1 = b2; // error: copy-initialization does not consider B::operator bool()
    bool nb2 = static_cast<bool>(b2); // OK: static_cast performs direct-initialization
}

explicit शब्दकोष को कन्स्ट्रक्टर को स्पष्ट रूप से बुलाए जाने के लिए उपयोग किया जा सकता है।

class C{
public:
    explicit C(void) = default;
};

int main(void){
    C c();
    return 0;
}

कन्स्ट्रक्टर C(void) सामने explicit कुंजीशब्द संकलक को बताता है कि इस कन्स्ट्रक्टर को केवल स्पष्ट कॉल की अनुमति है।

उपयोगकर्ता-परिभाषित प्रकार कास्ट ऑपरेटरों में explicit कीवर्ड का भी उपयोग किया जा सकता है:

class C{
public:
    explicit inline operator bool(void) const{
        return true;
    }
};

int main(void){
    C c;
    bool b = static_cast<bool>(c);
    return 0;
}

यहां, explicit कुंजीशब्द केवल स्पष्ट रूप से मान्य होने के लिए लागू करता है, इसलिए bool b = c; इस मामले में एक अवैध कलाकार होगा। इन explicit कीवर्ड जैसी परिस्थितियों में प्रोग्रामर को निहित, अनियंत्रित कास्ट से बचने में मदद मिल सकती है। इस उपयोग को C++11 में मानकीकृत किया गया है।

स्पष्ट रूपांतरण कन्स्ट्रक्टर (केवल सी ++)

स्पष्ट फ़ंक्शन विनिर्देशक अवांछित अंतर्निहित प्रकार रूपांतरणों को नियंत्रित करता है। इसका उपयोग केवल वर्ग घोषणा के भीतर रचनाकारों की घोषणाओं में किया जा सकता है। उदाहरण के लिए, डिफ़ॉल्ट कन्स्ट्रक्टर को छोड़कर, निम्न श्रेणी में निर्माता रूपांतरण कन्स्ट्रक्टर हैं।

class A
{
public:
    A();
    A(int);
    A(const char*, int = 0);
};

निम्नलिखित घोषणाएं कानूनी हैं:

A c = 1;
A d = "Venditti";

पहली घोषणा A c = A( 1 ); बराबर है A c = A( 1 ); ।

यदि आप कक्षा के निर्माता को explicit रूप से घोषित करते हैं, तो पिछली घोषणाएं अवैध होंगी।

उदाहरण के लिए, यदि आप कक्षा को इस प्रकार घोषित करते हैं:

class A
{
public:
    explicit A();
    explicit A(int);
    explicit A(const char*, int = 0);
};

आप केवल उन मानों को असाइन कर सकते हैं जो कक्षा प्रकार के मानों से मेल खाते हैं।

उदाहरण के लिए, निम्नलिखित कथन कानूनी हैं:

  A a1;
  A a2 = A(1);
  A a3(1);
  A a4 = A("Venditti");
  A* p = new A(1);
  A a5 = (A)1;
  A a6 = static_cast<A>(1);