COMSATS University Islamabad CUI), Lahore Campus

Assignment # 1 (Theory)– Fall 2024

Course Title: Object Oriented Programming Course Code: CSC241
Semester: 2 Batch: Fa23 Section: a Date: 15/10/2024
Time Allowed: Maximum Marks: 15
Student’s Name: Abdul Wasay Reg. No. Fa23-bse-210

CLO: <1> Explain the concepts of Object-Oriented Programming

(OOP) paradigms < Understanding>
Marks: 15
Question. Answer the following questions.

Explain run-time polymorphism using virtual function.

In object-oriented programming, run-time polymorphism is a technique that lets the program
choose which function to execute depending on the type of object it is running on at runtime.
Virtual functions, which are defined in a base class and designated with the virtual keyword to
indicate that they can be overridden by derived classes, are used to implement this. dynamic
binding or late binding refers to the process by which the program dynamically chooses and
executes the overridden version of the function in the derived class rather than the base class
version when a function is called on a base class pointer or reference that points to a derived
class object. Because the same function call can produce different results based on the actual
class type of the object, this allows for polymorphic behavior. With this method, code flexibility
is increased and code structures become more reusable and extendable. New derived classes with
distinct behavior can be added, and they can interact with existing code using base class
references or pointers without requiring changes.

Explain dynamic memory allocation.

Programming techniques such as dynamic memory allocation allow memory to be allocated at
runtime instead of compile time. This is necessary to enable effective and adaptable memory
usage as the program operates when it is not possible to predict the precise amount of memory
required. Dynamic memory allocation is managed by the `new} and `delete} operators in C++,
and by functions like `malloc()`, `calloc()`, `realloc()`, and `free()} in C programming languages.
Memory that is allocated dynamically comes from the program's *heap*, a memory pool set
aside just for these kinds of allocations. For example, a program can use dynamic memory
allocation to specify the size of an array based on input or other runtime conditions, creating only
the necessary amount of memory when it needs to create one but is unsure of the size
beforehand. But in order to prevent memory leaks, which eventually could cause the program to
crash and result in inefficient memory use, it is imperative that you manually release or
deallocate this memory once it is no longer needed. Applications where data sizes are
unpredictable or where large data structures, such as linked lists, trees, and other custom
structures, are needed, benefit greatly from dynamic memory allocation. With this method,
programs can effectively use memory and adjust to changing needs without wasting space on
unneeded or static allocations.

What is method overloading? And What is method overriding?

Although they accomplish different things, method overloading and overriding are two
fundamental ideas in object-oriented programming that allow for flexible function usage. Method
overloading enables several methods with the same name but distinct parameter lists, usually
based on the quantity or kind of arguments, to occur within the same class. This improves
readability and usability by enabling methods to carry out comparable operations on various
inputs. To handle multiple data types under one function name, an `add` method could be
overload to handle both integers and floating-point numbers. Compiler decisions about which
method to call in order to resolve overloading are made at compile time, taking into account the
argument list. However, method overriding is a type of polymorphism in which a method in a
derived class replaces a method in its base class by having the same name, return type, and
parameter list. The derived class's version is invoked instead of the method when it is called on a
base class reference or pointer pointing to an object of the derived class; this is decided at
runtime. Run-time polymorphism is a feature that lets derived classes extend or implement base
class behavior to make it unique to that derived type. For instance, the `Dog` and `Cat` classes
may override a `sound` method in the base class `Animal} to generate sounds unique to their
respective species. In conclusion, overriding gives derived classes the ability to change inherited
behavior at runtime, allowing for polymorphism, while overloading permits methods within the
same class to react to various input types at compile time.

What is an abstract class?

