{"id":96,"date":"2018-07-10T05:49:39","date_gmt":"2018-07-10T05:49:39","guid":{"rendered":"http:\/\/itp1.epgpbooks.inflibnet.ac.in\/?post_type=chapter&p=96"},"modified":"2019-05-14T11:51:16","modified_gmt":"2019-05-14T11:51:16","slug":"96","status":"publish","type":"chapter","link":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/chapter\/96\/","title":{"rendered":"Operator Overloading"},"content":{"raw":"\r\n
\"epgp<\/a>\r\n<\/span><\/div>\r\n\r\nIntroduction\r\n\r\n \r\n\r\nConstructs like structure and class allow us to create our own data type. For example if we want to store date, we can create appropriate data type by creating class Time as follows:\r\n\r\n \r\n\r\n \r\n\r\n#include<iostream>\r\n\r\n#include<conio.h>\r\n\r\n \r\n\r\nusing namespace std;\r\n\r\n \r\n\r\nclass Time\r\n\r\n{\r\n\r\nprivate:\r\n\r\n \r\n\r\nint second;\r\n\r\nint minute;\r\n\r\nint hour;\r\n\r\n \r\n\r\npublic:\r\n\r\n \r\n\r\nTime();\r\n\r\n \r\n\r\nTime(int h, int m,int s);\r\n\r\nvoid displayTime();\r\n\r\nvoid readTime();\r\n\r\n \r\n\r\nTime addTime(Time t);\r\n\r\n \r\n\r\nTime subtractTime(Time t );\r\n\r\n \r\n\r\n};\r\n\r\n \r\n\r\nThis class will allow us to store time in a single variable like\r\n\r\n \r\n\r\nTime now;\r\n\r\n \r\n\r\nWhich otherwise would have required 3 integer variables for the same such as int hrs, min sec;\r\n\r\n \r\n\r\n \r\n

C++ by means of providing class construct empowers us to create our own data type, but the data type thus created is inferior to standard data type in many ways:<\/p>\r\n \r\n

    \r\n \t
  1. We cannot use operators provided by the language with the user defined data types to perform arithmetic, logical or other operations. For example the difference of two Time objects end_time and start_time cannot be computed using arithmetic operator (\u2013) minus. We need to do the same as follows<\/li>\r\n<\/ol>\r\n \r\n\r\ntime_diff = end_time.subtractTime(start_time) ;\r\n\r\n \r\n\r\nThe above statement achieves the goal but it is not as readable and clearas the following statement.\r\n\r\n \r\n\r\ntime_diff = end time \u2013 start_time ;\r\n\r\n \r\n\r\nThe above statement though very clear and readable, is not valid for the Time class that we have defined.\r\n\r\n \r\n
      \r\n \t
    1. We cannot read the objects of our class through cin and cout object as we read variable of standard data type. For example we read and write integer variable x as<\/li>\r\n<\/ol>\r\ncin\u00a0\u00a0\u00a0 >>\u00a0 x ;\r\n\r\ncout <<\u00a0 x ;\r\n\r\n \r\n\r\nBut we cannot read or write object of Time class as:\r\n\r\n \r\n\r\nTime now;\r\n\r\ncin\u00a0 >> now ;\r\n\r\ncout << now ;\r\n\r\n \r\n\r\nFor reading and writing Time object we will write following statements\r\n\r\n \r\n\r\nTime now;\r\n\r\nnow.readTime() ;\r\n\r\nnow.displayTime() ;\r\n
        \r\n \t
      1. Implicit type conversion is not done for the user defined data types. For example we cannot assign an integer value to our Time object as C++ does not provide implicit conversion of integer to Time object<\/li>\r\n<\/ol>\r\n
        \r\n\r\nTime current_time;\r\n\r\ncurrent_time = 10 ;\r\n\r\n\/\/ This will not work\r\n\r\n<\/div>\r\n \r\n

        We cannot be content with the fact that data type defined by us is inferior to standard data type. Well we do not need to be. The good news is that with little more work, it is possible to modify our class to compensate for the said deficiencies. For the first two shortcomings the desired can be achieved with the addition of appropriately overloaded operators to our class, which is the subject of this module and the next module. The third deficiency can be overcome by providing appropriate constructors and conversion functions for our class. That we will discuss in later module.<\/p>\r\n \r\n\r\nOperator Overloading\r\n\r\n \r\n

        Operator overloading means overloading existing operators with more tasks. For example operations such as subtraction of integers and subtraction of real numbers have already been defined for minus (\u2013) operator, we can define another task of subtracting two time objects for minus (\u2013) operator. This process of overloading operator with one more task is called operator overloading. We can overload unary as well as binary operators. Let us see how we can overload operators.<\/p>\r\n \r\n\r\n \r\n\r\nOverloading Binary Operator<\/strong>\r\n\r\n \r\n

        C++ allows us to overload an operator with the help of special function that we can add to our class. The syntax of function for overloading binary operator is given below<\/p>\r\n \r\n\r\nreturn_type operator operator_to_be_overloaded (class object)\r\n\r\n \r\n

        For our Time class we can overload the minus (\u2013 ) operator with yet another job, that is of finding difference of two Time objects. We can overload minus (\u2013) operator for finding difference of two Time objects as follows:<\/p>\r\n \r\n\r\nTime Time :: operator- ( Time t )\r\n\r\n{\r\n\r\n \r\n\r\nTime time;\r\n\r\nint seconds_1 , seconds_2 , seconds_diff ;\r\n\r\n\/\/ convert time into second\r\n\r\nseconds_1 = (hour *3600) + (minute * 60) + second ; seconds_2 = (t.hour * 3600) + (t.minute * 60) + t.second ;\r\n\r\nseconds_diff = seconds_1 - seconds_2 ;\r\n\r\ntime.hour = seconds_diff \/ 3600 ;\r\n\r\nseconds_diff = seconds_diff % 3600 ;\r\n\r\ntime.minute = seconds_diff \/60 ;\r\n\r\nseconds_diff = seconds_diff % 60 ;\r\n\r\ntime.second = seconds_diff ;\r\n\r\n \r\n\r\nreturn time;\r\n\r\n}\r\n\r\nOnce the above function is added to our class the following statement would work fine time_taken = end_time \u2013 start_time;\r\n\r\n \r\n

        Here time_taken, end_time and start_time are objects of Time class. Above statement would result in invoking overloaded minus (\u2013) operator function through end_time object, and start_time object will be passed as argument. The object containing the difference of time will be returned by the overloaded function, which will be stored in the variable time_taken.<\/p>\r\n \r\n\r\nOperators can also be overloaded for adding objects of other data type with the object of our class. For example minus (\u2013) operator can also be overloaded to make the following statement work.\r\n\r\n \r\n\r\nTime_difference = current_time \u2013 5;\r\n\r\nTo make this work, we need to overload minus (\u2013) operator as follows\r\n\r\nTime Time :: operator\u2013 ( int h )\r\n\r\n{\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
        Time diff;<\/td>\r\n<\/td>\r\n<\/tr>\r\n
        diff.hours<\/td>\r\n= hours \u2013 h;<\/td>\r\n<\/tr>\r\n
        diff.minutes = minutes;<\/td>\r\n<\/tr>\r\n
        diff.seconds<\/td>\r\n= seconds;<\/td>\r\n<\/tr>\r\n
        return diff;<\/td>\r\n<\/td>\r\n<\/tr>\r\n
        }<\/td>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n \r\n\r\n \r\n\r\n \r\n\r\nLet us see few more binary operators that can be overloaded for our Time class\r\n\r\n \r\n\r\nOverloading Relational Operator\r\n\r\nOverloading == operator\r\n\r\nint Time::operator==(Time t)\r\n\r\n{\r\n\r\nif(hour==t.hour && minute==t.minute && seconds==t.seconds)\r\n\r\nreturn 1;\r\n\r\nelse\r\n\r\nreturn 0;\r\n\r\n}\r\n\r\nOverloading > operator\r\n\r\n \r\n\r\nint Time :: operator >( Time t )\r\n\r\n{\r\n\r\nif( hour > t.hour )\r\n\r\nreturn 1;\r\n\r\nelse I f( hour == t.hour)\r\n\r\n{\r\n\r\nIf (minute > t.minute )\r\n\r\nreturn 1;\r\n\r\nelse I f( minute == t.minute )\r\n\r\n{\r\n\r\nIf (seconds>t.seconds)\r\n\r\nreturn 1;\r\n\r\nelse\r\n\r\nreturn 0;\r\n\r\n}\r\n\r\nelse\r\n\r\nreturn 0;\r\n\r\n}\r\n\r\nelse\r\n\r\nreturn 0;\r\n\r\n}\r\n\r\n \r\n\r\nWe can add above two functions to our Time class to have following code work for us\r\n\r\nTime t1 , t2 ;\r\n\r\nIf ( t1 > t2 )\r\n\r\nCout << \"Time T1 is Greater\";\r\n\r\nelse if ( t1 == t2)\r\n\r\ncout << \"Both time are equal\" ;\r\n\r\nelse\r\n\r\ncout << \"Time T2 is greater\" ;\r\n\r\n \r\n

        Here overloaded > and == operator functions will be invoked on object t1 and object t2 will be passed as argument.<\/p>\r\n\r\n

        \r\n\r\nOverloading shorthand operators\r\n\r\n \r\n

        We can also overload shorthand operators. Following function will overload shorthand operator (-=).<\/p>\r\n \r\n\r\nvoid Time :: operator-= ( Time t )\r\n\r\n{\r\n\r\n \r\n\r\nTime time;\r\n\r\n \r\n\r\nint seconds_1 , seconds_2 , seconds_diff ;\r\n\r\nseconds_1 = (hour *3600) + (minute * 60) + seconds ; seconds_2 = (t.hour * 3600) + (t.minute * 60) + t.seconds ;\r\n\r\nseconds_diff = seconds_1 - seconds_2 ;\r\n\r\nhour = seconds_diff \/ 3600 ;\r\n\r\nseconds_diff = seconds_diff % 3600 ;\r\n\r\nminute = seconds_diff \/60 ;\r\n\r\nseconds_diff = seconds_diff % 60 ;\r\n\r\nseconds = seconds_diff ;\r\n\r\n}\r\n\r\n \r\n\r\nWe can add above function to our Time class to have following code work for us\r\n\r\n \r\n\r\nTime t1, t2;\r\n\r\n \r\n\r\nt1 -=\u00a0 t2;\r\n\r\n \r\n\r\nHere overloaded (-=) operator function will be invoked on object t1 and object t2 will be passed as argument. Function will update t1 object with computed difference of Time objects t1 and t2.\r\n\r\n \r\n\r\nOverloading array subscript operator []<\/strong>\r\n\r\n \r\n\r\nIt is interesting to see how operators like comma operator, function call operator (), array subscript operator [] can be meaningfully overloaded for user defined data types. Let us see how array subscript operator can be meaning fully overloaded for our Time class.\r\n\r\n \r\n\r\nint Time :: operator []( char unit )\r\n\r\n{\r\n\r\nswitch(unit)\r\n\r\n{\r\n\r\n<\/div>\r\n

        \r\n\r\ncase 'h' :\r\n\r\ncase 'm' :\r\n\r\ncase 's'\u00a0 :\r\n\r\nreturn hour;\r\n\r\nreturn minute;\r\n\r\nreturn seconds;\r\n\r\n<\/div>\r\n
        \r\n\r\n}\r\n\r\n<\/div>\r\n}\r\n

        With the above function added to our class, we can get the hours, minutes and seconds of Time class objects printed as follows<\/p>\r\n \r\n\r\ncout<<\"\\n T1 Second is =\"<<t1['s'];\r\n\r\n \r\n\r\ncout<<\"\\n T1 Minute is =\"<<t1['m'];\r\n\r\ncout<<\"\\n T1 Hour is =\"<<t1['h'];\r\n\r\n \r\n

        Here object t1 will invoke the function and character \u2018h\u2019\/\u2019 m\u2019\/\u2019s\u2019 will be passed as argument. The function will return hours, minutes or seconds stored in t1 depending on the character passed.<\/p>\r\n \r\n\r\n \r\n\r\nOperator Functions<\/strong>\r\n\r\n \r\n

        We can also overload function call operator () for any class. Once we overload this operator, use of operator () with the object of the class will look like a function call. For example we can overload function call () operator on Matrix class to get the value stored on a specific row and column as follows<\/p>\r\n \r\n\r\nclass Matrix\r\n\r\n \r\n\r\n{\r\n\r\n \r\n\r\nint mat[20][20];\r\n\r\nint row, column;\r\n\r\npublic :\r\n\r\n\u2026\u2026\u2026\u2026..\r\n\r\n \r\n\r\n\u2026\u2026\u2026\u2026\r\n\r\nint operator() ( int r, int c);\r\n\r\n{\r\n\r\nreturn\u00a0 mat[r][c];\r\n\r\n}\r\n\r\n \r\n\r\n\u2026\u2026\u2026\u2026\u2026..\r\n\r\n \r\n\r\n\u2026\u2026\u2026\u2026\u2026..\r\n\r\n};\r\n\r\n \r\n\r\nWith the overloaded operator () for class Matrix, we can get the value of any matrix element as follows:\r\n\r\n\r\n\r\n\r\n\r\n
        Matrix m;<\/td>\r\n\/\/ element stored on 4th row and 5th column of matrix m<\/td>\r\n<\/tr>\r\n
        cout << m(4,5);<\/td>\r\n<\/tr>\r\n
        <\/td>\r\nwill be printed<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n \r\n

        Such objects are known as function objects. Here overloaded operator function will be invoked on object m and row and column will be passed as argument.<\/p>\r\n \r\n\r\nOverloading Unary Operator<\/strong>\r\n\r\n \r\n\r\nWe can also overload unary operators such as (++) and (--). The syntax of function for overloading unaryoperator is given below\r\n\r\nreturn_type operator operor_to_be_overloaded ();\r\n\r\nFor example operator function for overloading unary operator ++, when overloaded as member function will have following prototype:\r\n\r\nTime operator ++ ( );\r\n\r\nIt does not require any argument as unary operator has only one operand, which will be the invoking object, hence will be passed implicitly to the function.\r\n\r\n \r\n\r\nOverloading Increment and decrement operators<\/strong>\r\n\r\n \r\n\r\nC++ provides increment and decrement operator in two flavors - Postfix version & Prefix version\r\n\r\n \r\n\r\nTime now;\r\n\r\n \r\n\r\nnow++;\r\n\r\n \r\n\r\n++now;\r\n\r\n \r\n

        If we want both the versions of increment operator (++) to be overloaded, the prototype for both the operator functions will turn out to be identical. It will result into ambiguous situation for the compiler. To resolve this, C++ compiler allows us to define different prototypes for both the versions. To overload prefix version, prototype of operator function will be as follows:<\/p>\r\n \r\n\r\nTime operator++ ( );\r\n\r\n \r\n\r\nand to overload postfix version of increment operator (++) function prototype will be as follows:\r\n\r\n \r\n\r\nTime operator++ (int x);\r\n\r\n \r\n

        Here x is a dummy argument. It has no role in the function and has been defined only to distinguish between infix and postfix versions of (++) operator.<\/p>\r\n\r\n

        \r\n\r\nFollowing is the example of prefix and postfix increment (++) operator overloading:\r\n\r\n \r\n\r\n\/\/prefix version\r\n\r\nvoid Time :: operator ++( )\r\n\r\n{\r\n\r\n\/\/increment seconds\r\n\r\n \r\n\r\nseconds++ ;\r\n\r\n \r\n\r\nif(seconds==60)\r\n\r\n \r\n\r\n{\r\n\r\nseconds=0;\r\n\r\nminute++;\r\n\r\n \r\n\r\nif(minute==60)\r\n\r\n \r\n\r\n{\r\n\r\nminute=0;\r\n\r\nhour++;\r\n\r\n}\r\n\r\n}\r\n\r\n}\r\n\r\n \r\n\r\n\/\/postfix version\r\n\r\nvoid Time :: operator ++( int x )\r\n\r\n \r\n\r\n{\r\n\r\n\/\/increment seconds\r\n\r\nseconds++ ;\r\n\r\n \r\n\r\nif(seconds==60)\r\n\r\n \r\n\r\n{\r\n\r\nseconds=0;\r\n\r\n \r\n\r\nminute++;\r\n\r\n \r\n\r\nif(minute==60)\r\n\r\n \r\n\r\n{\r\n\r\nminute=0;\r\n\r\nhour++;\r\n\r\n}\r\n\r\n}\r\n\r\n \r\n\r\nBoth the versions for decrement operator (--) can also be overloaded in the similar fashion.\r\n\r\n<\/div>\r\n
        \r\n\r\nOperators that cannot be overloaded<\/strong>\r\n\r\n \r\n\r\nBarring few operators almost all operators can be overloaded. List of operators which cannot be overloaded is given below:\r\n\r\n1.\u00a0\u00a0\u00a0\u00a0\u00a0 Dot operator for member access (.)\r\n\r\n2.\u00a0\u00a0\u00a0\u00a0\u00a0 Dereference member to class operator (.*)\r\n\r\n3.\u00a0\u00a0\u00a0\u00a0\u00a0 Scope resolution operator (::)\r\n\r\n4.\u00a0\u00a0\u00a0\u00a0\u00a0 Size of operator (sizeof)\r\n\r\n5.\u00a0\u00a0\u00a0\u00a0\u00a0 Conditional ternary operator (?:)\r\n\r\n6.\u00a0\u00a0\u00a0\u00a0\u00a0 Casting operator (static_cast<>, dynamic_cast<>, reinterpret_cast<>, and const_cast<>)\r\n\r\n7.\u00a0\u00a0\u00a0\u00a0\u00a0 # and ## tokens for macro preprocessors\r\n\r\n \r\n

        One may ask why these operators cannot be overloaded. Consider overloading operator(.), which will give new meaning to member access function. This may result in creating ambiguous scenario for compiler \u2013 which can either result into serious errors or make compiler\u2019s job very complex.<\/p>\r\n \r\n

        Operator overloading as such is a complex problem to be managed by compiler, because of which perhaps many object oriented programming languages including JAVA do not provide operator overloading. Therefore this much liberty of not allowing few operators to be overloaded by C++ compiler perhaps is justified.<\/p>\r\n \r\n\r\nSummary<\/strong>\r\n\r\n \r\n

        By means of operator overloading we can use operators provided by the language, with the user defined data types to perform arithmetic, logical or other operations. Operator overloading is not essential feature for any object oriented programming language. As discussed before many object oriented programming languages including JAVA do not provide operator overloading. We can do without operator overloading but operator overloading provides significant advantages in terms of making code easy to read and manage (a very important quality factor for any program). It reduces the burden of programmer by eliminating the need to remember the function name and as name of function is not required; chances of spelling mistake is also not there. Also in context of C++ , overloading operators such as assignment operator = appropriately, resolve issues arising from scoping rules in certain cases. We will discuss this in detail in later module.<\/p>\r\n \r\n

        However operator overloading will yield full advantage when the new definition added to the operator is intuitive resulting into simple and easy to understand code.<\/p>\r\n\r\n<\/div>\r\n \r\n

        Following is the complete C++ program for overloading operators discussed above.<\/p>\r\n\"\"\r\n\r\n\"\"\r\n\r\n \r\n\r\n\"\"\r\n\r\n\"\"\r\n\r\n \r\n\r\n\"\"\r\n\r\n \r\n\r\n\r\n\r\n
        you can view video on Operator Overloading<\/strong><\/td>\r\n\"\"<\/a><\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n\r\n\r\nAdditional References<\/strong>\r\n\r\n \r\n\r\n1) Stanley Lippmann, \u201cC++ Primer\u201d, Pearson Education.\r\n\r\n2) Bjarne Stroustrup, \u201cThe C++ Programming Language\u201d, Pearson Education.\r\n\r\n3) Scott Mayer, \u201cEffective C++\u201d, Addison Wesley.\r\n\r\n4) Bhushan Trivedi , Programming with ANSI C++, 2\/e , Oxford University Press\r\n\r\n5) Yashavant P. Kanetkar \u201cLet Us C++\u201d , Bpb Publications.\r\n\r\n6) Abhiram G. Ranade, \u201cAn Introduction to Programming through C++\u201d , McGraw Hill\r\n\r\n7) Ellis and B. Stroustrup \u201cAnnotated C++ Reference Manual\u201d, http:\/\/www.stroustrup.com\/arm.html\r\n\r\n8) Herbert Schildt, \u201cComplete Reference C++\u201d, McGraw Hill Publications.\r\n\r\n9) Ashok Kamthane, \u201cObject Oriented Programming with ANSI and Turbo C++\u201d, Pearson Education\r\n\r\n10) E Balaguruswami, \u201cObject Oriented Programming With C++\u201d, Tata McGraw Hill\r\n\r\n11) \u201cC++ FAQs\u201d, Pearson Education.","rendered":"
        \"epgp<\/a>
        \n<\/span><\/div>\n

        Introduction<\/p>\n

         <\/p>\n

        Constructs like structure and class allow us to create our own data type. For example if we want to store date, we can create appropriate data type by creating class Time as follows:<\/p>\n

         <\/p>\n

         <\/p>\n

        #include<iostream><\/p>\n

        #include<conio.h><\/p>\n

         <\/p>\n

        using namespace std;<\/p>\n

         <\/p>\n

        class Time<\/p>\n

        {<\/p>\n

        private:<\/p>\n

         <\/p>\n

        int second;<\/p>\n

        int minute;<\/p>\n

        int hour;<\/p>\n

         <\/p>\n

        public:<\/p>\n

         <\/p>\n

        Time();<\/p>\n

         <\/p>\n

        Time(int h, int m,int s);<\/p>\n

        void displayTime();<\/p>\n

        void readTime();<\/p>\n

         <\/p>\n

        Time addTime(Time t);<\/p>\n

         <\/p>\n

        Time subtractTime(Time t );<\/p>\n

         <\/p>\n

        };<\/p>\n

         <\/p>\n

        This class will allow us to store time in a single variable like<\/p>\n

         <\/p>\n

        Time now;<\/p>\n

         <\/p>\n

        Which otherwise would have required 3 integer variables for the same such as int hrs, min sec;<\/p>\n

         <\/p>\n

         <\/p>\n

        C++ by means of providing class construct empowers us to create our own data type, but the data type thus created is inferior to standard data type in many ways:<\/p>\n

         <\/p>\n

          \n
        1. We cannot use operators provided by the language with the user defined data types to perform arithmetic, logical or other operations. For example the difference of two Time objects end_time and start_time cannot be computed using arithmetic operator (\u2013) minus. We need to do the same as follows<\/li>\n<\/ol>\n

           <\/p>\n

          time_diff = end_time.subtractTime(start_time) ;<\/p>\n

           <\/p>\n

          The above statement achieves the goal but it is not as readable and clearas the following statement.<\/p>\n

           <\/p>\n

          time_diff = end time \u2013 start_time ;<\/p>\n

           <\/p>\n

          The above statement though very clear and readable, is not valid for the Time class that we have defined.<\/p>\n

           <\/p>\n

            \n
          1. We cannot read the objects of our class through cin and cout object as we read variable of standard data type. For example we read and write integer variable x as<\/li>\n<\/ol>\n

            cin\u00a0\u00a0\u00a0 >>\u00a0 x ;<\/p>\n

            cout <<\u00a0 x ;<\/p>\n

             <\/p>\n

            But we cannot read or write object of Time class as:<\/p>\n

             <\/p>\n

            Time now;<\/p>\n

            cin\u00a0 >> now ;<\/p>\n

            cout << now ;<\/p>\n

             <\/p>\n

            For reading and writing Time object we will write following statements<\/p>\n

             <\/p>\n

            Time now;<\/p>\n

            now.readTime() ;<\/p>\n

            now.displayTime() ;<\/p>\n

              \n
            1. Implicit type conversion is not done for the user defined data types. For example we cannot assign an integer value to our Time object as C++ does not provide implicit conversion of integer to Time object<\/li>\n<\/ol>\n
              \n

              Time current_time;<\/p>\n

              current_time = 10 ;<\/p>\n

              \/\/ This will not work<\/p>\n<\/div>\n

               <\/p>\n

              We cannot be content with the fact that data type defined by us is inferior to standard data type. Well we do not need to be. The good news is that with little more work, it is possible to modify our class to compensate for the said deficiencies. For the first two shortcomings the desired can be achieved with the addition of appropriately overloaded operators to our class, which is the subject of this module and the next module. The third deficiency can be overcome by providing appropriate constructors and conversion functions for our class. That we will discuss in later module.<\/p>\n

               <\/p>\n

              Operator Overloading<\/p>\n

               <\/p>\n

              Operator overloading means overloading existing operators with more tasks. For example operations such as subtraction of integers and subtraction of real numbers have already been defined for minus (\u2013) operator, we can define another task of subtracting two time objects for minus (\u2013) operator. This process of overloading operator with one more task is called operator overloading. We can overload unary as well as binary operators. Let us see how we can overload operators.<\/p>\n

               <\/p>\n

               <\/p>\n

              Overloading Binary Operator<\/strong><\/p>\n

               <\/p>\n

              C++ allows us to overload an operator with the help of special function that we can add to our class. The syntax of function for overloading binary operator is given below<\/p>\n

               <\/p>\n

              return_type operator operator_to_be_overloaded (class object)<\/p>\n

               <\/p>\n

              For our Time class we can overload the minus (\u2013 ) operator with yet another job, that is of finding difference of two Time objects. We can overload minus (\u2013) operator for finding difference of two Time objects as follows:<\/p>\n

               <\/p>\n

              Time Time :: operator- ( Time t )<\/p>\n

              {<\/p>\n

               <\/p>\n

              Time time;<\/p>\n

              int seconds_1 , seconds_2 , seconds_diff ;<\/p>\n

              \/\/ convert time into second<\/p>\n

              seconds_1 = (hour *3600) + (minute * 60) + second ; seconds_2 = (t.hour * 3600) + (t.minute * 60) + t.second ;<\/p>\n

              seconds_diff = seconds_1 – seconds_2 ;<\/p>\n

              time.hour = seconds_diff \/ 3600 ;<\/p>\n

              seconds_diff = seconds_diff % 3600 ;<\/p>\n

              time.minute = seconds_diff \/60 ;<\/p>\n

              seconds_diff = seconds_diff % 60 ;<\/p>\n

              time.second = seconds_diff ;<\/p>\n

               <\/p>\n

              return time;<\/p>\n

              }<\/p>\n

              Once the above function is added to our class the following statement would work fine time_taken = end_time \u2013 start_time;<\/p>\n

               <\/p>\n

              Here time_taken, end_time and start_time are objects of Time class. Above statement would result in invoking overloaded minus (\u2013) operator function through end_time object, and start_time object will be passed as argument. The object containing the difference of time will be returned by the overloaded function, which will be stored in the variable time_taken.<\/p>\n

               <\/p>\n

              Operators can also be overloaded for adding objects of other data type with the object of our class. For example minus (\u2013) operator can also be overloaded to make the following statement work.<\/p>\n

               <\/p>\n

              Time_difference = current_time \u2013 5;<\/p>\n

              To make this work, we need to overload minus (\u2013) operator as follows<\/p>\n

              Time Time :: operator\u2013 ( int h )<\/p>\n

              {<\/p>\n\n\n\n\n\n\n\n\n
              Time diff;<\/td>\n<\/td>\n<\/tr>\n
              diff.hours<\/td>\n= hours \u2013 h;<\/td>\n<\/tr>\n
              diff.minutes = minutes;<\/td>\n<\/tr>\n
              diff.seconds<\/td>\n= seconds;<\/td>\n<\/tr>\n
              return diff;<\/td>\n<\/td>\n<\/tr>\n
              }<\/td>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

               <\/p>\n

               <\/p>\n

               <\/p>\n

              Let us see few more binary operators that can be overloaded for our Time class<\/p>\n

               <\/p>\n

              Overloading Relational Operator<\/p>\n

              Overloading == operator<\/p>\n

              int Time::operator==(Time t)<\/p>\n

              {<\/p>\n

              if(hour==t.hour && minute==t.minute && seconds==t.seconds)<\/p>\n

              return 1;<\/p>\n

              else<\/p>\n

              return 0;<\/p>\n

              }<\/p>\n

              Overloading > operator<\/p>\n

               <\/p>\n

              int Time :: operator >( Time t )<\/p>\n

              {<\/p>\n

              if( hour > t.hour )<\/p>\n

              return 1;<\/p>\n

              else I f( hour == t.hour)<\/p>\n

              {<\/p>\n

              If (minute > t.minute )<\/p>\n

              return 1;<\/p>\n

              else I f( minute == t.minute )<\/p>\n

              {<\/p>\n

              If (seconds>t.seconds)<\/p>\n

              return 1;<\/p>\n

              else<\/p>\n

              return 0;<\/p>\n

              }<\/p>\n

              else<\/p>\n

              return 0;<\/p>\n

              }<\/p>\n

              else<\/p>\n

              return 0;<\/p>\n

              }<\/p>\n

               <\/p>\n

              We can add above two functions to our Time class to have following code work for us<\/p>\n

              Time t1 , t2 ;<\/p>\n

              If ( t1 > t2 )<\/p>\n

              Cout << “Time T1 is Greater”;<\/p>\n

              else if ( t1 == t2)<\/p>\n

              cout << “Both time are equal” ;<\/p>\n

              else<\/p>\n

              cout << “Time T2 is greater” ;<\/p>\n

               <\/p>\n

              Here overloaded > and == operator functions will be invoked on object t1 and object t2 will be passed as argument.<\/p>\n

              \n

              Overloading shorthand operators<\/p>\n

               <\/p>\n

              We can also overload shorthand operators. Following function will overload shorthand operator (-=).<\/p>\n

               <\/p>\n

              void Time :: operator-= ( Time t )<\/p>\n

              {<\/p>\n

               <\/p>\n

              Time time;<\/p>\n

               <\/p>\n

              int seconds_1 , seconds_2 , seconds_diff ;<\/p>\n

              seconds_1 = (hour *3600) + (minute * 60) + seconds ; seconds_2 = (t.hour * 3600) + (t.minute * 60) + t.seconds ;<\/p>\n

              seconds_diff = seconds_1 – seconds_2 ;<\/p>\n

              hour = seconds_diff \/ 3600 ;<\/p>\n

              seconds_diff = seconds_diff % 3600 ;<\/p>\n

              minute = seconds_diff \/60 ;<\/p>\n

              seconds_diff = seconds_diff % 60 ;<\/p>\n

              seconds = seconds_diff ;<\/p>\n

              }<\/p>\n

               <\/p>\n

              We can add above function to our Time class to have following code work for us<\/p>\n

               <\/p>\n

              Time t1, t2;<\/p>\n

               <\/p>\n

              t1 -=\u00a0 t2;<\/p>\n

               <\/p>\n

              Here overloaded (-=) operator function will be invoked on object t1 and object t2 will be passed as argument. Function will update t1 object with computed difference of Time objects t1 and t2.<\/p>\n

               <\/p>\n

              Overloading array subscript operator []<\/strong><\/p>\n

               <\/p>\n

              It is interesting to see how operators like comma operator, function call operator (), array subscript operator [] can be meaningfully overloaded for user defined data types. Let us see how array subscript operator can be meaning fully overloaded for our Time class.<\/p>\n

               <\/p>\n

              int Time :: operator []( char unit )<\/p>\n

              {<\/p>\n

              switch(unit)<\/p>\n

              {<\/p>\n<\/div>\n

              \n

              case ‘h’ :<\/p>\n

              case ‘m’ :<\/p>\n

              case ‘s’\u00a0 :<\/p>\n

              return hour;<\/p>\n

              return minute;<\/p>\n

              return seconds;<\/p>\n<\/div>\n

              \n

              }<\/p>\n<\/div>\n

              }<\/p>\n

              With the above function added to our class, we can get the hours, minutes and seconds of Time class objects printed as follows<\/p>\n

               <\/p>\n

              cout<<“\\n T1 Second is =”<<t1[‘s’];<\/p>\n

               <\/p>\n

              cout<<“\\n T1 Minute is =”<<t1[‘m’];<\/p>\n

              cout<<“\\n T1 Hour is =”<<t1[‘h’];<\/p>\n

               <\/p>\n

              Here object t1 will invoke the function and character \u2018h\u2019\/\u2019 m\u2019\/\u2019s\u2019 will be passed as argument. The function will return hours, minutes or seconds stored in t1 depending on the character passed.<\/p>\n

               <\/p>\n

               <\/p>\n

              Operator Functions<\/strong><\/p>\n

               <\/p>\n

              We can also overload function call operator () for any class. Once we overload this operator, use of operator () with the object of the class will look like a function call. For example we can overload function call () operator on Matrix class to get the value stored on a specific row and column as follows<\/p>\n

               <\/p>\n

              class Matrix<\/p>\n

               <\/p>\n

              {<\/p>\n

               <\/p>\n

              int mat[20][20];<\/p>\n

              int row, column;<\/p>\n

              public :<\/p>\n

              \u2026\u2026\u2026\u2026..<\/p>\n

               <\/p>\n

              \u2026\u2026\u2026\u2026<\/p>\n

              int operator() ( int r, int c);<\/p>\n

              {<\/p>\n

              return\u00a0 mat[r][c];<\/p>\n

              }<\/p>\n

               <\/p>\n

              \u2026\u2026\u2026\u2026\u2026..<\/p>\n

               <\/p>\n

              \u2026\u2026\u2026\u2026\u2026..<\/p>\n

              };<\/p>\n

               <\/p>\n

              With the overloaded operator () for class Matrix, we can get the value of any matrix element as follows:<\/p>\n\n\n\n\n\n
              Matrix m;<\/td>\n\/\/ element stored on 4th row and 5th column of matrix m<\/td>\n<\/tr>\n
              cout << m(4,5);<\/td>\n<\/tr>\n
              <\/td>\nwill be printed<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

               <\/p>\n

              Such objects are known as function objects. Here overloaded operator function will be invoked on object m and row and column will be passed as argument.<\/p>\n

               <\/p>\n

              Overloading Unary Operator<\/strong><\/p>\n

               <\/p>\n

              We can also overload unary operators such as (++) and (–). The syntax of function for overloading unaryoperator is given below<\/p>\n

              return_type operator operor_to_be_overloaded ();<\/p>\n

              For example operator function for overloading unary operator ++, when overloaded as member function will have following prototype:<\/p>\n

              Time operator ++ ( );<\/p>\n

              It does not require any argument as unary operator has only one operand, which will be the invoking object, hence will be passed implicitly to the function.<\/p>\n

               <\/p>\n

              Overloading Increment and decrement operators<\/strong><\/p>\n

               <\/p>\n

              C++ provides increment and decrement operator in two flavors – Postfix version & Prefix version<\/p>\n

               <\/p>\n

              Time now;<\/p>\n

               <\/p>\n

              now++;<\/p>\n

               <\/p>\n

              ++now;<\/p>\n

               <\/p>\n

              If we want both the versions of increment operator (++) to be overloaded, the prototype for both the operator functions will turn out to be identical. It will result into ambiguous situation for the compiler. To resolve this, C++ compiler allows us to define different prototypes for both the versions. To overload prefix version, prototype of operator function will be as follows:<\/p>\n

               <\/p>\n

              Time operator++ ( );<\/p>\n

               <\/p>\n

              and to overload postfix version of increment operator (++) function prototype will be as follows:<\/p>\n

               <\/p>\n

              Time operator++ (int x);<\/p>\n

               <\/p>\n

              Here x is a dummy argument. It has no role in the function and has been defined only to distinguish between infix and postfix versions of (++) operator.<\/p>\n

              \n

              Following is the example of prefix and postfix increment (++) operator overloading:<\/p>\n

               <\/p>\n

              \/\/prefix version<\/p>\n

              void Time :: operator ++( )<\/p>\n

              {<\/p>\n

              \/\/increment seconds<\/p>\n

               <\/p>\n

              seconds++ ;<\/p>\n

               <\/p>\n

              if(seconds==60)<\/p>\n

               <\/p>\n

              {<\/p>\n

              seconds=0;<\/p>\n

              minute++;<\/p>\n

               <\/p>\n

              if(minute==60)<\/p>\n

               <\/p>\n

              {<\/p>\n

              minute=0;<\/p>\n

              hour++;<\/p>\n

              }<\/p>\n

              }<\/p>\n

              }<\/p>\n

               <\/p>\n

              \/\/postfix version<\/p>\n

              void Time :: operator ++( int x )<\/p>\n

               <\/p>\n

              {<\/p>\n

              \/\/increment seconds<\/p>\n

              seconds++ ;<\/p>\n

               <\/p>\n

              if(seconds==60)<\/p>\n

               <\/p>\n

              {<\/p>\n

              seconds=0;<\/p>\n

               <\/p>\n

              minute++;<\/p>\n

               <\/p>\n

              if(minute==60)<\/p>\n

               <\/p>\n

              {<\/p>\n

              minute=0;<\/p>\n

              hour++;<\/p>\n

              }<\/p>\n

              }<\/p>\n

               <\/p>\n

              Both the versions for decrement operator (–) can also be overloaded in the similar fashion.<\/p>\n<\/div>\n

              \n

              Operators that cannot be overloaded<\/strong><\/p>\n

               <\/p>\n

              Barring few operators almost all operators can be overloaded. List of operators which cannot be overloaded is given below:<\/p>\n

              1.\u00a0\u00a0\u00a0\u00a0\u00a0 Dot operator for member access (.)<\/p>\n

              2.\u00a0\u00a0\u00a0\u00a0\u00a0 Dereference member to class operator (.*)<\/p>\n

              3.\u00a0\u00a0\u00a0\u00a0\u00a0 Scope resolution operator (::)<\/p>\n

              4.\u00a0\u00a0\u00a0\u00a0\u00a0 Size of operator (sizeof)<\/p>\n

              5.\u00a0\u00a0\u00a0\u00a0\u00a0 Conditional ternary operator (?:)<\/p>\n

              6.\u00a0\u00a0\u00a0\u00a0\u00a0 Casting operator (static_cast<>, dynamic_cast<>, reinterpret_cast<>, and const_cast<>)<\/p>\n

              7.\u00a0\u00a0\u00a0\u00a0\u00a0 # and ## tokens for macro preprocessors<\/p>\n

               <\/p>\n

              One may ask why these operators cannot be overloaded. Consider overloading operator(.), which will give new meaning to member access function. This may result in creating ambiguous scenario for compiler \u2013 which can either result into serious errors or make compiler\u2019s job very complex.<\/p>\n

               <\/p>\n

              Operator overloading as such is a complex problem to be managed by compiler, because of which perhaps many object oriented programming languages including JAVA do not provide operator overloading. Therefore this much liberty of not allowing few operators to be overloaded by C++ compiler perhaps is justified.<\/p>\n

               <\/p>\n

              Summary<\/strong><\/p>\n

               <\/p>\n

              By means of operator overloading we can use operators provided by the language, with the user defined data types to perform arithmetic, logical or other operations. Operator overloading is not essential feature for any object oriented programming language. As discussed before many object oriented programming languages including JAVA do not provide operator overloading. We can do without operator overloading but operator overloading provides significant advantages in terms of making code easy to read and manage (a very important quality factor for any program). It reduces the burden of programmer by eliminating the need to remember the function name and as name of function is not required; chances of spelling mistake is also not there. Also in context of C++ , overloading operators such as assignment operator = appropriately, resolve issues arising from scoping rules in certain cases. We will discuss this in detail in later module.<\/p>\n

               <\/p>\n

              However operator overloading will yield full advantage when the new definition added to the operator is intuitive resulting into simple and easy to understand code.<\/p>\n<\/div>\n

               <\/p>\n

              Following is the complete C++ program for overloading operators discussed above.<\/p>\n

              \"\"<\/p>\n

              \"\"<\/p>\n

               <\/p>\n

              \"\"<\/p>\n

              \"\"<\/p>\n

               <\/p>\n

              \"\"<\/p>\n

               <\/p>\n\n\n\n
              you can view video on Operator Overloading<\/strong><\/td>\n\"\"<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

              Additional References<\/strong><\/p>\n

               <\/p>\n

              1) Stanley Lippmann, \u201cC++ Primer\u201d, Pearson Education.<\/p>\n

              2) Bjarne Stroustrup, \u201cThe C++ Programming Language\u201d, Pearson Education.<\/p>\n

              3) Scott Mayer, \u201cEffective C++\u201d, Addison Wesley.<\/p>\n

              4) Bhushan Trivedi , Programming with ANSI C++, 2\/e , Oxford University Press<\/p>\n

              5) Yashavant P. Kanetkar \u201cLet Us C++\u201d , Bpb Publications.<\/p>\n

              6) Abhiram G. Ranade, \u201cAn Introduction to Programming through C++\u201d , McGraw Hill<\/p>\n

              7) Ellis and B. Stroustrup \u201cAnnotated C++ Reference Manual\u201d, http:\/\/www.stroustrup.com\/arm.html<\/p>\n

              8) Herbert Schildt, \u201cComplete Reference C++\u201d, McGraw Hill Publications.<\/p>\n

              9) Ashok Kamthane, \u201cObject Oriented Programming with ANSI and Turbo C++\u201d, Pearson Education<\/p>\n

              10) E Balaguruswami, \u201cObject Oriented Programming With C++\u201d, Tata McGraw Hill<\/p>\n

              11) \u201cC++ FAQs\u201d, Pearson Education.<\/p>\n","protected":false},"author":4,"menu_order":11,"template":"","meta":{"pb_show_title":"on","pb_short_title":"","pb_subtitle":"","pb_authors":["dr-jyoti-pareek"],"pb_section_license":""},"chapter-type":[],"contributor":[58],"license":[],"class_list":["post-96","chapter","type-chapter","status-publish","hentry","contributor-dr-jyoti-pareek"],"part":3,"_links":{"self":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters\/96","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters"}],"about":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/types\/chapter"}],"author":[{"embeddable":true,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/users\/4"}],"version-history":[{"count":7,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters\/96\/revisions"}],"predecessor-version":[{"id":399,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters\/96\/revisions\/399"}],"part":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/parts\/3"}],"metadata":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters\/96\/metadata\/"}],"wp:attachment":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/media?parent=96"}],"wp:term":[{"taxonomy":"chapter-type","embeddable":true,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapter-type?post=96"},{"taxonomy":"contributor","embeddable":true,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/contributor?post=96"},{"taxonomy":"license","embeddable":true,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/license?post=96"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}