Ad

Sunday, August 26, 2007

Adding Flexibility to Operators while Overloading them

  class_name class_name::operator+(int x)
  {
    class_name temp;

    temp.a = a + x;
    temp.b = b + x;

    return temp;
  }

With reference to the above operator function and supposing that ‘ob’ is an object of the class to which this function belongs; Is the statement below legal:

ob2 = ob1 + 100;

Yes, but what about the following statement:

ob2 = 100 + ob1;

Surely this won’t work!

100 is an integer constant and has no ‘+’ operator that could add it with user-defined types (object ‘ob’).

This certainly is a shortcoming, since often we don’t really care which operand is where (as in addition and multiplication) and we order the operands as necessary (as in subtraction and division).

To overcome this we can overload two-two versions of these operators as friend, one for ‘integer + object’ type and the other for ‘object + integer’ type.

So, for example for addition we have to overload the ‘+’ operator twice as below:

  friend class_name operator+(class_name,int);
  friend class_name operator+(int,class_name);

Similarly we have to overload other operators.

The program below illustrates this concept:


  // Program to illustrate
  // the overloading of
  // flexible addition
  // and subtraction
  // operators
  #include <iostream.h>

  class myclass
  {
    int a;
    int b;

  public:
    myclass(){}
    myclass(int x,int y){a=x;b=y;}
    void show()
    {
      cout<<a<<endl<<b<<endl;
    }

    // object + int form
    friend myclass operator+(myclass,int);
    friend myclass operator-(myclass,int);

    // int + object form
    friend myclass operator+(int,myclass);
    friend myclass operator-(int,myclass);
  };

  myclass operator+(myclass ob,int x)
  {
    myclass temp;

    temp.a = ob.a + x;
    temp.b = ob.b + x;

    return temp;
  }

  myclass operator-(myclass ob, int x)
  {
    myclass temp;

    temp.a = ob.a - x;
    temp.b = ob.b - x;

    return temp;
  }

  myclass operator+(int x, myclass ob)
  {
    // does the same thing
    // because in addition
    // it doesn't matters
    // which operand is where
    myclass temp;

    temp.a = x + ob.a;
    temp.b = x + ob.b;

    return temp;
  }

  myclass operator-(int x, myclass ob)
  {
    myclass temp;

    temp.a = x - ob.a;
    temp.b = x - ob.b;

    return temp;
  }

  void main()
  {
    myclass a(10,20);
    myclass b(100,200);

    a=a + 10;
    a.show();

    b=100 + b;
    b.show();
  }

Related Articles:

1 comment:

You are free to comment anything, although you can comment as 'Anonymous' it is strongly recommended that you supply your name. Thank You.

Please don't use abusive language.