Section A

Ans.1

a. Features of Object-Oriented Languages:

- Encapsulation: Bundling of data and methods that operate on the data into a single unit, i.e., a
class.

- Inheritance: Capability of a class to derive properties and characteristics from another class.

- Polymorphism: Ability to present the same interface for different data types, i.e., methods can
take many forms.

- Abstraction: Process of hiding the implementation details and showing only the essential features
of the object.

b. Structured Approach vs. Object-Oriented Approach:

- Structured Approach: Focuses on breaking down a problem into smaller sub-problems through
the use of functions and procedures.

- Object-Oriented Approach: Emphasizes modeling a system as a group of interacting objects that

communicate with each other to solve a problem.

c. UML (Unified Modeling Language):

- Standardized visual modeling language used in the field of software engineering to design and
document software systems.

d. Generalization:

- In the context of object-oriented programming, generalization refers to the process of forming a

general class from specific classes by abstracting common attributes and behaviors.

e. Three Models in OMT (Object Modeling Technique):

- Object Model: Describes the objects involved in a system and their relationships.

- Dynamic Model: Depicts the behavior of the objects within the system and how they interact over
time.

- Functional Model: Illustrates the functions or operations that the system performs.

f. Optimization of Design:

- Optimization of design refers to the process of refining the design of a system or software to
improve its performance, efficiency, maintainability, or other desirable qualities.
g. C++ Program to Calculate sin(x):

```cpp

#include <iostream>

#include <cmath>

using namespace std;

int main() {

double x;

cout << "Enter the value of x in radians: ";

cin >> x;

cout << "sin(" << x << ") = " << sin(x) << endl;

return 0;

```

h. Typecasting in C++:

- Typecasting is the process of converting one data type into another. In C++, it can be done
explicitly using casting operators like static_cast, dynamic_cast, const_cast, and reinterpret_cast.

i. Difference Between Public and Private Member Function:

- Public Member Function: Accessible from outside the class and can be called by any part of the
program.

- Private Member Function: Accessible only within the class where it is declared and cannot be
called from outside the class.

j. Static Data and Static Function Member:

- Static Data Member: A member of a class that belongs to the class itself, not to instances of the
class. There's only one copy of a static data member shared by all instances of the class.

- Static Function Member: A member function of a class that operates on static data members and
doesn't have access to non-static members. It can be called using the class name without creating an
object of the class.
Section B

Ans.2

a. Object-Oriented Technology:

Object-oriented technology is a programming paradigm centered around the concept of "objects,"

which are instances of classes. Classes define the properties (attributes) and behaviors (methods) of
objects. Key principles of object-oriented programming include encapsulation, inheritance, and
polymorphism.

Pros of Object-Oriented Technology:

- Modularity: Encapsulation allows for the organization of code into manageable, reusable
components.

- Reusability: Objects and classes can be reused in different contexts, reducing development time
and effort.

- Abstraction: Classes provide a level of abstraction, hiding implementation details and allowing for
easier comprehension and maintenance.

- Inheritance: Enables code reuse and promotes a hierarchical structure for modeling real-world
relationships.

- Polymorphism: Allows objects of different classes to be treated uniformly, enhancing flexibility

and scalability.

Cons of Object-Oriented Technology:

- Complexity: Object-oriented systems can become complex, especially for large projects, leading to
potential difficulties in understanding and maintaining the codebase.

- Performance Overhead: The additional layers of abstraction and dynamic dispatching can
introduce overhead, impacting performance compared to procedural programming in some cases.

- Difficulty in Learning: Object-oriented concepts such as inheritance and polymorphism may be

challenging for beginners to grasp initially.

Example: Consider a banking application. Using object-oriented technology, you can create classes
such as `Account`, `Customer`, and `Transaction`, each encapsulating relevant data and operations.
Inheritance can be utilized to model relationships like `SavingsAccount` and `CheckingAccount`
inheriting from `Account`, promoting code reuse.

b. Architectural Modeling:
 Architectural modeling involves creating abstract representations (diagrams, documents) of a
system's architecture to communicate its structure, behavior, and interactions.

Concepts and Diagrams:

- Use Case Diagrams: Depict system functionalities and interactions with external actors.

- Class Diagrams: Illustrate the static structure of the system, showing classes, attributes,
relationships, and methods.

