Question

Suppose that you have the following classes, classA and classB: class classA { public: virtual void print() const; void doubleNum(); classA(int a = 0); private: int x; }; void classA::print() const { cout << "ClassA x: " << x << endl; } void classA::doubleNum() { x = 2 * x; } classA::classA(int a) { x = a; } class classB: public classA { public: void print() const; void doubleNum(); classB(int a = 0, int b = 0); private: int y; };void classB::print() const { classA::print(); cout << "ClassB y: " << y << endl; } void classB::doubleNum() { classA::doubleNum(); y = 2 * y; } classB::classB(int a, int b) : classA(a) { y = b; } What is the output of the following function main? int main() { classA *ptrA; classA objectA(2); classB objectB(3, 5); ptrA = &objectA ptrA->doubleNum(); ptrA->print(); cout << endl; ptrA = &objectB ptrA->doubleNum(); ptrA->print(); cout << endl; return 0; }

Short answer

ClassA x: 4 ClassA x: 6 ClassB y: 10

Step-by-step solution

Define Class Object Instances

In the `main` function, two objects are instantiated: `objectA` of type `classA` with initial `x` value of 2, and `objectB` of type `classB` with an initial `x` value of 3 and `y` value of 5.

Set Pointer to classA Object

A pointer `ptrA` of type `classA*` is set to point to `objectA`. The method `doubleNum()` is called on this pointer, which doubles `x` in `objectA` from 2 to 4. Then, it calls the `print()` method, outputting "ClassA x: 4".

Set Pointer to classB Object

The pointer `ptrA` is reassigned to point to `objectB`. The `doubleNum()` method is called again. In `classB`, this method first calls `doubleNum()` of `classA` to double `x` from 3 to 6, and then doubles `y` from 5 to 10. The `print()` method is invoked, outputting both values for `x` and `y`: "ClassA x: 6", "ClassB y: 10".

Key concepts

Virtual Functions

Virtual functions play an essential role in C++ programming, especially in scenarios where you deal with inheritance. A virtual function in a superclass allows derived classes to override it. This mechanism ensures that the correct method is called for an object, even when using a base class pointer.

• In the given example, `print()` is declared as a virtual function in `classA`. This means that when a `classA` pointer holds an object of `classB`, and you call the `print()` function, C++ will execute the `print()` method defined in `classB`, if it exists.
• Virtual functions are especially useful in a polymorphic context, where objects are treated as instances of their base class.
• They enable dynamic binding – the process of linking a function call to the code to execute at runtime.

Defining a function as virtual helps achieve flexibility and reusability in code. It allows subclasses to present their versions of the function, making software design modular and adhering to the open/closed principle.

Polymorphism

Polymorphism is a cornerstone of object-oriented programming that allows for treating objects of different classes in a uniform way. Generally, polymorphism is categorized as either compile-time (e.g., function overloading) or runtime (achieved through inheritance and virtual functions).

• Runtime polymorphism is demonstrated in the exercise through the use of the `classA` pointer, `ptrA`. Though `ptrA` is of type `classA*`, it can point to and operate on objects of both `classA` and `classB` due to polymorphism.
• This feature allows you to interact with differently derived objects through a common interface, as seen with the invocation of the `doubleNum()` and `print()` functions.
• Polymorphism enhances flexibility in code management, reducing the need for multiple function overloads or switch-case logic based on object types.

The ability to use a single pointer or reference to call methods on different derived classes makes polymorphism a powerful tool for implementing flexible and maintainable code.

Object-Oriented Programming

Object-oriented programming (OOP) offers a robust framework for building and managing complex software. OOP is based on four main principles: encapsulation, abstraction, inheritance, and polymorphism. In the given exercise, inheritance and polymorphism are highlighted, demonstrating the power and versatility of OOP. Inheritance allows a new class, `classB`, to derive properties and behaviors (methods) from an existing class, `classA`. This reduces redundancy and promotes code reuse.

• `classA` provides a base blueprint with attributes and functions that `classB` extends and customizes.
• This reuse of logic helps avoid code duplication, enhancing maintainability and scalability.

Encapsulation is seen in how data (like `x` and `y`) are bundled together with methods such as `doubleNum()` to manipulate them, keeping implementation details hidden. Overall, OOP principles lead to well-structured code that mirrors real-world systems, simplifies complex problems, and makes collaboration on projects easier through modular design and clear interfaces.