C++ में यूनरी ऑपरेटर को ओवरलोड करना क्या है?

सिंगल ऑपरेटर्स एक मात्रा पर ऑपरेट करते हैं और सिंगल ऑपरेटर्स के उदाहरण निम्न हैं – ++ इन्क्रीमेंट और -- डिक्रीमेंट ऑपरेटर्स। कंपाइलर ऑपरेटर के विभिन्न अर्थों को इसके ऑपरेंड्स के प्रकारों की जांच करके अलग करता है।

यूनरी ऑपरेटर्स एक सिंगल ऑपरेंड पर ऑपरेट करते हैं और यूनरी ऑपरेटर्स के उदाहरण निम्न हैं –

• इन्क्रीमेंट (++) और डिक्रीमेंट (--) ऑपरेटर्स।
• यूनरी माइनस (-) ऑपरेटर।
• लॉजिकल नॉट (!) ऑपरेटर।

यूनरी ऑपरेटर्स उस ऑब्जेक्ट पर ऑपरेट करते हैं जिसके लिए उन्हें कॉल किया गया था और आमतौर पर, यह ऑपरेटर ऑब्जेक्ट के बाईं ओर दिखाई देता है, जैसे !obj, -obj, और ++obj लेकिन कभी-कभी उन्हें पोस्टफिक्स के रूप में भी उपयोग किया जा सकता है जैसे obj++ या obj--।

निम्न उदाहरण बताता है कि बैंग (!) ऑपरेटर को प्रीफिक्स उपयोग के लिए कैसे ओवरलोड किया जा सकता है –

उदाहरण

#include <iostream>
using namespace std;
class Distance {
    private:
    int feet;      // 0 से अनंत
    int inches;    // 0 से 12
    public:
        // कंस्ट्रक्टर
        Distance(int f, int i) {
            feet = f;
            inches = i;
        }
        // दूरी प्रदर्शित करने की विधि
        void display() {
            cout << "F: " << feet << " I:" << inches << endl;
        }
        // ओवरलोडेड बैंग(!) ऑपरेटर
        Distance operator!() {
            feet = -feet;
            inches = -inches;
            return Distance(feet, inches);
        }
};
int main() {
    Distance D1(3, 4), D2(-1, 10);
    !D1;
    D1.display(); // D1 प्रदर्शित करें
    !D2;          // नेगेशन लागू करें
    D2.display(); // D2 प्रदर्शित करें
    return 0;
}

आउटपुट

इससे आउटपुट मिलेगा –

F: -3 I:-4
F: 1 I:-10