operator overloading in c++ example in hindi | operator overloading in c++ full details.

operator overloading in c++ full details

Operator overloading in C++

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

इस ट्यूटोरियल में, हम उदाहरणों की मदद से ऑपरेटर ओवरलोडिंग के बारे में जानेंगे।

C++ में, हम यूज़र-डिफ़ाइंड प्रकारों जैसे ऑब्जेक्ट्स और स्ट्रक्चर्स के लिए ऑपरेटरों के काम करने के तरीके को बदल सकते हैं। इसे ऑपरेटर ओवरलोडिंग के रूप में जाना जाता है। उदाहरण के लिए,

मान लीजिए कि हमने कॉम्प्लेक्स नामक एक वर्ग से तीन ऑब्जेक्ट c1, c2 और परिणाम बनाए हैं जो जटिल संख्याओं का प्रतिनिधित्व करते हैं।

चूंकि ऑपरेटर ओवरलोडिंग हमें ऑपरेटर के काम करने के तरीके को बदलने की अनुमति देता है, हम फिर से परिभाषित कर सकते हैं कि + ऑपरेटर कैसे काम करता है और निम्नलिखित कोड लिखकर c1 और c2 की जटिल संख्याओं को जोड़ने के लिए इसका उपयोग करता है:-

result = c1 + c2;

कुछ इस तरह के बजाय

result = c1.addNumbers(c2);

यह हमारे कोड को सहज और समझने में आसान बनाता है।

नोट: हम मौलिक डेटा प्रकारों जैसे इंट, फ्लोट, चार आदि के लिए ऑपरेटर ओवरलोडिंग का उपयोग नहीं कर सकते हैं।

Syntax for C++ Operator Overloading

एक ऑपरेटर को ओवरलोड करने के लिए, हम एक विशेष ऑपरेटर फ़ंक्शन का उपयोग करते हैं। हम उस वर्ग या संरचना के अंदर फ़ंक्शन को परिभाषित करते हैं जिसके ऑब्जेक्ट/वेरिएबल के साथ हम ओवरलोडेड ऑपरेटर को काम करना चाहते हैं।

class className {
    ... .. ...
    public
       returnType operator symbol (arguments) {
           ... .. ...
       } 
    ... .. ...
};

यहाँ देखें :-

  • रिटर्न टाइप फ़ंक्शन का रिटर्न प्रकार है।
  • ऑपरेटर एक कीवर्ड है।
  • प्रतीक वह ऑपरेटर है जिसे हम अधिभारित करना चाहते हैं। जैसे: +, <, -, ++, आदि।
  • तर्क समारोह में पारित तर्क है।

Operator Overloading in Unary Operators

यूनरी ऑपरेटर केवल एक ऑपरेंड पर काम करते हैं। इंक्रीमेंट ऑपरेटर ++ और डिक्रीमेंट ऑपरेटर — यूनरी ऑपरेटर्स के उदाहरण हैं।

Example1: ++ Operator (Unary Operator) Overloading

// Overload ++ when used as prefix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Output:-

Count: 6

यहां, जब हम ++count1; का उपयोग करते हैं, तो शून्य ऑपरेटर ++ () कहा जाता है। यह ऑब्जेक्ट काउंट 1 के लिए मान विशेषता को 1 से बढ़ा देता है।

नोट: जब हम ऑपरेटरों को ओवरलोड करते हैं, तो हम इसे किसी भी तरह से काम करने के लिए उपयोग कर सकते हैं। उदाहरण के लिए, हम मान को 100 तक बढ़ाने के लिए ++ का उपयोग कर सकते थे।

हालाँकि, यह हमारे कोड को भ्रमित करने वाला और समझने में कठिन बनाता है। एक प्रोग्रामर के रूप में यह हमारा काम है कि हम ऑपरेटर ओवरलोडिंग का ठीक से और सुसंगत और सहज तरीके से उपयोग करें।

उपरोक्त उदाहरण तभी काम करता है जब ++ को उपसर्ग के रूप में प्रयोग किया जाता है। ++ को पोस्टफिक्स के रूप में काम करने के लिए हम इस सिंटैक्स का उपयोग करते हैं।

