OOP – ASSIGNMENT IV

Lab Manual Download: Write a program in C++ to perform following operations on complex numbers Add, Subtract, Multiply, Divide, Complex conjugate. Design the class for complex number representation and the operations to be performed. The objective of this assignment is to learn the concepts classes and objects

ASSIGNMENT NO 4

Title: Demonstrate use of operator overloading for Complex class.

Objectives: 1) To understand concept of operator overloading.
2) To demonstrate overloading of binary operator, insertion and extraction operator.

Problem Statement: Write a program in C++ to perform following operations on complex numbers Add, Subtract, Multiply, Divide, Complex conjugate. Design the class for complex number representation and the operations to be performed. The objective of this assignment is to learn the concepts classes and objects

Outcomes: 1) Students will be able to demonstrate use of constructor
2) Students will be able to demonstrate binary operator overloading
3) Students will be able to demonstrate overloading of insertion and extraction
operator using friend function.

Hardware requirements: Any CPU with Pentium Processor or similar, 256 MB RAM or more, 1 GB Hard Disk or more.

Software requirements: 64 bit Linux/Windows Operating System, G++ compiler

Theory:

C++ allows you to specify more than one definition for a function name or an operator in the same scope, which is called function overloading and operator overloading respectively.
An overloaded declaration is a declaration that had been declared with the same name as a previously declared declaration in the same scope, except that both declarations have different arguments and obviously different definition (implementation). When you call an overloaded function or operator, the compiler determines the most appropriate definition to use by comparing the argument types you used to call the function or operator with the parameter types specified in the definitions. The process of selecting the most appropriate overloaded function or operator is called overload resolution.

Operator overloading is one of the special feature of C++. It also shows the extensibility of C++. C++ permits us to add two variables of user defined types with the same way that is applied with built in type data type. This refers to ability to provide special meaning for existing data type. This mechanism of giving such special meaning to an operator is known as overloading.

