7.1 Operator Overloading

Operator overloading refers to the ability to define a new meaning for an existing (built-in) "operator" The list of "operators" includes mathematical operators(+, -, *, /, ++, etc), relational operators ( <, >, ==, etc), logical operators (&&, ||, etc.), access operators ([], ->), assignment operator (=), stream I/O operators ( <<, >>), type conversion operators and several others. While all of these operator have a predefined and unchangeable meaning for the built-in types, all of these operators can be given a specific interpretation for different classes or combination of classes. C++ is particularly generous in the flexibility given to programmers in extending these built-in operators; not all object-oriented languages allow this.

There are a number of reasons why a class designer may decide to provide extensions to one or more of the built-in operators:

natural, suggestive usage

the most natural way to convey the intended meaning of an operation may be through the predefined operators. For example, in defining a class to represent complex or rational numbers the best way to represent adding to complex numbers or adding two rational numbers is by giving a new (extended) meaning to the "+" operator rather than to invent a member function with a suggestive name ("addTo").

semantic integrity

classes that have pointers to objects frequently need a specialized assignment operator in order to copy the objects being pointed to. The failure to properly handle assignment, as was seen earlier with the String class, leads to either memory leaks or run-time errors.

uniformity with base types

templates often impose requirements on their arguments that can only be met by both built-in types and user defined types when the user defined types provided overloaded operations. For example, a Set template may require that its instantiating type have an equality operator ("==") in order to implement the test for membership in the Set.

A simple example introducing operator overloading is a "safe" array of integers. The array is to be "safe" in the sense that the subscripting operation will insure that the subscript is within bounds. If the subscript is out of bounds, the program will terminate. The declaration of the safe array is:

   class Array {
    private:
      int array[20];
    public:
           Array(int init = 0);
      int& operator[](int i);	// overloaded subscript operator
          ~Array();
   };

   Array a;

   a[0] = 1;
   a[1] = 1;
   for (int i = 2; i < 20; i++)		// compute first 20 Fibonnaci numbers
       a[i] = a[i-1] + a[i-2];

        a.operator[](0)

       a[i] = a[i-1] + a[i-2];

	a.operator[](i) = a.operator[](i-1) + a.operator[](i-2);

Notice that aside from its declaration, the Array object looks and feels like a built-in array type. The similarity between them is also suggested by the following code that shows Arrays and built-in arrays being intermixed:

   Array safe;
   int   regular[20];

    // define contents of arrays safe and unsafe

    regular[10] = safe[10];
    safe[11]    = regular[11];
    safe[0]     = safe[0] + regular[0]

The implementation of the operator[] method would be written as follows:

   int& Array::operator[](int i) {
        assert(0 <= i && i < 20);
        return array[i];
   }

Two safe arrays may be added or subtracted by overloading the "+" operator and the "-" operator. The interface of the Array class would then be changed as follows:

   class Array
    private:
      int array[20];
    public:
             Array();
      int&   operator[](int i);		// subscript   operator
      Array& operator+(Array& other);	// addition    operator
      Array& operator-(Array& other);	// subtraction operator
            ~Array();
   };
   

The Array addition operator allows the following usages:

     Array a,b;		// initialized to 0
     Array one(1);	// initialized to 1

     // give values to arrays a and b

     Array& c = a + b;
     Array& d = a - b + one;

     

The compiler will, on encountering the expression "a + b" determine if there is a class specific overloading of the addition operator. Since "a" and "b" are objects of the Array class and this class contains an "operator+" method with matching argument types, the compiler will generate code that is the equivalent of:

	a.operator+(b)

	d = a - b + one

	Array& anonymous = a.operator-(b);
        d =anonymous.operator+(one);

The use of the default assignment operator in the Array class is sufficient. The default assignment operator simply performs a bit-level copy from the source to the target object. In this case, assignments such as:

	Array f, g;

        // assign values to g

	f = g;

The implementation of the Array addition and subtraction operators is as follows:

    Array& Array::operator+(Array& other) {
      Array *c = new Array;
      Array& result = *c;

      for(int i = 0; i< 20; i++) result[i] = array[i] + other.array[i];

      return result;
    }

    Array& Array::operator-(Array& other) {
      Array *c = new Array;
      Array& result = *c;

      for(int i = 0; i< 20; i++) result[i] = array[i] - other.array[i];

      return result;
    }

Exercises

1. Extend the Array class to include an operator that would allow each element of the array to be multiplied by a given constant. For example:

           Array  a;
           Array& b = a*6;  // multiple each element by 6
        

2. Extend the Array class to include a test for equality operator that returns 1 if all elements of the two Array objects are the same and 0 otherwise. For example:

           Array  a;
           Array  b;
   
           // give values to a and b
   
           if ( a == b) {// uses equality operator
                         // code for when they are equal
                        }