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 doesnt 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:

• 
  

  Using
  Friends to Overload all the Overloaded Arithmetic Operators

  
  


• 
  

  Class
  with all the Overloaded Arithmetic Operators

  
  


• 
  

  Overloading
  the Short-Hand Operators (+= and -=) using Friend Functions

  
  


• 
  

  Overloading
  Post-Fix Forms of ++ and -- Operators using Friend Functions

  
  


• 
  

  Overloading
  Increment/Decrement Operators using Friend Functions

  
  

Read More..

do while loop

Now we know about for, while loop that executed the statement within them finite number of times. However, in real life programming, one comes across a situation when it is not known beforehand how many times the statement in the loop are to be executed. In this situation we used do-while loop.

do-while tests the condition after having executed the statement within the loop i.e. do-while would executed its statement at least once, even if the condition fails for the first time. For example notice in following program:

/*demonstration of do-while*/

#include<stdio.h>

#include<conio.h>

void main()

{

 clrscr();

 do

 {

  printf("Its work!!");

 }while(10<1);

 getch();

}

Output of above program:

Its work!!

In above program, the printf() would be executed once, since first the body of loop is executed and then the condition tested, 10<1 condition false so loop terminate and go to next statement.

/*program to find factorial value of any number, and it is execute unknown number of times when user enter no, then program should be terminate.*/

#include<stdio.h>

#include<conio.h>

void main()

{

 int n,f=1;

 char choice;

 clrscr();

 do

 {

  printf("Enter number : ");

  scanf("%d",&n);

  while(n>=1)

  {

   f=f*n;

   n--;

  }

  printf("Factroial value of %d is %d",n,f);

  printf("
Calculate another value y/n :");

  scanf("%c",&choice);

 }while(choice==y);

}

output of above program:

Enter number :5

Factorial value of 5 is 120

Calculate another value y/n :y

Enter number :4

Factorial value of 4 is24

Calculate another value y/n :n

In above program, the do-while loop would keep getting executed till the user continues to answer y. When user enter answer n,the loop terminate, since the condition fails.

Read More..