- Sequence Diagrams: Describe interactions between objects over time, representing the dynamic
behavior of the system.

- Component Diagrams: Display the physical or logical components of the system and their
dependencies.

- Deployment Diagrams: Show the physical deployment of software components on hardware

nodes.

Example: Consider an e-commerce platform. A class diagram can represent entities like `Product`,
`User`, and `Order`, along with their attributes and relationships. Sequence diagrams can illustrate
the flow of interactions between these objects during a purchase process.

c. Documentation:

Documentation refers to the process of capturing and communicating information about software
systems. Considerations in documentation designing include:

- Audience: Tailor documentation to the intended readers, such as developers, users, or

administrators.

- Content: Include information on system architecture, design decisions, APIs, usage instructions,
and troubleshooting guides.

- Format: Choose appropriate formats such as text documents, diagrams, tutorials, or online help.

- Consistency: Maintain consistency in terminology, style, and formatting across the

documentation.

- Accessibility: Ensure documentation is easily accessible and searchable, aiding users in finding
relevant information quickly.

d. Namespace, Identifiers, Variables, Constants, Enum:

- Namespace: A namespace is a declarative region that provides a scope for the identifiers (such as
variables, functions, classes) declared within it, preventing naming conflicts.

- Identifiers: Identifiers are names given to various program elements like variables, functions,
classes, etc., enabling programmers to refer to them in code.
 - Variables: Variables are named storage locations in memory used to hold data values during the
execution of a program. They can be assigned different values throughout the program's execution.

- Constants: Constants are variables whose values cannot be changed during the execution of the
program. They are typically declared using the `const` keyword.

- Enum: Enumerations (enums) allow programmers to define a type with a set of named constants.
Each constant has an associated integer value.

e. C++ Program with Multiple Inheritance:

```cpp

#include <iostream>

using namespace std;

class Animal {

public:

void eat() {

cout << "Animal is eating" << endl;

};

class Mammal {

public:

void breathe() {

cout << "Mammal is breathing" << endl;

};

class Dog : public Animal, public Mammal {

public:

void bark() {

cout << "Dog is barking" << endl;

};
int main() {

Dog myDog;

myDog.eat(); // Accessing eat() from Animal

myDog.breathe(); // Accessing breathe() from Mammal

myDog.bark(); // Accessing bark() from Dog

return 0;

```

In this example, the `Dog` class inherits from both `Animal` and `Mammal` classes, demonstrating
multiple inheritance. The `Dog` class inherits the `eat()` method from `Animal` and the `breathe()`
method from `Mammal`. Additionally, it defines its own method `bark()`.

Section C

Ans.3

Ans a. Encapsulation:

Encapsulation is one of the fundamental concepts in object-oriented programming (OOP) that refers
to the bundling of data and methods that operate on that data into a single unit, called a class. It
allows for the abstraction of data within a class, ensuring that the internal representation of an
object is hidden from the outside world and can only be accessed through well-defined interfaces.

Encapsulation serves several purposes:

1. Data Hiding: By encapsulating data within a class, you can restrict access to certain components,
making them inaccessible to the outside world. This prevents unauthorized access and manipulation
of the data, thereby ensuring its integrity.

2. Abstraction: Encapsulation allows you to abstract away the implementation details of a class,
providing a clear separation between the interface and the implementation. Users of the class only
need to know how to interact with it through its public interface, without needing to understand
how it is implemented internally.

3. Modularity: Encapsulation promotes modularity by organizing related data and behaviors into
cohesive units (classes). This makes the code more manageable, scalable, and easier to maintain.
Example of Encapsulation:

```python

class Car:

def __init__(self, make, model, year):

self._make = make # Make of the car (encapsulated)

self._model = model # Model of the car (encapsulated)

self._year = year # Year of manufacture (encapsulated)

self._odometer_reading = 0 # Odometer reading (encapsulated)

def get_description(self):

return f"{self._year} {self._make} {self._model}"

def get_odometer_reading(self):

return self._odometer_reading

def update_odometer(self, mileage):

if mileage >= self._odometer_reading:

self._odometer_reading = mileage

else:

print("You can't roll back an odometer!")

def increment_odometer(self, miles):

self._odometer_reading += miles

# Creating an instance of Car

my_car = Car("Toyota", "Corolla", 2020)

# Accessing encapsulated attributes through methods

print(my_car.get_description()) # Output: 2020 Toyota Corolla

print(my_car.get_odometer_reading()) # Output: 0

# Updating odometer reading

my_car.update_odometer(100)

print(my_car.get_odometer_reading()) # Output: 100

# Incrementing odometer reading

my_car.increment_odometer(50)

print(my_car.get_odometer_reading()) # Output: 150

```

