Centre for Distance & Online Education

INTERNAL ASSIGNMENT ANSWERS

SESSION SEPTEMBER 2024
PROGRAM BACHELOR OF COMPUTER APPLICATIONS (BCA)
SEMESTER II
COURSE CODE & NAME DCA1203 – OBJECT ORIENTED PROGRAMMING –
C++
CREDITS 4
NUMBER OF ASSIGNMENTS & 02
MARKS 30

SET – I
1. Explain the concept of operator overloading in C++. Why is it important, and how
does it enhance the capabilities of the language?
Ans. Operator overloading is a powerful feature in C++ that allows
developers to redefine the behavior of operators when working with user-defined data types,
such as classes and structures. This feature enables developers to create more intuitive and
expressive code, making their programs more efficient, readable, and maintainable.
Operator Overloading is important for the following reasons:
1. Intuitive syntax: Operator overloading enables developers to use operators in a more natural
way, making their code more readable and intuitive. For example, when working with complex
numbers, it's more natural to use the + operator to add two complex numbers instead of calling
a function like addComplexNumbers().
2. Increased expressiveness: Operator overloading allows developers to create more expressive
code, which can convey the intent of the program more effectively. This can lead to better code
readability and maintainability.
3. Improved code reusability: Operator overloading enables developers to write more generic
code that can work with different data types. This can lead to better code reusability and
reduced code duplication.
operator overloading enhance the capabilities of the language:
1. Enables generic programming: Operator overloading allows developers to write generic code
that can work with different data types. This is particularly useful when working with
templates, where the same code needs to work with different data types.
2. Supports domain-specific languages: Operator overloading enables developers to create
domain-specific languages (DSLs) that can be used to solve specific problems. For example, a
DSL for linear algebra might overload operators to perform matrix operations.

Page 1
 Centre for Distance & Online Education
3. Improves code readability and maintainability: Operator overloading enables developers to
write more readable and maintainable code. By using operators in a more natural way,
developers can create code that is easier to understand and modify.
Here's an example of operator overloading for a ComplexNumber class:
class ComplexNumber {
private:
double real;
double imaginary;
public:
ComplexNumber(double real, double imaginary)
: real(real), imaginary(imaginary) {}
// Overload the + operator
ComplexNumber operator+(const ComplexNumber& other) const {
return ComplexNumber(real + other.real, imaginary + other.imaginary);
}
// Overload the << operator for printing
friend std::ostream& operator<<(std::ostream& os, const ComplexNumber& num) {
os << "(" << num.real << ", " << num.imaginary << ")";
return os;
}
};
int main() {
ComplexNumber num1(3.0, 4.0);
ComplexNumber num2(2.0, 1.0);

ComplexNumber sum = num1 + num2;

std::cout << "Sum: " << sum << std::endl;
return 0;
}

Page 2
 Centre for Distance & Online Education

In this example, we've overloaded the + operator to add two complex numbers. We've also
overloaded the << operator to print complex numbers in a more readable format.

2. What is the purpose of access specifiers in a class? Name the three access specifiers
available in C++?
Ans. The primary purpose of access specifiers in a class is to control access
to the class members (data members and member functions) from outside the class. Access
specifiers determine the visibility and accessibility of class members, helping to encapsulate
data and ensure data hiding.
The three access specifiers available in C++ are:
1. Public: Members declared as public are accessible from anywhere in the program, both
within and outside the class. This means that any part of the program can access and modify
public members.
2. Private: Members declared as private are accessible only within the class itself. They are not
accessible directly from outside the class, helping to encapsulate data and prevent unauthorized
access.
3. Protected: Members declared as protected are accessible within the class itself and also
within any derived classes (i.e., classes that inherit from the current class). They are not
accessible directly from outside the class or its derived classes.
By using these access specifiers, you can control how class members are accessed and
modified, helping to promote encapsulation, data hiding, and code organization.
Here's an example:
class MyClass {
public:
void publicMethod() { cout << "Public method"; }
private:
int privateData;
protected:
void protectedMethod() { cout << "Protected method"; }
};

Page 3
 Centre for Distance & Online Education
In this example, publicMethod() can be accessed from anywhere, privateData can only be
accessed within MyClass, and protectedMethod() can be accessed within MyClass and any
derived classes.

3. What do you understand by constant, keyword and identifier?

Ans. Here's what I understand by each of these terms:
Constant
A constant is a value that cannot be changed once it is assigned. Constants are used to represent
values that remain the same throughout the execution of a program. In C++, constants can be
declared using the const keyword.
Keyword
A keyword is a reserved word in a programming language that has a special meaning.
Keywords are used to define the structure and syntax of a program. In C++, keywords include
words like if, else, for, while, class, etc. Keywords cannot be used as variable names or
identifiers.
Identifier
An identifier is a name given to a variable, function, class, or other entity in a program.
Identifiers are used to uniquely identify and reference these entities. In C++, identifiers can be
composed of letters (both uppercase and lowercase), digits, and underscores. However, they
must start with a letter or underscore. Identifiers are case-sensitive, meaning that myVariable
and MyVariable are treated as two different identifiers.
Here's an example to illustrate the difference:
const int MAX_SIZE = 10; // MAX_SIZE is a constant

int myVariable = 5; // myVariable is an identifier

if (myVariable > 0) { // if is a keyword

// code here
}

