Pure virtual method called terminate called without an active exception

When encountering the error message “pure virtual method called terminate called without an active exception,” it typically means that a pure virtual function (a function declared as virtual in a base class and with no implementation) is being called without an appropriate exception handling mechanism being in place.

To better understand the issue, let’s consider the following example:

    #include <iostream>
    using namespace std;
    
    class Base {
    public:
      virtual void doSomething() = 0;  // Pure virtual function
    };
    
    class Derived : public Base {
    public:
      void doSomething() override {
        // Implementation code
        throw exception();  // Throwing an exception
      }
    };
    
    int main() {
      Base* obj = new Derived();
      obj->doSomething();  // Calling the pure virtual function
    
      delete obj;
      return 0;
    }
  

In this example, we have defined a base class Base with a pure virtual function doSomething(). The derived class Derived provides an implementation for the doSomething() function and throws an exception within it.

However, when we create an instance of the derived class and call the pure virtual function through a pointer to the base class (obj->doSomething();), an exception is thrown, but there is no active exception handling mechanism in place to catch it. This results in the error message mentioned.

To resolve this issue, we need to ensure that proper exception handling code, such as try-catch blocks, is added to catch any potential exceptions that might occur:

    int main() {
      Base* obj = new Derived();
      try {
        obj->doSomething();  // Calling the pure virtual function with exception handling
      } catch (const exception& e) {
        // Handle the exception
        cout << "Exception caught: " << e.what() << endl;
      }
    
      delete obj;
      return 0;
    }
  

Now, by enclosing the function call within a try block and providing a catch block to handle the thrown exception, we can avoid the “terminate called without an active exception” error and handle any potential exceptions gracefully.