In this example, the `Car` class encapsulates the attributes `make`, `model`, `year`, and
`odometer_reading`. Access to these attributes is controlled through getter and setter methods,
providing a level of abstraction and data hiding.

Ans b. Polymorphism:

Polymorphism is a core concept in object-oriented programming that allows objects of different

classes to be treated as objects of a common superclass. It enables a single interface to represent
different underlying forms (data types or classes). This means that different classes can define their
own unique behaviors while sharing the same interface or method signature.

There are two types of polymorphism:

1. Compile-time Polymorphism (Method Overloading): This occurs when multiple methods in the
same class have the same name but different parameters.

2. Runtime Polymorphism (Method Overriding): This occurs when a subclass provides a specific
implementation of a method that is already defined in its superclass.

Example of Polymorphism:

```python
class Animal:

def make_sound(self):

pass

class Dog(Animal):

def make_sound(self):

return "Woof!"

class Cat(Animal):

def make_sound(self):

return "Meow!"

# Polymorphic function

def animal_sound(animal):

return animal.make_sound()

# Creating instances of Dog and Cat

my_dog = Dog()

my_cat = Cat()

# Calling the polymorphic function with different objects

print(animal_sound(my_dog)) # Output: Woof!

print(animal_sound(my_cat)) # Output: Meow!

```

In this example, both the `Dog` and `Cat` classes inherit from the `Animal` class and override the
`make_sound()` method with their own implementations. The `animal_sound()` function can accept
any object that is an instance of a class inheriting from `Animal`, demonstrating runtime
polymorphism. When called with different objects (`my_dog` and `my_cat`), it invokes the
appropriate overridden method based on the object's actual type.

Ans.4
Ans a. Class and Object Diagrams:

Class Diagram:

A class diagram is a static representation of the structure and relationships of classes in a system. It
illustrates the attributes, methods, and associations between classes. Classes are depicted as
rectangles with three sections: the top section contains the class name, the middle section lists the
class attributes, and the bottom section displays the class methods.

Example:

Consider a simple class diagram for a library management system:

```

+---------------------+

| Book |

+---------------------+

| - title: String |

| - author: String |

| - ISBN: String |

| - available: boolean|

+---------------------+

+-----------------------+

| Library |

+-----------------------+

| - books: List<Book> |

| - members: List<Member>|

+-----------------------+

+---------------------+

| Member |

+---------------------+

| - id: int |
| - name: String |

| - address: String |

+---------------------+

```

Object Diagram:

An object diagram represents a snapshot of objects and their relationships at a specific point in time
within a system. It depicts instances of classes and the values of their attributes. Objects are shown
as rectangles with the object name followed by a colon and the class name.

Ans b. Object Diagram Portion:

Let's create a portion of an object diagram for a library book checkout system that includes the date
a book is due and the late charges for an overdue book as derived objects.

```

+---------------------+

| Book |

+---------------------+

| - title: "To Kill a Mockingbird" |

| - author: "Harper Lee" |

| - ISBN: "9780061120084"|

| - available: false |

+---------------------+

+-----------------------+

| Library |

+-----------------------+

| - books: [Book] |

| - members: [Member] |

+-----------------------+
+---------------------+

| Member |

+---------------------+

| - id: 001 |

| - name: "John Smith"|

| - address: "123 Main St" |

+---------------------+

+------------------------+

| CheckoutRecord |

+------------------------+

| - book: Book |

| - member: Member |

| - checkoutDate: 2024-02-01 |

| - dueDate: 2024-02-15 |

+------------------------+

+-------------------------+

| LateCharge |

+-------------------------+

| - book: Book |

| - daysOverdue: 2 |

| - chargePerDay: $0.50 |

| - totalLateCharge: $1.00|

+-------------------------+

```