An abstract class is one that is meant to act as a model for other classes; it is one that cannot be
instantiated on its own. Both concrete methods with defined behavior and abstract methods—
methods declared but not implemented—can be found within. Any subclass that derives from the
abstract class needs to implement the abstract methods in order to guarantee that the subclass
provides particular behavior for those methods. This feature comes in handy when you want to
give different subclasses the freedom to define their own implementations, but still enforce a
specific structure or contract across them. In order to facilitate the sharing of setup and common
properties among derived classes, abstract classes may also contain fields and constructors. To
put it simply, an abstract class is a fundamental building block for other classes, which is why it
is important to achieve code reusability and implement polymorphism. However, attempting to
create an object of an abstract class will result in an error because it is incomplete in and of itself.

Difference between class and an object?

A class is an instance of a class that represents a particular entity, whereas a class blueprint
defines the behavior and structure of objects. The class does not actually contain any data;
instead, it describes the methods (functions) and attributes (properties) that its objects will have.
A class could define a "Car," for instance, with methods like start, accelerate, and stop as well as
properties like color, model, and speed. An object created from this class will have its own set of
values for the class-defined attributes. For example, it may be a specific "Car" with a red color
and a model name. Put differently, an object is a tangible, real-world instance of a concept, and a
class is its conceptual definition. While objects exist at runtime and take up memory, classes
exist at the code level. Objects are the actual products created from a class, which can be thought
of as a design plan. Each object has a unique state that is determined by the class definition.

What is an abstraction?
The goal of object-oriented programming's abstraction concept is to conceal a system's intricate
workings and reveal only the features that are most important to the user. It frees developers
from having to comprehend the underlying implementation in order to define a simplified
interface for interacting with objects. Code maintainability is improved and complexity is
decreased when abstraction is used to emphasize an object's functions rather than their methods.
For instance, you do not need to understand how the engine or transmission operate internally to
drive a car; all you need to do is operate the steering wheel, pedals, and gear shift. Similar to this,
abstraction in programming allows users to work with high-level functionality without getting
bogged down in the details of the code. This can be accomplished through the use of abstract
classes, interfaces, or enclosing implementation details within methods. This improves
modularity and facilitates maintenance by enabling developers to alter internal operations
without affecting other program components. It also makes the code more readable.

What are the various types of constructors?

In object-oriented programming, constructors are unique methods that are called upon the
creation of an object of a class in order to initialize the object's attributes. Constructors come in a
variety of forms, and the programming language you use will determine which ones are
available. Default constructors, parameterized constructors, copy constructors, and static
constructors are the most popular types.

A constructor that accepts no arguments is called a default constructor. Most programming

languages automatically provide a default constructor, which initializes the object with default
values (e.g., null for objects, 0 for numbers), if no constructor is explicitly defined in a class. If
developers want to set unique default values for an object's attributes, they can also explicitly
define a default constructor.
With parameterized constructors, the developer can specify the object's initial state using one or
more arguments and the values passed in when the object was created. This provides more
control and flexibility over the object's instantiation process and is helpful when you need to
create objects with specific properties right away.

When a constructor receives an object of the same class as an argument, it can copy the existing
object and create a new one. This is known as a copy constructor. This is primarily used to
handle object copying in languages such as C++, particularly when deep copying—that is, when
all the attributes—including dynamically allocated memory—need to be duplicated instead of
just the references—is required.

The static members of the class are initialized using static constructors, also called class
constructors. They are automatically invoked prior to the creation of any class objects or the
access of any static members. Static constructors, in contrast to other constructors, are used to set
up static fields or carry out operations that must be completed once per class as opposed to once
per object. They also do not accept parameters.
These various constructor types contribute to the flexibility of object creation by giving
developers authority over the initialization of objects and guaranteeing that objects are created in
a valid and meaningful state from the start.

How can we call the base method without creating an instance?

You can use **static methods** or take advantage of **inheritance** to invoke a base class
method without having to create an instance of the class. Static methods can be called directly by
using the class name because they are part of the class itself, not just a particular instance, in
many object-oriented programming languages like Java and C#. For instance, if your base class,
{Base}, defines a static method, `staticMethod()}, you may use `Base.staticMethod()` to call this
method directly, without having to create an instance of `Base}. This is especially helpful for
utility methods that must be accessed without an object context and do not depend on instance-
specific data.

