CS304 Final Term Past Papers 2025

Inheritance in Classes

Inheritance is a fundamental concept in object-oriented programming that allows a new class (known as the derived or child class) to acquire the properties and behaviors of an existing class (called the base or parent class). When class B is derived from class A, it automatically incorporates all the data members and functions that belong to class A. This enables the reuse of existing code and promotes modular and organized programming practices.


Even though a derived class acquires these features from its base class, it can also have its own specialized attributes and behaviors. A derived class can introduce its own unique data members and member functions to extend or specialize the behavior of the base class. This combination of inherited and new characteristics forms the basis of powerful object-oriented programming structures.

Default Constructor

A default constructor is one that can be called without supplying any arguments; it may have no parameters at all or only parameters that come with pre-assigned default values. It is defined either with no parameters or with parameters that have default values assigned. The advantage of the default constructor is that it enables the creation of class objects without requiring any explicit input from the user. It provides a simple way to initialize objects with default or empty states.

Explicit Default Constructor

When a programmer provides a constructor explicitly without any parameters or with parameters that have default values, this is called an explicit default constructor. Even though it meets the definition of a default constructor, it is specifically coded by the programmer, rather than being automatically provided by the compiler.

Using Member Functions of the Base Class within a Derived Class

Sometimes, a base class contains helper functions that are not meant to be accessed directly by external code. These functions often serve as internal utilities for other member functions. For instance, if a class requires input validation to ensure that only numeric data is entered by a user, a helper function can be written to perform this check.

In cases where a class implements data encryption, there may be encoding and decoding functions that are essential for the encryption process but should remain hidden from the outside world. Such helper functions help maintain data integrity and internal class behavior without exposing unnecessary details to other classes or functions.

Protected Members and Encapsulation

In object-oriented design, encapsulation means that a class should contain and protect its data members and functions. Protected members somewhat challenge this principle. Protected members are visible to derived classes, but they cannot be accessed directly from outside the class hierarchy.

This is significant during inheritance, as protected members form a middle ground between private and public access. In a standalone class, protected access has little relevance, but when inheritance comes into play, it allows derived classes to use and build upon the base class’s implementation.

Assignment Operator in Inheritance

When working with inheritance, the compiler automatically provides an assignment operator if one is not explicitly defined. This operator handles the process of assigning one object to another within the same class hierarchy. In the case of derived classes, the assignment operator of the derived class will also invoke the assignment operator of the base class to ensure that both the derived and the inherited elements of the object are correctly duplicated.

If the programmer defines a custom assignment operator for the derived class, it becomes essential to explicitly call the base class’s assignment operator within it. This guarantees that the base class’s data members are assigned correctly, preserving the integrity of the object hierarchy.

Overriding Base Class Member Functions

Derived classes can override the member functions of their base classes to provide specialized behavior. When this occurs, the derived class can still call the base class’s version of the function if it needs to perform the inherited portion of the task, followed by its own additional operations.

For example, in a scenario where a student class inherits from a Person class, the student class can override a Print method. It might first call the Person class’s Print method to display the student’s name, then add its own functionality to display the student’s program of study.

This approach is in line with the principles of object-oriented programming, emphasizing that each class should handle its own responsibilities while leveraging inherited behavior as needed.

Polymorphism with Overriding Functions

When the same method exists in both base and derived classes, polymorphism allows the appropriate version of the method to be executed at runtime, depending on the type of the object calling the method. For instance, if both a Shape class and its derived Circle class have a draw method, the Circle class’s draw method will be called when a Circle object is involved. This dynamic method resolution makes object-oriented programs flexible and adaptable.

Pure Virtual Functions

Pure virtual functions define abstract behaviors in base classes without providing an implementation. As an example, consider the draw function declared as a pure virtual function within a Shape class. Since Shape itself is an abstract representation and does not have a real-world form, it doesn’t provide a concrete implementation. Concrete derived classes like Circle, Line, or Triangle provide specific implementations for the draw method to represent their real-world existence.

Inheritance, Interfaces, and Implementation

When dealing with simple virtual functions, there are cases where some derived classes don’t provide their own implementation of a virtual method. For instance, take a base class named Shape. A derived class like Line is also a Shape but doesn’t have an area, and similarly, a Point class wouldn’t have an area either. In such situations, we simply don’t implement the calcArea() method in those derived classes. As a result, the base class’s calcArea() method is called, which might just return zero or indicate no area.

In this example, the draw method is declared as a pure virtual function because every shape whether it’s a Point, Line, or any other shape needs to provide its own way to draw itself. That makes it logical to force derived classes to implement this method.

One important caution is about using arrays polymorphically. This is because the arrangement of elements in an array is determined by the type of the array. If you try to treat a child class array as a parent class array, the calculations to locate elements can become incorrect, leading to errors. So, using arrays with polymorphism is generally unsafe.

Templates and Type Conversion

When you want to convert between different data types like from char to int, or float to int you’d typically write many different functions to handle each case. But as the number of types increases, this approach becomes cumbersome. This is where templates come in handy: they allow you to write a general function that works for any type conversion.

Overloading vs. Templates

Function templates are useful when you want to perform the exact same operation on different data types. However, you can’t change how the operation works for different types unless you specialize the template for a specific type. On the other hand, function overloading lets you define similar but slightly different versions of a function for each data type.

Even though a template function can handle multiple data types, if it accepts an array as an argument, it still depends on the data structure. Ideally, you want a function flexible enough to work with both single values and arrays, regardless of their type.

Conclusion

To conclude, inheritance in object-oriented programming is an essential tool that promotes code reuse, allows for the extension of existing functionality, and encourages well-structured design. With default and explicit constructors, protected members, assignment operators, function overriding, and polymorphism, inheritance ensures that derived classes can build upon and extend the functionality of their base classes. Pure virtual functions further allow the creation of abstract interfaces, making software design more structured and maintainable. This comprehensive understanding of inheritance lays a solid foundation for creating robust and efficient object-oriented applications.

CS304 Final Term Past Papers 2025, cs304 final term past papers, cs304 finalterm preparation 2025