Creating Abstract Classes

virtual void function_name(parameters) = 0;

• No implementation: The pure virtual function has no function body within the base class. The `= 0` notation signifies this.
• Mandatory override: Any derived class that inherits from the base class *must* provide a concrete implementation for the pure virtual function; otherwise, the derived class itself becomes abstract.

• Cannot be instantiated: You cannot create objects directly from an abstract class. It primarily serves as a blueprint or interface for derived classes.
• Enforce inheritance: Abstract classes ensure that derived classes provide the necessary implementations for specific behaviors defined by the pure virtual functions.

1. Defining Interfaces: The primary purpose of this combination is to establish a contract or an interface. The abstract class defines the essential methods (pure virtual functions) that all its derived classes must implement. This promotes consistency and ensures that derived classes conform to a specific structure.
2. Polymorphism: Abstract classes and pure virtual functions are the foundation of polymorphism in C++. Derived classes can provide their unique implementations for the inherited pure virtual functions. This allows you to treat objects of different derived classes in a uniform way through a pointer or reference to the abstract base class.

class Shape { // Abstract class 
public:
    virtual void calculateArea() = 0; // Pure virtual function
};

class Rectangle : public Shape {
public:
    void calculateArea() override { 
        // Implementation for calculating the area of a rectangle 
    } 
};

class Circle : public Shape {
public:
    void calculateArea() override { 
        // Implementation for calculating the area of a circle 
    } 
};

virtual function prototype = 0;

class Abstract_Base {
public:
   //interface - largely virtual
  Abstract_Base();    // default constructor
   //copy constructor
  Abstract_Base(const Abstract_Base&);
   // destructor should be virtual
  virtual ~Abstract_Base();
   // pure virtual function for print
  virtual void print() = 0;
  ...
}

• Abstract Classes and Pure Virtual Functions A base class reference or pointer can be assigned a derived class object or address. Manipulation of such a reference or pointer can be polymorphic by using virtual functions, the properly overridden function defined in the derived class is called dynamically. Usually, such a base class is abstract. This identifies the class as an important type to be used polymorphically. It guarantees that the compiler will insist on overridden member function definitions where concrete behavior for derived types is needed.
• Virtual Functions: To use heterogeneous lists effectively, we need functions that can be applied to any object on the list without regard to its class. Such functions will generally have different definitions for different classes. We want the appropriate definition to be used whenever a function is applied to an object, even though the class of the object was not known at compile. In C++ these capabilities are provided by virtual functions.

#include <iostream>
using namespace std;
class Bird {
 public:
  Bird() throw();
  virtual ~Bird() throw();
  int altitude() const throw();
  virtual void fly() throw();
  // PROMISE: altitude() will return a number > 0; never throws an exception.
  protected:
   int altitude_;
  };
  Bird::Bird() throw(): altitude_(0){ }
  Bird::~Bird() throw() { }
  int Bird::altitude() const throw(){ 
    return altitude_; 
  }
  void Bird::fly() throw(){ 
   altitude_ = 100; 
  }

// Legitimate reliance on what Bird::fly() says
void sample(Bird& bird) throw() {
  bird.fly();
}

class CannotFly { };
class Ostrich : public Bird {
 public:
  virtual void fly() throw(CannotFly);
  // PROMISE: throws an exception despite what Bird says
 };
 void Ostrich::fly() throw(CannotFly){throw CannotFly(); }

int main(){
  Ostrich bird;
  sample(bird); // Legitimate conversion from Ostrich to Bird
}

Member function throws an Exception

Abstract Classes - Quiz