Operator overloading provides a flexible option for creation of new definition for most of the C++ operators. We can assign additional meaning to all existing C++ operators except following:
1) Class member access operators ( . , .*)
2) Scope resolution operator ( : : )
3) Size of operator (sizeof)
4) Conditional operator (? 😉
These operators are attributed to fact that an operator takes names as their operand instead of values.
Note: When an operator is overloaded, its original meaning is not lost. E. g. the operator +, which has been overloaded to add two vectors, can still be used to add two integers.

Definition Operator Overloading: To define an additional task to an operator, we must specify what it means in relation to class to which the operator is applied. This is done with the help of a special function, called operator function which describes the task.

Return type class_name : : operator op( argument list)
{
// Body of the function
// The task defined by overloaded operator
}
where:
return type is type of value returned by specified operation.
op is operator being overloaded.
operator is a keyword in C++

Operator function is no static member function or it may be friend function. A basic difference between them is that friend function will have only one argument for unary and binary operator whereas member function has no argument for unary operators and only one for binary operators. This is because the object used to invoke the member function is passé implicitly and therefore is available for member function. This is not the case with friend functions. Arguments may be passed either by value or by reference.

For defining an additional task to an operator, we must mention what is means in relation to the 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 =
You can overload the assignment operator (=) just as you can other operators and it can be used to create an object just like the copy constructor.

Unary operators overloading in C++: The unary operators operate on a single operand and following are the examples of Unary operators:
The increment (++) and decrement (–) operators.
The unary minus (-) operator.
The logical not (!) operator.
The unary operators operate on the object for which they were called and normally, this operator appears on the left side of the object, as in !obj, -obj, and ++obj but sometime they can be used as postfix as well like obj++ or obj–.

Binary operator overloading: In overloading binary operator, a friend function wil have two arguments, while a member function will have one argument.

Overloading binary operators using friends: Friend functions may be used in the place of member functions for overloading a binary operator. The only difference being that a friend function requires two arguments to be explicitly passed to it while a member function requires only one.
The same complex number program with friend function can be developed as friend complex operator +(complex, complex); and we will define this function as

complex operator + (complex a, complex b)
{
return complex ( c.x + b.x), (a.y + b.y) ;
}

in this case, the statement
c3 = c1 + c2;
is equal to c3 = operator + (c1, c2)

In certain situation it is require using a friend function rather than member function.

Rules for overloading operators:

  1. Only existing operators can be overloaded. New operators cannot be overloaded.
  2. The overloaded operator must have at least one operand that is of user defined type.
  3. We cannot change the basic meaning of an operator. That is to say, We cannot redefine the plus(+) operator to subtract one value from the other.
  4. Overloaded operators follow the syntax rules of the original operators. They cannot be overridden.
  5. There are some operators that cannot be overloaded like size of operator(sizeof), membership operator(.), pointer to member operator(.*), scope resolution operator(::), conditional operators(?:) etc
  6. We cannot use “friend” functions to overload certain operators. However, member function can be used to overload them. Friend Functions can not be used with assignment operator(=), function call operator(()), subscripting operator([]), class member access operator(->) etc.
  7. Unary operators, overloaded by means of a member function, take no explicit arguments and return no explicit values, but, those overloaded by means of a friend function, take one reference argument (the object of the relevant class).
  8. Binary operators overloaded through a member function take one explicit argument and those which are overloaded through a friend function take two explicit arguments.
  9. When using binary operators overloaded through a member function, the left hand operand must be an object of the relevant class.
  10. Binary arithmetic operators such as +,-,* and / must explicitly return a value. They must not attempt to change their own arguments.

 

Conclusion: Hence, we have studied, used and demonstrated use of binary operator overloading and insertion-extraction operator overloading using friend function.

 PROGRAM

//Program to demonstrate various operations on Complex class
#include<iostream>
using namespace std;
class Complex
{
    float real,img;
public:
//Constructor
Complex()
{
    real=0;
    img=0;
}
Complex(float a,float b)
{
    real=a;
    img=b;
}
//Addition of two complex numbers
Complex operator+(Complex c1)
{
    Complex temp;
    temp.real=real+c1.real;
    temp.img=img+c1.img;
    return temp;
}
//Subtraction of two complex numbers
Complex operator-(Complex c1)
{
    Complex temp;
    temp.real=real-c1.real;
    temp.img=img-c1.img;
    return temp;
}
//Multiplication of two complex numbers
Complex operator*(Complex c1)
{
    Complex temp;
    temp.real=(real*c1.real)-(img*c1.img);
    temp.img=(img*c1.real)+(real*c1.img);
    return temp;
}
//Division of two complex numbers
Complex operator/(Complex c1)
{
    Complex temp,c2;
    c2.img=-c1.img;
    float x;
    temp.real=(real*c1.real)-(img*(c2.img));
    temp.img=(real*c1.real)+(real*(c2.img));
    x=(c1.real)*(c1.real)+(c1.img)*(c1.img);
    temp.real=temp.real/x;
    temp.img=temp.img/x;
    return temp;
}
//overloaded insertion (<<) opertor for class Complex
    friend ostream &operator<<(ostream &out, Complex &c)
    {
        out << c.real<<" + "<< c.img<<" i";;
        return out;
    }
//overloaded extraction (>>) opertor for class Complex
    friend istream &operator>>(istream &in, Complex &c)
    {
        in>> c.real>>c.img;
        return in;
    }
};
int main()
{
Complex c1,c2,c3;
int choice;
char ans;
do
{
cout<<"\n************* MENU ************\n";
cout<<"\n\t1.Addition\n\t2.Subtraction\n\t3.Multiplication\n\t4.Division";
cout<<"\n\nEnter your choice: ";
cin>>choice;
cout<< "Enter real and img part of first complex number\n";
cin>>c1;
cout<< "Enter real and img part of second complex number\n";
cin>>c2;
switch(choice)
{
case 1:
    c3=c1+c2;
    cout<<"\n\nAddition is: ";
    cout<<c3;
break;
case 2:
    c3=c1-c2;
    cout<<"\n\nSubtraction is: ";
    cout<<c3;
break;
case 3:
    c3=c1*c2;
    cout<<"\n\nMultiplication is: ";
    cout<<c3;
break;
case 4:
    c3=c1/c2;
    cout<<"\n\nDivision is: ";
    cout<<c3;
break;
default:    
    cout<<"\nWrong choice";
}
    cout<<"\nDo you want to continue?(y/n): ";
    cin>>ans;
    }while(ans=='y' || ans=='Y');
return 0;
}

 

Leave a Reply

Your email address will not be published. Required fields are marked *