In this portion of the object diagram:

- A book titled "To Kill a Mockingbird" by Harper Lee has been checked out by a member named John
Smith.

- The checkout record includes the checkout date (2024-02-01) and the due date (2024-02-15).
- The late charge object calculates the late charge for the overdue book, which is 2 days overdue,
with a charge of $0.50 per day, resulting in a total late charge of $1.00.

This object diagram portion illustrates the relationships between the book, member, checkout
record, and late charge objects in the library book checkout system.

Ans.5

Ans a. Structured Analysis and Structured Design:

Structured analysis and design are methods used in software engineering to organize and document
the requirements and design of a system.

Structured Analysis: It involves breaking down a complex system into smaller, more manageable
parts. This is usually done using techniques like Data Flow Diagrams (DFDs), Entity-Relationship
Diagrams (ERDs), and Structured English.

Structured Design: Once the system has been analyzed, structured design is used to create a
blueprint for implementing the system. This can involve techniques like Structured Charts and
Pseudocode to represent the system's architecture and algorithms.

Example:

Let's consider a library management system:

- Structured Analysis: In this phase, the analyst would identify the main entities and processes
involved in the system. They might create a DFD to represent how books are borrowed, returned,
and managed within the library.

- Structured Design: After analyzing the system, the designer would create a structured design that
outlines how the system will be implemented. This might involve creating structured charts to
represent the modules and functions of the system, as well as pseudocode to outline the algorithms
used for tasks like checking out a book or adding a new book to the system.

Ans b. Mapping Object-Oriented Concepts using Non-Object Oriented Languages:

When dealing with non-object-oriented languages, such as procedural languages like C or functional
languages like Haskell, you can still implement concepts from object-oriented programming (OOP) by
using certain strategies.

Encapsulation: Encapsulation can be achieved in non-OOP languages by using modules or

namespaces to group related functions and data together.

Inheritance: Inheritance can be simulated using techniques like function pointers or structs in
languages like C. You can create structs that contain function pointers to simulate method calls and
achieve a form of polymorphism.

Polymorphism: Polymorphism can be emulated using function pointers or unions in C, where you can
have different functions with the same signature and switch between them dynamically based on the
context.

Example:

Let's say we want to represent different shapes in a non-OOP language like C.

```c

#include <stdio.h>

// Struct representing a shape

typedef struct {

int type; // 0 for circle, 1 for rectangle

union {

struct { int radius; } circle;

struct { int width; int height; } rectangle;

} data;

} Shape;

// Function to calculate area based on shape type

int calculateArea(Shape shape) {

switch (shape.type) {
 case 0: // Circle

return 3.14 shape.data.circle.radius * shape.data.circle.radius;

case 1: // Rectangle

return shape.data.rectangle.width * shape.data.rectangle.height;

default:

return -1; // Invalid shape type

int main() {

// Create a circle

Shape circle = {0, .data.circle.radius = 5};

// Create a rectangle

Shape rectangle = {1, .data.rectangle.width = 4, .data.rectangle.height = 6};

// Calculate and print areas

printf("Circle Area: %d\n", calculateArea(circle));

printf("Rectangle Area: %d\n", calculateArea(rectangle));

return 0;

```

In this example, we define a struct `Shape` that can represent either a circle or a rectangle. We use a
union to store the data specific to each shape type. The `calculateArea` function calculates the area
based on the type of shape. This approach simulates polymorphism and encapsulation, allowing us
to work with different types of shapes using a single function.

Ans.6

Ans. a. Friend Function:

A friend function in C++ is a function that is not a member of a class but has access to the private and
protected members of that class. It can be declared inside a class with the keyword `friend`. This
allows the function to access private and protected members of the class as if it were a member
function.

Here's an example to illustrate how friend functions work:

```cpp

#include <iostream>

class MyClass {

private:

int secretNumber;

public:

MyClass() : secretNumber(42) {}

// Declaring friend function

friend void printSecret(MyClass obj);

};

// Defining friend function

void printSecret(MyClass obj) {

std::cout << "The secret number is: " << obj.secretNumber << std::endl;

int main() {

MyClass myObj;

printSecret(myObj); // Accessing private member through friend function

return 0;

```
In this example, `printSecret` is declared as a friend function inside the `MyClass`. It can access the
private member `secretNumber` of `MyClass` even though it's not a member of the class.

