"ऑपरेटर बूल () कॉन्स्ट" का क्या अर्थ है

जवाबों:

141

प्रपत्र के सदस्य कार्य 

operator TypeName()

रूपांतरण ऑपरेटर हैं। वे वर्ग प्रकार की वस्तुओं का उपयोग करने की अनुमति देते हैं जैसे कि वे प्रकार के थे TypeNameऔर जब वे होते हैं, तो वे TypeNameरूपांतरण फ़ंक्शन का उपयोग करके परिवर्तित हो जाते हैं ।

इस विशेष मामले में, operator bool()वर्ग प्रकार की एक वस्तु का उपयोग करने की अनुमति देता है जैसे कि यह एक था bool। उदाहरण के लिए, यदि आपके पास नामित वर्ग प्रकार की कोई वस्तु है obj, तो आप इसका उपयोग कर सकते हैं

if (obj)

यह कॉल करेगा operator bool(), परिणाम लौटाएगा, और परिणाम का उपयोग शर्त के रूप में करेगा if।

यह ध्यान दिया जाना चाहिए कि operator bool()ए वेरी बैड आइडिया है और आपको इसका इस्तेमाल कभी नहीं करना चाहिए। यह क्यों खराब है और समस्या के समाधान के लिए एक विस्तृत विवरण के लिए, "द सेफ बूल आइडियलम" देखें ।

(C ++ 0x, C ++ मानक का आगामी संशोधन, स्पष्ट रूपांतरण ऑपरेटरों के लिए समर्थन जोड़ता है। ये आपको एक सुरक्षित लिखने की अनुमति देगा explicit operator bool()जो सुरक्षित बूल मुहावरे को लागू करने के हुप्स के माध्यम से कूदने के बिना सही ढंग से काम करता है।)

— जेम्स मैकनेलिस
स्रोत
1
"यह एक बूल के रूप में इस्तेमाल किया जाता है" जैसा कि आप कह सकते हैं कि यह एक नकली मूल्य है। बल्कि पोस्टर के कोड में, यह प्रकार के बूल का एक अस्थायी चर उत्पन्न करता है जो कि कर्नल के क्षणिक मूल्य से संबंधित होता है लेकिन इसके बाद बनाई गई वस्तु से स्वतंत्र होता है। इसके अलावा, सेफ बूल आइडियल का उल्लेख बहुत अच्छा है, लेकिन इसके विपरीत विचार दर्ज करने के लिए: आईएमएचओ "वास्तव में इसका कभी भी उपयोग नहीं करता है" सलाह शीर्ष पर है - यह अधिक मोटे एपीआई की कीमत पर मूर्खतापूर्ण दुरुपयोग के खिलाफ सख्त संकलक चेक देता है जिससे आकस्मिक दुरुपयोग हो सकता है।
— टोनी डेलरो
1
@ टोनी: ठीक है, यह इस्तेमाल किया जा सकता है जैसे कि यह एक बूल था; चूंकि रूपांतरण का परिणाम एक प्रतिद्वंद्विता ( bool) है, नहीं, आप इसे असाइन नहीं कर सकते। यदि यह एक परिवर्तनीय अंतराल (जैसे bool&) था, तो आप इसे असाइन कर सकते हैं। शुद्धता के लिए, मेरा तर्क है कि operator bool()यह हमेशा गलत होता है क्योंकि यह कई प्रकार की स्थितियों में वर्ग-प्रकार की वस्तु का उपयोग करने की अनुमति देता है जहां आप कभी भी इसका उपयोग नहीं करना चाहते हैं। सुरक्षित बूल एक बेहतर विकल्प है।
— जेम्स मैकनेलिस
1
तो पिछले पैराग्राफ के अनुसार आज उपयोग करने के लिए पूरी तरह से ठीक है explicit operator bool()। क्या मैंने ठीक समझा?
— झिंगम
1
सी ++ समिति ऑपरेटर बूल () पर आपसे असहमत दिखेगी। कम से कम मानक के नवीनतम संस्करण के लिए (जैसे en.cppreference.com/w/cpp/utility/optional )। या शायद आप केवल एसटीएल कोड का उपयोग करने की अनुमति दी जानी चाहिए?
— जो स्टील की
1
@JoeSteele - देखें stackoverflow.com/a/16615725/2492801 । स्पष्ट रूपांतरण ऑपरेटर सुरक्षित हैं!
— बेंजामिन बिहलर
9 
operator bool() const 
{
    return col != 0;
}