Furthermore, in the context of inheritance, you can use the `super` or `base} keywords in Python
and Java, respectively, to invoke a method defined in the base class if your derived class is
descended from it. Similarly, in C#. As a result, the derived class can directly access methods
from the underlying class. For example, in Java or Python, the derived class can use
`super.methodName()`, or in C#, `base.methodName()}, to execute the original method from the
base class even if it has overridden it. With this method, customized functionality can still be
included in the derived class while preserving the behavior described in the base class and
facilitating code reuse. Your code will be clearer and more effective if you use inheritance and
static methods to efficiently access base class methods without having to create instances. All
things considered, these techniques are necessary for good object-oriented design since they
make the links between classes and their behaviors understandable and controllable.

What is ‘this’ pointer?

The this pointer is a special pointer available in non-static member functions of a class that refers
to the current instance of the class. It is implicitly passed to all non-static member functions and
allows access to the object's own data members and methods. When an object calls a member
function, the 'this' pointer holds the address of that particular object, enabling the function to
access or modify the attributes specific to that instance. The 'this' pointer is essential for
distinguishing between class attributes and parameters with the same name. For example, if a
method has a parameter named `value` and the class also has a data member called `value`, using
`this->value` (in C++ or this.value in Java) will refer to the object's data member, while `value`
alone will refer to the method's parameter. The 'this' pointer is also used when returning the
current object from a method, enabling method chaining (calling multiple methods in a single
statement). Notably, it cannot be used in static member functions since they do not belong to any
specific instance. Overall, the 'this' pointer is a powerful mechanism to ensure precise access to
an object's properties and to manage potential ambiguities in the code.

What is the difference between structure and a class?

The main distinction between a class and a structure in programming, especially in object-
oriented languages like C++ and C#, is how they behave, what their intended use is, and how
accessible they are. Simple data structures can be created by grouping related variables (data
members) under a single name using a value type called a **structure**. Members of a structure
are by default public, meaning that there is no encapsulation involved and they can be accessed
directly from outside the structure. In general, structures do not support inheritance and are used
for lightweight objects that represent simple data models, such as colors or coordinates.
However, a class is a reference type that has the ability to encapsulate functionality and data,
enabling more intricate behavior and design. Fundamental concepts of object-oriented
programming, such as inheritance, polymorphism, and encapsulation, are supported by classes.
By default, class members are private, which encourages encapsulation and safeguards data
integrity. This means that getter and setter methods are typically needed to access class members.
Although methods, properties, and constructors can be found in both structures and classes,
classes are more flexible and strong because they support inheritance and access modifiers. Thus,
classes are used when more sophisticated object-oriented features are required, while structures
are best suited for straightforward data representations.

What is the default access modifier in a class?

When no explicit access modifier is specified, a class's default access modifier controls the
visibility and accessibility of its members (attributes and methods). The default access modifier
for class members in many object-oriented programming languages, like Java and C#, is
package-private (or default); in C#, it is private. This means that in C#, the default access level
restricts access to the containing class only, meaning that other classes cannot access those
members directly unless they are within the same class, whereas in Java, if no access modifier is
declared, the class members are only accessible to other classes within the same package.
Different programming languages have different default access levels, though. For instance, in
C++, if a class is declared without an access modifier, then by default, its members are private.
In order to preserve encapsulation and data hiding and safeguard a class's internal operations
from inadvertent disruption by other classes, default access modifier selection is essential.
Therefore, in order to improve code readability and make it clear what level of access each class
member is intended to have, it is best practice to always explicitly specify the access modifier for
each member. This will help to promote better understanding and maintainability of the code.

What is a virtual function?

