Question

A.3 - 10 pts It is legal to have a pure virtual destructor in a C++ class as far as that destructor has a function body. Please explain the logic behind this requirement. int fu int fu Pure virtual functions in C++ can have function body implementation. Please explain a scenario when and how this implementation is used. Then please provide a sample code to access/invoke that original function code if it was overridden by a child class

Answer 1

ANS 1 : Yes , it is legal to have a pure virtual destructor in a C++ class as far as the destrutor has a function body.

Explanation : Here , when we come to the pure virtual functions here the pure virtual functions are the functions that are declared in a base class for which the definition is not relative to the base class.So, in these cases the compiler requires each derived class to either define the function or redeclare it is a pure virtual function.

- And when it comes to a pure virtual destructor here we know that the destructor is different from the other functions because these are not "overridden" but the actual process what will be done is that these are called in the reverse order of the class derivation i.e; here the derived class destructor will be called before the base class destructor and in case if we don't provide any function body then it will not find any object to destruct and then it will raise an error .So, if there is a function body then it is easy to make a pure virtual destructor by a simple definition.

Code :

class Base_class {
public:
  virtual ~Base_class() = 0;
};

Base_class::~Base_class() {}

class Derived_class : public Base_class {};

int main() { 
  
  Derived_class d; 
}

Ans 2: We know that , the pure virtual functions are the virtual functions that are simply declared without any implementation and they are initialized to 0 and here when we come the function body implementation in c++ here the implementation can be used in the situation i.e; here if you have a certain program that will be executed by a derived class but here it was not wanted to be executed directly but it should be executed in such a way that it was forced to be overridden in such cases the implementation of pure virtual functions are used and here it forces the derived ones to override the methods.

Code :

/*

#include <iostream>
using namespace std;

class Parent
{
public:
Parent(){}
virtual void fun() = 0;
};

void Parent::fun()
{
cout<<"Hi";
}

class Children : public Parent
{
public:
Children(){}

void fun(){
cout<<"Hello";
}
};

int main(int argc, char const *argv[])
{
Children a;
a.Parent::fun();
return 0;
}

*/

Output :

Hi ..Program finished with exit code 0 Press ENTER to exit console.