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` function declarations to make them pure virtual.

Step-by-step solution

Understand the Concept of Pure Virtual Functions

In a class, a pure virtual function is declared by assigning 0 to the virtual function. It provides no implementation in the base class and is meant to be overridden in any derived class.

Modify Function Signatures

Transform the member functions `print` and `calculateGPA` into pure virtual functions by adding `= 0` at their declaration. This makes studentType an abstract class.

Implement the Class Definition

Rewrite the class definition as follows: ``` 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; }; ```

Verify Class Design

Ensure that `studentType` is now an abstract class due to the presence of pure virtual functions. It means you cannot instantiate `studentType` directly, and it must be inherited by another class that provides implementations for `print` and `calculateGPA`.

Key concepts

Pure Virtual Functions

In C++, pure virtual functions are a special kind of virtual function that are declared in a base class, but do not include any implementation. These functions serve as a placeholder in the base class and must be overridden in any derived class. When a class has one or more pure virtual functions, it becomes abstract and cannot be instantiated directly.
To create a pure virtual function, you declare it using the syntax `virtual returnType functionName() = 0;`. The `= 0` at the end of the declaration specifies that the function has no implementation in the base class, marking it as pure virtual. This requirement enforces developers to provide their own specific implementation when creating derived classes.
In our problem, transforming the `print` and `calculateGPA` functions into pure virtual functions in the `studentType` class means these functions will have no body in the `studentType` class. They are only defined, but not implemented, urging derived classes to develop their unique logic for these functions.

Abstract Classes

An abstract class in C++ is a class that cannot be instantiated directly. It typically contains one or more pure virtual functions. This abstraction allows the developer to define common interfaces for different classes, setting a template for derived classes to follow.
By making the `studentType` class abstract through the introduction of pure virtual functions like `print` and `calculateGPA`, we ensure that it can only be used as a base class. Derived classes must override these virtual functions with their specific functionality. This enforces a contract between the base class and derived classes, enabling polymorphic behavior.
Abstract classes are crucial in C++ for designing a clear protocol for complex systems with multiple and varying implementations. They enhance flexibility and modularity by providing a skeleton for functionality that can be filled in multiple, different ways by subclasses.

Inheritance

Inheritance is a fundamental feature of object-oriented programming in C++. It allows a class, known as a derived class, to acquire properties and behaviors from another class, called the base class. Utilizing inheritance reduces redundancy by enabling the reuse of existing code and implementing new extensions while retaining a single point of maintenance.
In the problem context, `studentType` inherits from `personType`. This means `studentType` gains all public and protected members of `personType`, enabling `studentType` to extend or customize its behavior. By changing `studentType` to an abstract class, it is designed to further be a base class itself, thereby promoting a hierarchical class structure.
Inheritance not only facilitates code reuse but also establishes a natural framework for the implementation of pure virtual functions, where derived classes supply the specific behavior.

Function Overriding

Function overriding occurs when a function in a derived class has the same name, return type, and parameters as a function in its base class. In C++, this allows the derived class to provide its specific implementation of a function originally declared (and often defined) in the base class.
When dealing with pure virtual functions in abstract classes, function overriding is a means of providing concrete implementations in derived classes. With `studentType` set as abstract due to pure virtual functions, any class deriving from `studentType` must provide definitions for `print` and `calculateGPA`, thus overriding these functions.
Overriding is essential in implementing polymorphism. It allows objects to be treated as instances of their base type, but with behavior that corresponds to the actual derived type implementation. For instance, calling `print` on a `studentType` reference will execute the overridden version in the derived class.