class to which it (the operator) is applied. The operator function helps us in doing so.

The Syntax of declaration of an Operator function is as follows:

**Operator Operator_name**

For example, suppose that we want to declare an Operator function for ‘=’. We can do it as follows:

**operator =**

A Binary Operator can be defined either a member function taking one argument or a global function taking one arguments. For a Binary Operator X, a X b can be interpreted as either an operator X (b) or operator X (a, b).

For a Prefix unary operator Y, Ya can be interpreted as either a.operator Y ( ) or Operator Y (a).

For a Postfix unary operator Z, aZ can be interpreted as either a.operator Z(int) or Operator (Z(a),int).

The operator functions namely operator=, operator [ ], operator ( ) and operator? must be nonstatic member functions. Due to this, their first operands will be lvalues.

An operator function should be either a member or take at least one class object argument. The

operators new and delete need not follow the rule. Also, an operator function, which needs to

accept a basic type as its first argument, cannot be a member function.

**Some examples of declarations of operator functions are given below:**

class P { P operator ++ (int);//Postfix increment P operator ++ ( ); //Prefix increment P operator || (P); //Binary OR } Some examples of Global Operator Functions are given below: P operator – (P); // Prefix Unary minus P operator – (P, P); // Binary “minus” P operator - - (P &, int); // Postfix Decrement

We can declare these Global Operator Functions as being friends of any other class.

**Examples of operator overloading:**

**Operator overloading using friend. **

Class time { int r; int i; public: friend time operator + (const time &x, const time &y ); // operator overloading using friend time ( ) { r = i = 0;} time (int x, int y) {r = x; i = y;} }; time operator + (const time &x, const time &y) { time z; z.r = x.r +y.r; z.i = x.i + y.i; return z; } main ( ) { time x,y,z; x = time (5,6); y = time (7,8); z = time (9, 10); z = x+y; // addition using friend function + }

Operator overloading using member function:

Class abc { char * str; int len ; // Present length of the string int max_length; // (maximum space allocated to string) public: abc ( ); // black string of length 0 of maximum allowed length of size 10. abc (const abc &s ) ;// copy constructor ~ abc ( ) {delete str;} int operator = = (const abc &s ) const; // check for equality abc & operator = (const abc &s ); // overloaded assignment operator friend abc operator + (const abc &s1, const abc &s2); } // string concatenation abc:: abc () { max_length = 10; str = new char [ max_length]; len = 0; str [0] = ‘\0’; } abc :: abc (const abc &s ) { len = s. len; max_length = s.max_length; str = new char [max_length]; strcpy (str, s.str); // physical copying in the new location. }