परिभाषित करता है कि क्लास को बूलियन मान में कैसे बदला जा सकता है, इस पद्धति को इंगित करने के लिए उपयोग किए जाने के constबाद ()यह उत्परिवर्तित नहीं करता है (इस वर्ग के सदस्यों को बदलें)।

आप आमतौर पर ऐसे ऑपरेटरों का उपयोग इस प्रकार करेंगे:

airplaysdk sdkInstance;
if (sdkInstance) {
    std::cout << "Instance is active" << std::endl;
} else {
    std::cout << "Instance is in-active error!" << std::endl;
}
— langerra.com
स्रोत
7

मैं इसे स्पष्ट करने के लिए और अधिक कोड देना चाहूंगा।

struct A
{
    operator bool() const { return true; }
};

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

int main()
{
    A a1;
    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;     
    if (b1) cout << "true" << endl; // OK: B::operator bool()
    // bool nb1 = b1; // error: copy-initialization does not consider B::operator bool()
    bool nb2 = static_cast<bool>(b1); // OK: static_cast performs direct-initialization
}
— selfboot
स्रोत
3

यह उपयोगकर्ता-निर्धारित implicitरूपांतरण समारोह में या तो अपने वर्ग कन्वर्ट करने के लिए trueया false।

//usage
bool value = yourclassinstance; //yourclassinstance is converted into bool!
— नवाज
स्रोत
1

यह एक अंतर्निहित रूपांतरण है bool। यानी जहां भी निहित रूपांतरण की अनुमति है, boolउस पद्धति को कॉल करके आपकी कक्षा को परिवर्तित किया जा सकता है ।

— बिली ओनली
स्रोत
1

जैसा कि दूसरों ने कहा है, यह इस मामले में टाइप रूपांतरण के लिए है bool। उदाहरण के लिए:

class A {
    bool isItSafe;

public:
    operator bool() const
    {
        return isItSafe;
    }

    ...
};

अब मैं इस वर्ग की एक वस्तु का उपयोग कर सकता हूँ जैसे कि यह एक बूलियन है:

A a;
...
if (a) {
    ....
}
— chrisaycock
स्रोत
1

अपना स्वयं का यूनिक_प्र्टर लिखते समय, मुझे यह मामला मिला। यह देखते हुए std::unique_ptr'soperator== :

template<class T1, class D1, class T2, class D2>
bool operator==(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y);

template <class T, class D>
bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;

template <class T, class D>
bool operator==(nullptr_t, const unique_ptr<T, D>& x) noexcept;

और यह परीक्षण मामला libstdcxx से :

  std::unique_ptr<int> ptr;
  if (ptr == 0)
    { }
  if (0 == ptr)
    { }
  if (ptr != 0)
    { }
  if (0 != ptr)
    { }

