Interfaces in C++

Example program demonstrating interfaces in C++

Consider the following example where parent class provides an interface to the child  class to implement a function called getArea() 

#include<iostream>
using namespace std;
// parent class
class Shape 
{
  public:
  // pure virtual function providing interface framework.
  virtual int getArea() = 0;
  void setWidth(int w) {
    width = w;
  }
  void setHeight(int h) {
   height = h;
  }
  protected:
  int width;
  int height;
};
// child classes for implementation
class Rectangle: public Shape {
  public:
  int getArea() { 
   return (width * height); 
  }
};
// child classes for implementation
class Triangle: public Shape {
  public:
  int getArea() { 
    return (width * height)/2; 
  }
};
int main()
{
  Rectangle Rect;
  Triangle Tri;
  Rect.setWidth();
  Rect.setHeight(4);
  // display the area of the object.
  cout << "Total Rectangle area: " << Rect.getArea() << endl;

  Tri.setWidth(8);
  Tri.setHeight(4);

  // Print the area of the object.
  cout << "Total Triangle area: " << Tri.getArea() << endl;
  return 0;
}


0/P
Total Rectangle area: 32
Total Triangle area: 16

You can see how an abstract class defined as an interface in terms of getArea() and two other classes implemented the same function but with a different set of code to calculate the area specific to the shape.

Point to remember about abstract classes

• An abstract class cannot be used and not allowed to create objects, just it is used as an interface if you try to create an object of an abstract class that it was a compile time error
• A child class that is implementing a parent abstract class must define all the pure virtual functions of parent class in the child then only child class can be allowed to create objects and use them 

Why interfaces

• In OOP’s  design system an abstract base class will provide a common generalized  interface that is appropriate and can be used for all external applications of similar type 
• Interface mechanism allows applications  to add new   software updates and other changes  to the existing system easily even after a software system has been defined