void operator ++ (int) {
    // code
}

कोष्ठक के अंदर int पर ध्यान दें। यह यूनरी ऑपरेटरों को पोस्टफिक्स के रूप में उपयोग करने के लिए उपयोग किया जाने वाला वाक्यविन्यास है; यह एक फ़ंक्शन पैरामीटर नहीं है।

Example 2: ++ Operator (Unary Operator) Overloading

// Overload ++ when used as prefix and postfix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}


    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }


    // Overload ++ when used as postfix
    void operator ++ (int) {
        value++;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ (int)" function
    count1++;
    count1.display();

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Output:-

Count: 6
Count: 7

उदाहरण 2 तब काम करता है जब ++ का उपयोग उपसर्ग और पोस्टफिक्स दोनों के रूप में किया जाता है। हालांकि, अगर हम ऐसा कुछ करने की कोशिश करते हैं तो यह काम नहीं करता है|

Count count1, result;

// Error
result = ++count1;

ऐसा इसलिए है क्योंकि हमारे ऑपरेटर फ़ंक्शन का रिटर्न प्रकार शून्य है। हम गणना को ऑपरेटर फ़ंक्शन के रिटर्न प्रकार के रूप में बनाकर इस समस्या को हल कर सकते हैं।

// return Count when ++ used as prefix

Count operator ++ () {
    // code
}

// return Count when ++ used as postfix

Count operator ++ (int) {
   // code
}

Example 3: Return Value from Operator Function (++ Operator)

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public
       :
    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    Count operator ++ () {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = ++value;

        return temp;
    }

    // Overload ++ when used as postfix
    Count operator ++ (int) {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = value++;

        return temp;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1, result;

    // Call the "Count operator ++ ()" function
    result = ++count1;
    result.display();

    // Call the "Count operator ++ (int)" function
    result = count1++;
    result.display();

    return 0;
}

Output:-

Count: 6
Count: 6

यहां, हमने उपसर्ग ऑपरेटर ओवरलोडिंग (prefix operator) के लिए निम्नलिखित कोड का उपयोग किया है:

// Overload ++ when used as prefix
Count operator ++ () {
    Count temp;

    // Here, value is the value attribute of the calling object
    temp.value = ++value;

    return temp;
}

पोस्टफिक्स ऑपरेटर ओवरलोडिंग के लिए कोड भी समान है। ध्यान दें कि हमने एक ऑब्जेक्ट अस्थायी बनाया है और इसके मान को ऑपरेटर फ़ंक्शन में वापस कर दिया है।

इसके अलावा, कोड पर ध्यान दें|

temp.value = ++value; 

परिवर्तनीय मान मुख्य () में गिनती 1 ऑब्जेक्ट से संबंधित है क्योंकि गिनती 1 फ़ंक्शन को कॉल कर रहा है, जबकि अस्थायी मान अस्थायी ऑब्जेक्ट से संबंधित है।

Operator Overloading in Binary Operators

बाइनरी ऑपरेटर दो ऑपरेंड पर काम करते हैं। उदाहरण के लिए,

result = num + 9;

यहां, + एक बाइनरी ऑपरेटर है जो ऑपरेंड संख्या और 9 पर काम करता है।

जब हम कोड का उपयोग करके उपयोगकर्ता-परिभाषित प्रकारों के लिए बाइनरी ऑपरेटर को अधिभारित करते हैं:

obj3 = obj1 + obj2;

ऑपरेटर फ़ंक्शन को obj1 ऑब्जेक्ट का उपयोग करके कॉल किया जाता है और obj2 को फ़ंक्शन के तर्क के रूप में पास किया जाता है।

Example 4: C++ Binary Operator Overloading

// C++ program to overload the binary operator +
// This program adds two complex numbers

#include <iostream>
using namespace std;

class Complex {
   private:
    float real;
    float imag;

   public:
    // Constructor to initialize real and imag to 0
    Complex() : real(0), imag(0) {}

    void input() {
        cout << "Enter real and imaginary parts respectively: ";
        cin >> real;
        cin >> imag;
    }

    // Overload the + operator
    Complex operator + (const Complex& obj) {
        Complex temp;
        temp.real = real + obj.real;
        temp.imag = imag + obj.imag;
        return temp;
    }

    void output() {
        if (imag < 0)
            cout << "Output Complex number: " << real << imag << "i";
        else
            cout << "Output Complex number: " << real << "+" << imag << "i";
    }
};

int main() {
    Complex complex1, complex2, result;

    cout << "Enter first complex number:\n";
    complex1.input();

    cout << "Enter second complex number:\n";
    complex2.input();

   // complex1 calls the operator function
   // complex2 is passed as an argument to the function
    result = complex1 + complex2;
    result.output();

    return 0;
}

Output:-

Enter first complex number:
Enter real and imaginary parts respectively: 9 5
Enter second complex number:
Enter real and imaginary parts respectively: 7 6
Output Complex number: 16+11i

इस प्रोग्राम में, ऑपरेटर फ़ंक्शन है:

Complex operator + (const Complex& obj) {
    // code
}

इसके बजाय, हम इस फंक्शन को इस तरह भी लिख सकते थे:-

Complex operator + (Complex obj) {
    // code
}

हालाँकि,

  • ऑपरेटर फ़ंक्शन के अंदर एक डुप्लिकेट ऑब्जेक्ट बनाने के बजाय कॉम्प्लेक्स 2 ऑब्जेक्ट को संदर्भित करके और हमारे कोड को कुशल बनाता है।
  • कॉन्स का उपयोग करना एक अच्छा अभ्यास माना जाता है क्योंकि यह ऑपरेटर फ़ंक्शन को कॉम्प्लेक्स 2 को संशोधित करने से रोकता है।

Things to Remember in C++ Operator Overloading

  1. दो ऑपरेटर = और & पहले से ही C++ में डिफ़ॉल्ट रूप से अतिभारित हैं। उदाहरण के लिए, एक ही वर्ग की वस्तुओं की प्रतिलिपि बनाने के लिए, हम सीधे = ऑपरेटर का उपयोग कर सकते हैं। हमें एक ऑपरेटर फ़ंक्शन बनाने की आवश्यकता नहीं है।
  2. ऑपरेटर ओवरलोडिंग ऑपरेटरों की प्राथमिकता और संबद्धता को नहीं बदल सकता है। हालांकि, अगर हम मूल्यांकन के क्रम को बदलना चाहते हैं, तो कोष्ठक का उपयोग किया जाना चाहिए।

ऐसे 4 ऑपरेटर हैं जिन्हें C++ में ओवरलोड नहीं किया जा सकता है। वे:
:: (दायरा संकल्प)
. (सदस्य चयन)
.* (सूचक के माध्यम से कार्य करने के लिए सदस्य चयन)
?: (टर्नरी ऑपरेटर)

Example:-

नीचे दिए गये code को आप रन करे और आउटपुट कमेंट करे |

#include <iostream>
using namespace std;

class Box
{
   public:

      double getVolume(void)
      {
         return length * breadth * height;
      }
      void setLength( double len )
      {
          length = len;
      }

      void setBreadth( double bre )
      {
          breadth = bre;
      }

      void setHeight( double hei )
      {
          height = hei;
      }
      // Overload + operator to add two Box objects.
      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};
// Main function for the program
int main( )
{
   Box Box1;                // Declare Box1 of type Box
   Box Box2;                // Declare Box2 of type Box
   Box Box3;                // Declare Box3 of type Box
   double volume = 0.0;     // Store the volume of a box here

   // box 1 specification
   Box1.setLength(6.0);
   Box1.setBreadth(7.0);
   Box1.setHeight(5.0);

   // box 2 specification
   Box2.setLength(12.0);
   Box2.setBreadth(13.0);
   Box2.setHeight(10.0);

   // volume of box 1
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;

   // volume of box 2
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:
   Box3 = Box1 + Box2;

   // volume of box 3
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;

   return 0;
}

इसका आउटपुट हमे कमेंट करके बताय|

धन्यवाद |

Previous articleDescribe about history of C programming language. |c interview questions and answers for freshers
Next articlefile input/output in c in hindi|सी में फाइल हैंडलिंग क्या है ?

LEAVE A REPLY

Please enter your comment!
Please enter your name here