In object-oriented programming, a virtual function is a member function in a base class that can
be overridden in a derived class. This enables dynamic polymorphism. The program can choose
which function implementation to execute at runtime based on the actual object type rather than
the type of reference or pointer when a function is declared as virtual in the base class.
Accordingly, if you have a base class with a virtual function and a derived class that overrides it,
calling the function with an object of the derived class type pointed to by a base class pointer or
reference will invoke the derived class's version of the function. With this behavior,
programmers can define generic interfaces and provide specific implementations in derived
classes, which is essential for achieving flexibility and extensibility in code. For example, both
`Circle` and `Square} derived classes can implement their own versions of `draw()` if your base
class {Shape} has a virtual function called `draw()`. Even though the call was made through the
`Shape} pointer, the `Circle`'s implementation will be carried out when you call `draw()` using a
base class pointer that points to a `Circle` object. In order to implement features like
polymorphism, which improve code reuse, organization, and flexibility, virtual functions are
essential.

What is an interface?
An interface is a programming construct that, in the absence of a concrete implementation,
defines a contract or a set of methods that a class must implement. In object-oriented
programming, interfaces are used to achieve abstraction and establish a common protocol for
classes so they can communicate with each other without being aware of the details of each
other's implementations. An interface promotes flexibility and decoupling of code by allowing
different classes to implement the same methods in their own ways by specifying only method
signatures, which are the method names, return types, and parameters. An interface called
`Drawable`, for instance, might define a method called `draw()` in a graphics application.
Different classes, such as `Circle`, `Square`, and `Triangle`, can implement this method and
provide their own unique drawing logic. In this manner, polymorphism is enabled in a function
by accepting any object that implements the `Drawable} interface. Furthermore, a class can
implement multiple interfaces and inherit behavior from various sources without the
complications of traditional class inheritance because interfaces support multiple inheritance. As
they establish boundaries and expectations for the behavior of implementing classes, interfaces
are essential to the design of modular, easily maintained, and extensible systems.

Differentiate between an abstract class and an interface?

Both an interface and an abstract class are essential ideas in object-oriented programming that
help with abstraction and establish a contract for classes, but they have different functions and
unique qualities. A class that lacks the ability to be instantiated independently is known as an
abstract class. It can contain both concrete methods and abstract methods, the latter of which has
an implementation. This enables abstract classes to enforce a specific structure on subclasses that
inherit from them, and to provide some shared behavior. On the other hand, an interface does not
provide any implementation for the methods it defines; rather, it is just a contract that outlines a
set of methods that implementing classes must define. Furthermore, a class can implement
multiple interfaces, providing more design flexibility, even though it can only inherit from one
abstract class (single inheritance). Additionally, members of an abstract class can have different
access modifiers for their members, such as private and protected, whereas members of an
interface are usually public by default. All things considered, abstract classes are helpful when
you want to enforce a particular structure while allowing related classes to share code, while
interfaces are great for defining a standard protocol that several classes can follow, encouraging
loose coupling and flexibility in code design.

What is the difference between an error and an exception?

Understanding the differences between error and exception refers to various problems that can
arise when a program is being executed, and it is essential for debugging and error handling in
software development. A serious issue that arises during program execution and usually cannot
be fixed is referred to as an error. These issues are typically caused by flaws in the program's
architecture or the environment in which it operates. Errors typically mean that the program can
not run safely and are linked to basic problems like memory leaks, stack overflows, or hardware
malfunctions. Runtime errors, on the other hand, have the potential to crash the program or cause
unexpected behavior. Syntax errors, for instance, like a misspelled keyword or a missing closing
bracket, are detected during the compilation process and prevent the program from running at all.

Conversely, an exception is a situation that occurs when a program is being executed that breaks
the program's normal flow but can be gracefully handled. Typically, exceptions result from
circumstances that the program can foresee, like incorrect user input, file not found errors, or
problems with network connectivity. Programming languages frequently come with built-in
exception handling mechanisms that let programmers write code that can react to exceptions by
doing particular things like logging the error for later review, retrying an operation, or showing
the user an error message. Try-catch blocks and other exception handling constructs help
developers build more resilient programs that can handle unforeseen circumstances without
crashing. In conclusion, exceptions are controllable events that arise during program execution
and can be handled to preserve the program's stability, whereas errors are serious problems that
frequently point to a basic issue with the program itself.