Page 4
 Centre for Distance & Online Education
SET-II
4. Explain with the help of an example the method to implement a class template?
Ans. Here's an example of how to implement a class template in C++:
Implementing a Class Template for a Generic Pair Class

// pair.h (header file)

#ifndef PAIR_H
#define PAIR_H
template <typename T1, typename T2>
class Pair {
private:
T1 first;
T2 second;
public:
// Constructor
Pair(T1 first, T2 second) : first(first), second(second) {}

// Getter methods
T1 getFirst() const { return first; }
T2 getSecond() const { return second; }

// Setter methods
void setFirst(T1 value) { first = value; }
void setSecond(T2 value) { second = value; }
};
#endif // PAIR_H
// main.cpp (implementation file)
#include <iostream>

Page 5
 Centre for Distance & Online Education
#include "pair.h"
int main()
{
// Create a Pair object with int and double types
Pair<int, double> pair1(10, 3.14);
std::cout << "Pair 1: (" << pair1.getFirst() << ", " << pair1.getSecond() << ")" << std::endl;

// Create a Pair object with string and int types

Pair<std::string, int> pair2("Hello", 42);
std::cout << "Pair 2: (" << pair2.getFirst() << ", " << pair2.getSecond() << ")" << std::endl;

return 0;
}
In this example:
1. We define a class template Pair with two template parameters T1 and T2.
2. The class has two private member variables first and second of types T1 and T2, respectively.
3. We provide a constructor, getter methods, and setter methods for the class.
4. In the main function, we create two Pair objects with different type combinations (int and
double, std::string and int) and demonstrate how to use the class template.
This example illustrates how class templates enable generic programming in C++, allowing
you to write reusable code that can work with various data types.

5. List and explain the STL Components.

Ans. The Standard Template Library (STL) is a collection of C++ template
classes that provide common data structures and algorithms. The STL components can be
broadly categorized into four main parts:
1. Containers: These are data structures that store and manage collections of data. The STL
provides several container classes, including:
- vector: a dynamic array that can grow or shrink as elements are added or removed.
- list: a doubly-linked list that allows efficient insertion and deletion of elements.

Page 6
 Centre for Distance & Online Education
- deque: a double-ended queue that allows efficient insertion and deletion of elements at
both ends.
- set: a sorted set of unique elements that allows efficient lookup and insertion.
- map: a sorted map of key-value pairs that allows efficient lookup and insertion.
- stack: a last-in, first-out (LIFO) stack that allows efficient push and pop operations.
- queue: a first-in, first-out (FIFO) queue that allows efficient enqueue and dequeue
operations.
2. Iterators: These are objects that allow traversal of the elements in a container. The STL
provides several iterator classes, including:
- iterator: a general-purpose iterator that allows traversal of the elements in a container.
- const_iterator: a constant iterator that allows traversal of the elements in a container
without modifying them.
- reverse_iterator: a reverse iterator that allows traversal of the elements in a container in
reverse order.
3. Algorithms: These are functions that perform common operations on containers, such as
sorting, searching, and manipulating elements. The STL provides several algorithm functions,
including:
- sort: sorts the elements in a container in ascending order.
- search: searches for a specific element in a container.
- find: finds the first occurrence of a specific element in a container.
- count: counts the number of occurrences of a specific element in a container.
- copy: copies the elements from one container to another.
4. Function Objects: These are objects that can be used as functions. The STL provides several
function object classes, including:
- less: a function object that compares two elements using the less-than operator.
- greater: a function object that compares two elements using the greater-than operator.
- equal_to: a function object that compares two elements using the equality operator.
These STL components can be used together to write efficient and generic code that can work
with a wide range of data structures and algorithms.

Page 7
 Centre for Distance & Online Education
6. Describe the different types of inheritance in C++.
Ans. In C++, inheritance is a mechanism where one class (the derived
class or subclass) inherits the properties and behavior of another class (the base class or
superclass).
There are five types of inheritance in C++:
1. Single Inheritance
In single inheritance, a derived class inherits from only one base class. This is the simplest form
of inheritance.

class Base {
// ...
};

class Derived : public Base {

// ...
};

2. Multiple Inheritance
In multiple inheritance, a derived class can inherit from more than one base class. This can lead
to the "diamond problem" if not handled carefully.

class Base1 {
// ...
};
class Base2 {
// ...
};
class Derived : public Base1, public Base2 {
// ...
};

Page 8
 Centre for Distance & Online Education
3. Multilevel Inheritance
In multilevel inheritance, a derived class inherits from a base class, which in turn inherits from
another base class.

class Base1
{
// ...
};
class Base2 : public Base1 {
// ...
};
class Derived : public Base2 {
// ...
};

4. Hierarchical Inheritance
In hierarchical inheritance, more than one derived class inherits from the same base class.

class Base
{
// ...
};
class Derived1 : public Base {
// ...
};
class Derived2 : public Base {
// ...
};

Page 9
 Centre for Distance & Online Education

5. Hybrid Inheritance
Hybrid inheritance is a combination of multiple inheritance types. For example, a class may
inherit from two base classes, one of which inherits from another base class.

class Base1
{
// ...
};
class Base2 : public Base1
{
// ...
};
class Base3
{
// ...
};
class Derived : public Base2, public Base3
{
// ...
};

Page 10