Interface

'Interface' for subclass

#include <iostream>
using namespace std;

class AreaClass {
public:
  double height;
  double width;
};

class Rectangle : public AreaClass {
public:
  Rectangle(double h, double w);
  double area();
};

class Isosceles : public AreaClass {
public:
  Isosceles(double h, double w);
  double area();
};

Rectangle::Rectangle(double h, double w)
{
  height = h;
  width = w;
}

Isosceles::Isosceles(double h, double w)
{
  height = h;
  width = w;
}

double Rectangle::area()
{
  return width * height;
}
 
double Isosceles::area()
{
  return 0.5 * width * height;
}

int main()
{
  Rectangle rectangleObject(10.0, 5.0);
  Isosceles isoscelesObject(4.0, 6.0);

  cout << "Rectangle: " << rectangleObject.area() << endl;
  cout << "Triangle: " << isoscelesObject.area() << endl;

  return 0;
}

Use virtual function to define interface.

#include <iostream>
using namespace std;

class area {
  double dim1, dim2; 
public:
  void setarea(double d1, double d2)
  {
    dim1 = d1;
    dim2 = d2;
  }
  void getdim(double &d1, double &d2)
  {
    d1 = dim1;
    d2 = dim2;
  }
  virtual double getarea()
  { 
    cout << "You must override this function\n";
    return 0.0;
  }
};

class rectangle : public area {
public:
  double getarea() 
  {
    double d1, d2;
    getdim(d1, d2);
    return d1 * d2;
  }
};

class triangle : public area {
public:
  double getarea()
  {
    double d1, d2;
  
    getdim(d1, d2);
    return 0.5 * d1 * d2;
  }
};

int main()
{
  area *p;
  rectangle r;
  triangle t;

  r.setarea(3.3, 4.5);
  t.setarea(4.0, 5.0);

  p = &r;
  cout << "Rectangle has area: " << p->getarea() << '\n';

  p = &t;
  cout << "Triangle has area: " << p->getarea() << '\n';

  return 0;
}

Demonstrate virtual functons: list interface

#include <iostream>
#include <cstdlib>
#include <cctype>
using namespace std;

class list {
public:
  list *head;             // pointer to start of list
  list *tail;             // pointer to end of list 
  list *next;             // pointer to next item
  int num;                // value to be stored

  list() { 
     head = tail = next = NULL; 
  }
  virtual void store(int i) = 0;
  virtual int retrieve() = 0;
};

class queue : public list {
public:
  void store(int i);
  int retrieve();
};

void queue::store(int i)
{
  list *item;

  item = new queue;
  if(!item) {
    cout << "Allocation error.\n";
    exit(1);
  }
  item->num = i;

  if(tail) 
     tail->next = item;
  tail = item;
  item->next = NULL;
  if(!head) 
     head = tail;
}

int queue::retrieve()
{
  int i;
  list *p;

  if(!head) {
    cout << "List empty.\n";
    return 0;
  }

  // remove from start of list
  i = head->num;
  p = head;
  head = head->next;
  delete p;

  return i;
}

class stack : public list {
public:
  void store(int i);
  int retrieve();
};

void stack::store(int i)
{
  list *item;

  item = new stack;
  if(!item) {
    cout << "Allocation error.\n";
    exit(1);
  }
  item->num = i;

  if(head) 
     item->next = head;
  head = item;
  if(!tail) 
     tail = head;
}

int stack::retrieve()
{
  int i;
  list *p;

  if(!head) {
    cout << "List empty.\n";
    return 0;
  }

  // remove from start of list
  i = head->num;
  p = head;
  head = head->next;
  delete p;

  return i;
}

int main()
{
  list *p;

  // demonstrate queue
  queue q_ob;
  p = &q_ob; // point to queue

  p->store(1);
  p->store(2);
  p->store(3);

  cout << "Queue: ";
  cout << p->retrieve();
  cout << p->retrieve();
  cout << p->retrieve();

  cout << '\n';

  // demonstrate stack
  stack s_ob;
  p = &s_ob; // point to stack

  p->store(1);
  p->store(2);
  p->store(3);

  cout << "Stack: ";
  cout << p->retrieve();
  cout << p->retrieve();
  cout << p->retrieve();

  cout << '\n';

  return 0;
}