Question

Consider the following definition of the class studentType: public studentType: public personType { public: void print(); void calculateGPA(); void setID(long id); void setCourses(const string c[], int noOfC); void setGrades(const char cG[], int noOfC); void getID(); void getCourses(string c[], int noOfC); void getGrades(char cG[], int noOfC); void studentType(string fName = "", string lastName = "", long id, string c[] = NULL, char cG[] = NULL, int noOfC = 0); private: long studentId; string courses[6]; char coursesGrade[6] int noOfCourses; } Rewrite the definition of the class studentType so that the functions print and calculateGPA are pure virtual functions.

Short answer

Add `= 0` to `print` and `calculateGPA` to make them pure virtual functions.

Step-by-step solution

Understanding Pure Virtual Functions

A pure virtual function in C++ is a function that has no implementation in the base class and is defined by assigning 0 to it in the class definition. It must be overridden by any derived class.

Identify Functions to Be Converted

Locate the functions in the class that need to be declared as pure virtual. In this case, the functions `print` and `calculateGPA` need to be modified.

Modify Class Declaration

To make `print` and `calculateGPA` pure virtual functions, change their declaration by adding `= 0` at the end. This will create an abstract base class.

Rewrite the Class Definition

Edit the class definition to include the changes: ```cpp class studentType: public personType { public: virtual void print() = 0; virtual void calculateGPA() = 0; void setID(long id); void setCourses(const string c[], int noOfC); void setGrades(const char cG[], int noOfC); long getID(); void getCourses(string c[], int noOfC); void getGrades(char cG[], int noOfC); studentType(string fName = "", string lastName = "", long id = 0, string c[] = NULL, char cG[] = NULL, int noOfC = 0); private: long studentId; string courses[6]; char coursesGrade[6]; int noOfCourses; }; ```

Key concepts

Pure Virtual Functions

In C++, a pure virtual function is a function declared in a base class that is assigned to 0. This means the function does not have a body in the base class. When a class contains at least one pure virtual function, it is considered an abstract class. These functions are placeholders meant to be overridden in any derived class.

Pure virtual functions are useful because they enable creating blueprints for other classes. You might compare them to empty boxes, where each derived class fills these empty boxes with its own specific implementation.

• The syntax for a pure virtual function declaration is: `virtual void functionName() = 0;`.
• A class having one or more pure virtual functions cannot be instantiated directly.
• Derived classes must provide implementations for all inherited pure virtual functions, otherwise, they too will become abstract classes.

This promotes a design known as polymorphism, where the same function can act differently depending on which derived class is implementing it.

Inheritance in C++

Inheritance in C++ allows one class (the derived class) to inherit attributes and behavior (methods) from another class (the base class). This is one of the cornerstones of C++ Object-Oriented Programming and facilitates code reusability.

• The `public studentType : public personType{}` syntax means `studentType` is inheriting from `personType`, taking all its public and protected members.
• Inheritance establishes a "is-a" relationship; for example, a `studentType` is a `personType`.
• Beyond just copying over members, inheritance can mean the derived class can also extend or modify the behavior of the base class's methods.

Inheritance enhances encapsulation by allowing derived classes to use and extend functionalities of existing classes. It promotes easier maintenance and scalability of applications.

Abstract Base Class

An abstract base class is a class that is designed to be specifically used as a base class. It is a class that cannot be instantiated on its own and typically contains one or more pure virtual functions. These classes provide an interface for other classes to implement.

Using abstract base classes in C++ encourages a design pattern where specific methods must be implemented by subclasses, enforcing a certain level of consistency and reliability across derived classes.

• An abstract base class guides the design of derived classes, ensuring they implement required behaviors.
• These classes emphasize defining a protocol or contract for the derived classes to follow.
• A design using abstract classes is often more adaptable to changes, as new classes can be introduced without modifying existing ones.

Creating abstract base classes using pure virtual functions ensures that derived classes provide the detailed functionality while the base class provides the interface guide. This makes your architecture robust, future-proof, and efficient.