Explore topic-wise InterviewSolutions in .

+ operator is overloaded

Answer is (b) +

(d) return 0;

class sale 

{

int cost, discount;

public:

sale (sale&);

};

// non inline constructor

sale: : sale(sale&s)

{

cost = s.cost;

discount = s.discount;

}

add (int temp)

{

x = temp;

}

(b) Overloaded operators

(i) Objects: ob and obi of main ()

(ii) object ob of void operator = = (comp ob);

(iii) Overloaded operator: = = Statement that invokes: ob = = ob1; (v) void operator = = (comp ob):

(v) Operands used are the objects of the class comp

(vi) The default constructor generated by the compiler will be executed.[comp();]

Output 1

Enter first string: hello

Enter second string: hello String are equal

Output 2

Enter first string: hello

Enter second string: fine String are not equal

Function overloading can be applied for constructors, as constructors are special functions of classes. A class can have more than one constructor with different signature. Constructor overloading provides flexibility of creating multiple type of objects for a class.

1. Memory is allocated for the objects.

2. Initialisation for the objects.

#include

using namespace std;

class add

{

int num1, num2, sum; 

public:

add()

{

cout << “\n Constructor without parameters…”; 

num1 = 0;

num2 = 0;

sum = 0;

}

add (int s1, int s2 )

{

cout << “\n Parameterized constructor…”;

num1= s1;

num2=s2;

sum=0;

}

add (add &a)

{

cout << “\n Copy Constructor…”; ‘

num1 = a.num1;

num2 = a.num2;

sum = 0;

}

void getdata()

{

cout<<“\n Enter data …”; cin>>num 1 >> num2;

}

void addition()

{

sum=num 1 + num2;

}

void putdata()

{

cout << “\n The numbers are..”;

cout <cout << “\n The sum of the numbers are..” << sum; }

};

int main()

{

add a, b (10, 20), c(b);

a. getdata();

a. addition();

b. addition();

c. addition();

cout << “\n Object a : “;

a. putdata();

cout << “\n Object b : “;

b. putdata();

cout << “\n Object c..”;

c. putdata();

return 0; 

}

Output: 

value of x is 7 

value of x is 9.132 

value of x and y is 85,64

When you call an overloaded function, the compiler determines the most appropriate definition . to use, by comparing the argument types you have used to callthe function with the parameter types specified in the definitions. The process of selecting the most appropriate overloaded function or operator is called overload resolution.

(a) overload resolution

(a) operator overloading

Function overloading is not only implementing polymorphism but also reduces the number of comparisons in a program and makes the program to execute faster. It also helps the programmer by reducing the number of function names to be remembered.

No. The return type of overloaded functions are not considered for overloading same data type.

The ability of the function to process the message or data in more than one form is called as function overloading. In other words function overloading means two or more functions in the same scope share the same name but their parameters are different.

Operator that are not overloaded are follows:

1. scope operator ::

2. sizeof

3. member selector.

4. member pointer selector *

5. ternary operator ?:

Rules for function overloading: 

1. The overloaded function must differ in the number of its arguments or data types. 

2. The return type of overloaded functions are not considered for overloading same data type.

3. The default arguments of overloaded functions are not considered as part of the parameter list in function overloading.

When you call an overloaded function (when there are many functions with same name), the compiler determines the most appropriate definition to use by comparing the argument types used to call the function with the parameter types specified in the definitions. The process of selecting the most appropriate overloaded function or operator is called overload resolution.

Example:

#include using namespace std; void print (int i)

{

cout<< “It is integer” <<i<<endl;

}

void print (string c)

{

cout<< “It is string”<< c<<endl;

}

int main ()

{

print (10);

print (“Good”);

return 0;

}

Output:

It is integer 10

It is string Good

The term operator overloading, refers to giving additional functionality to the normal C++ operators like It is also a type of polymorphism in which an operator is overloaded to give user defined meaning to it.

For example ‘+’ operator can be overloaded to perform addition on various data types, like for Integer, String (concatenation) etc.

Following are some rules to be followed while implementing operator overloading.

1. Precedence and Associativity of an operator cannot be changed.

2. No new operators can be created, only existing operators can be overloaded.

3. Cannot redefine the meaning of an operator’s procedure. You cannot change how integers are added. Only additional functions can be to an operator.

4. Overloaded operators cannot have default arguments.

5. When binary operators are overloaded, the left hand object must be an object of the relevant class.

1. Constructor overloading (function 1 and function 4 are constructors with different signatures in the class book)

2. Function 3 is destructor of the class. Function 3 is executed when the object of the class book goes out of scope.

3. Function 3 is destructor of the class.

• Destructor (function3) will free resources if any that the object may have acquired during its lifetime 
• Destructor function removes the memory of an object which was allocated by the constructor at the time of creating an object. Thus frees the unused memory.
• 4. book b;
• b.display (4.5);

5. Book: :Book (int sc.char.s[], float, F) //

Function 4

{

Book Code = SC

strcpy (Book name, S);

fees = F;

}

(c) data type

(d) F1, F3, F4