ध्यान दें क्योंकि ptrइसमें ए है explicit operator bool() const noexcept;, इसलिए operator overload resolutionयहाँ ठीक काम करता है, जैसे, ptr == 0चुनता है

 template <class T, class D>
 bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;`.

यदि यह नहीं है explicitकीवर्ड यहाँ, ptrमें ptr == 0में कनवर्ट कर दिया जाएगा bool, तो boolमें बदल दिया जाएगा int, क्योंकि bool operator==(int, int)अंतर्निहित है और 0है int। हमारे लिए इंतजार कर रहा है अस्पष्ट अतिभार संकल्प त्रुटि है।

यहाँ एक न्यूनतम, पूर्ण और सत्यापन योग्य उदाहरण है :

#include <cstddef>
struct A
{
    constexpr A(std::nullptr_t) {}
    operator bool() 
    {
        return true;
    }
};

constexpr bool operator ==(A, A) noexcept
{
    return true;
}

constexpr bool operator ==(A, std::nullptr_t) noexcept
{
    return true;
}

constexpr bool operator ==(std::nullptr_t, A) noexcept
{
    return true;
}

int main()
{
    A a1(nullptr);
    A a2(0);
    a1 == 0;
}

gcc :

prog.cc: In function 'int main()':
prog.cc:30:8: error: ambiguous overload for 'operator==' (operand types are 'A' and 'int')
   30 |     a1 == 0;
      |     ~~ ^~ ~
      |     |     |
      |     A     int
prog.cc:30:8: note: candidate: 'operator==(int, int)' <built-in>
   30 |     a1 == 0;
      |     ~~~^~~~
prog.cc:11:16: note: candidate: 'constexpr bool operator==(A, A)'
   11 | constexpr bool operator ==(A, A) noexcept
      |                ^~~~~~~~
prog.cc:16:16: note: candidate: 'constexpr bool operator==(A, std::nullptr_t)'
   16 | constexpr bool operator ==(A, std::nullptr_t) noexcept
      |                ^~~~~~~~

क्लैंग :

prog.cc:30:8: error: use of overloaded operator '==' is ambiguous (with operand types 'A' and 'int')
    a1 == 0;
    ~~ ^  ~
prog.cc:16:16: note: candidate function
constexpr bool operator ==(A, std::nullptr_t) noexcept
               ^
prog.cc:11:16: note: candidate function
constexpr bool operator ==(A, A) noexcept
               ^
prog.cc:30:8: note: built-in candidate operator==(int, int)
    a1 == 0;
       ^
prog.cc:30:8: note: built-in candidate operator==(float, int)
prog.cc:30:8: note: built-in candidate operator==(double, int)
prog.cc:30:8: note: built-in candidate operator==(long double, int)
prog.cc:30:8: note: built-in candidate operator==(__float128, int)
prog.cc:30:8: note: built-in candidate operator==(int, float)
prog.cc:30:8: note: built-in candidate operator==(int, double)
prog.cc:30:8: note: built-in candidate operator==(int, long double)
prog.cc:30:8: note: built-in candidate operator==(int, __float128)
prog.cc:30:8: note: built-in candidate operator==(int, long)
prog.cc:30:8: note: built-in candidate operator==(int, long long)
prog.cc:30:8: note: built-in candidate operator==(int, __int128)
prog.cc:30:8: note: built-in candidate operator==(int, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(int, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(int, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(int, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(long, int)
prog.cc:30:8: note: built-in candidate operator==(long long, int)
prog.cc:30:8: note: built-in candidate operator==(__int128, int)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, int)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, int)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, int)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, int)
prog.cc:30:8: note: built-in candidate operator==(float, float)
prog.cc:30:8: note: built-in candidate operator==(float, double)
prog.cc:30:8: note: built-in candidate operator==(float, long double)
prog.cc:30:8: note: built-in candidate operator==(float, __float128)
prog.cc:30:8: note: built-in candidate operator==(float, long)
prog.cc:30:8: note: built-in candidate operator==(float, long long)
prog.cc:30:8: note: built-in candidate operator==(float, __int128)
prog.cc:30:8: note: built-in candidate operator==(float, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(float, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(float, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(float, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(double, float)
prog.cc:30:8: note: built-in candidate operator==(double, double)
prog.cc:30:8: note: built-in candidate operator==(double, long double)
prog.cc:30:8: note: built-in candidate operator==(double, __float128)
prog.cc:30:8: note: built-in candidate operator==(double, long)
prog.cc:30:8: note: built-in candidate operator==(double, long long)
prog.cc:30:8: note: built-in candidate operator==(double, __int128)
prog.cc:30:8: note: built-in candidate operator==(double, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(double, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(double, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(double, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(long double, float)
prog.cc:30:8: note: built-in candidate operator==(long double, double)
prog.cc:30:8: note: built-in candidate operator==(long double, long double)
prog.cc:30:8: note: built-in candidate operator==(long double, __float128)
prog.cc:30:8: note: built-in candidate operator==(long double, long)
prog.cc:30:8: note: built-in candidate operator==(long double, long long)
prog.cc:30:8: note: built-in candidate operator==(long double, __int128)
prog.cc:30:8: note: built-in candidate operator==(long double, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(long double, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(long double, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(long double, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(__float128, float)
prog.cc:30:8: note: built-in candidate operator==(__float128, double)
prog.cc:30:8: note: built-in candidate operator==(__float128, long double)
prog.cc:30:8: note: built-in candidate operator==(__float128, __float128)
prog.cc:30:8: note: built-in candidate operator==(__float128, long)
prog.cc:30:8: note: built-in candidate operator==(__float128, long long)
prog.cc:30:8: note: built-in candidate operator==(__float128, __int128)
prog.cc:30:8: note: built-in candidate operator==(__float128, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(__float128, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(__float128, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(__float128, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(long, float)
prog.cc:30:8: note: built-in candidate operator==(long, double)
prog.cc:30:8: note: built-in candidate operator==(long, long double)
prog.cc:30:8: note: built-in candidate operator==(long, __float128)
prog.cc:30:8: note: built-in candidate operator==(long, long)
prog.cc:30:8: note: built-in candidate operator==(long, long long)
prog.cc:30:8: note: built-in candidate operator==(long, __int128)
prog.cc:30:8: note: built-in candidate operator==(long, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(long, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(long, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(long, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(long long, float)
prog.cc:30:8: note: built-in candidate operator==(long long, double)
prog.cc:30:8: note: built-in candidate operator==(long long, long double)
prog.cc:30:8: note: built-in candidate operator==(long long, __float128)
prog.cc:30:8: note: built-in candidate operator==(long long, long)
prog.cc:30:8: note: built-in candidate operator==(long long, long long)
prog.cc:30:8: note: built-in candidate operator==(long long, __int128)
prog.cc:30:8: note: built-in candidate operator==(long long, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(long long, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(long long, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(long long, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(__int128, float)
prog.cc:30:8: note: built-in candidate operator==(__int128, double)
prog.cc:30:8: note: built-in candidate operator==(__int128, long double)
prog.cc:30:8: note: built-in candidate operator==(__int128, __float128)
prog.cc:30:8: note: built-in candidate operator==(__int128, long)
prog.cc:30:8: note: built-in candidate operator==(__int128, long long)
prog.cc:30:8: note: built-in candidate operator==(__int128, __int128)
prog.cc:30:8: note: built-in candidate operator==(__int128, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(__int128, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(__int128, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(__int128, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, float)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, double)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, long double)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, __float128)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, long)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned int, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, float)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, double)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, long double)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, __float128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, float)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, double)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, long double)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, __float128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned long long, unsigned __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, float)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, double)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, long double)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, __float128)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, long)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, __int128)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, unsigned int)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, unsigned long)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, unsigned long long)
prog.cc:30:8: note: built-in candidate operator==(unsigned __int128, unsigned __int128)
1 error generated.
— 陳 陳
स्रोत
-4

एक और आम उपयोग std कंटेनरों के लिए कस्टम वस्तुओं के अंदर प्रमुख मूल्यों पर समानता की तुलना करने के लिए है

class Foo
{
    public: int val;
};

class Comparer { public:
bool operator () (Foo& a, Foo&b) const {
return a.val == b.val; 
};

class Blah
{
std::set< Foo, Comparer > _mySet;
};
— user2945260
स्रोत
2
यह उदाहरण उपयोग operator ()नहीं है operator bool। वे बिलकुल अलग हैं। operator ()कॉल ऑपरेटर है, ताकि Comparerइसे फ़ंक्शन के रूप में कहा जा सके। यह operator ()सिर्फ लौटने के लिए होता है bool, लेकिन यह इसे वैसा ही नहीं बनाता है operator bool, जो केवल एक निहित कलाकारों के लिए अनुमति देता है bool।
— माइकल डोरस्ट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.