Ans. b. Virtual Function:

A virtual function is a member function of a class that is declared within a base class and is redefined
(or overridden) by a derived class. Virtual functions allow a program to perform different
implementations of a function based on the object type that invokes it. They are used in
polymorphism to achieve runtime polymorphism.

### Difference between Virtual and Pure Virtual Functions:

1. Virtual Function:

- A virtual function is declared in a base class using the `virtual` keyword and is meant to be
overridden by derived classes.

- A virtual function has a default implementation in the base class, but derived classes can provide
their own implementation.

- It allows dynamic binding or late binding, meaning the function call is resolved at runtime.

2. Pure Virtual Function:

- A pure virtual function is a virtual function that is declared in a base class but has no
implementation provided in the base class.

- It is declared using the syntax `virtual returnType functionName() = 0;`.

- Classes containing pure virtual functions are abstract classes, meaning they cannot be instantiated
directly.

- Derived classes must override pure virtual functions to become concrete classes.

- Pure virtual functions provide a way to define interfaces in C++.

Here's an example demonstrating virtual and pure virtual functions:

```cpp

#include <iostream>

// Base class

class Shape {
public:

// Pure virtual function

virtual void draw() = 0;

};

// Derived class 1

class Circle : public Shape {

public:

void draw() override {

std::cout << "Drawing Circle" << std::endl;

};

// Derived class 2

class Rectangle : public Shape {

public:

void draw() override {

std::cout << "Drawing Rectangle" << std::endl;

};

int main() {

// Creating objects of derived classes

Circle circle;

Rectangle rectangle;

// Polymorphic behavior

Shape* shapePtr1 = &circle;

Shape* shapePtr2 = &rectangle;

// Calling draw() for different shapes

 shapePtr1->draw(); // Output: Drawing Circle

shapePtr2->draw(); // Output: Drawing Rectangle

return 0;

```

In this example, `Shape` is an abstract class with a pure virtual function `draw()`. Both `Circle` and
`Rectangle` are concrete classes derived from `Shape` and provide their own implementation of the
`draw()` function. At runtime, the appropriate `draw()` function is called based on the object type.

Ans.7

Ans a.

```cpp

#include <iostream>

template<typename T>

class Node {

public:

T data;

Node* next;

Node(T newData) : data(newData), next(nullptr) {}

};

template<typename T>

class SinglyLinkedList {

private:

Node<T>* head;

public:

SinglyLinkedList() : head(nullptr) {}
 ~SinglyLinkedList() {

while (head) {

Node<T>* temp = head;

head = head->next;

delete temp;

void insert(T data) {

Node<T>* newNode = new Node<T>(data);

if (!head) {

head = newNode;

return;

Node<T>* temp = head;

while (temp->next) {

temp = temp->next;

temp->next = newNode;

void display() {

Node<T>* temp = head;

while (temp) {

std::cout << temp->data << " ";

temp = temp->next;

std::cout << std::endl;

};
```

This class `SinglyLinkedList` is a template class which can be used to create singly linked lists of any
data type. It contains a private member `head` which points to the first node of the linked list. It has
methods to insert elements into the list and to display the contents of the list.

Ans b. A constructor is a special member function of a class which is automatically called when an
object of that class is created. It is used to initialize the object's data members. Constructors do not
have a return type, not even `void`, and their name is the same as the class name.

A constructor is different from a normal member function in that it is automatically invoked when an
object is created, whereas normal member functions need to be explicitly called.

Here's an example to illustrate the difference:

```cpp

#include <iostream>

class MyClass {

private:

int x;

public:

// Constructor

MyClass(int val) : x(val) {

std::cout << "Constructor called. Value of x: " << x << std::endl;

// Normal member function

void display() {

std::cout << "Value of x: " << x << std::endl;

};
int main() {

// Constructor is automatically called when object is created

MyClass obj1(5);

// Normal member function needs to be called explicitly

obj1.display();

return 0;

```

In this example, `MyClass` has a constructor which initializes the private member `x` with the value
passed to it. When an object `obj1` of `MyClass` is created with the value `5`, the constructor is
automatically called. On the other hand, the `display()` function needs to be called explicitly to
display the value of `x`.