Properties of Pure Virtual Functions

In the article Properties
of Virtual Functions, we discussed about two properties of virtual
functions in detail. In this article we’ll be discussing about some properties
of Pure
Virtual Functions.

Property #1: We know that a
base class can’t define a pure virtual function and at the same time its
derived class must define it. But what if the derived class is used as base
for deriving yet another class; is this possible?

Yes, it is, as is obvious from the following program:


  #include <iostream.h>

  // base class
  class base
  {
  public:
    // pure virtual function
    // declaration
    virtual void func() = 0;
  };

  // derived class
  class derived1 : public base
  {
  public:
    // must define
    void func()
    {
      cout<<"Derived1's func()\n";
    }
  };

  // derived from class derived1
  class derived2 : public derived1
  {
  public:
    void func()
    {
      cout<<"Derived2's func()\n";
    }
  };

  // main
  void main()
  {
    derived1 d1;
    derived2 d2;

    d1.func();
    d2.func();
  }

Hence strictly speaking, a pure virtual function cannot be declared and defined
in the same class.

Property #2: While it’s
necessary for a derived class to override a pure virtual function but if we
derive yet another class from that derived class then it’s not necessary
for the newly derived class to override that function.

So that means, if we have a hierarchy of derived classes then a pure virtual
function must be overridden at least once.

It is clear from the following program:


  #include <iostream.h>

  // base class
  class base
  {
  public:
    // pure virtual function
    // declaration
    virtual void func() = 0;
  };

  // derived class
  class derived1 : public base
  {
  public:
    // must define
    void func()
    {
      cout<<"Derived1's func()\n";
    }
  };

  // derived from class derived1
  class derived2 : public derived1
  {
  public:
    // may not override the
    // pure virtual function
  };

  // main
  void main()
  {
    derived1 d1;
    derived2 d2;

    d1.func();

    // derived1's function will
    // be called
    d2.func();
  }

Property #3: We know that we
can’t declare objects of Abstract
Classes but since C++ offers very powerful Polymorphism
capability, we can have their pointer (as well as references).

It is clear from the following program:


  #include <iostream.h>

  // base class
  class base
  {
  public:
    // pure virtual function
    // declaration
    virtual void func() = 0;
  };

  // derived class
  class derived1 : public base
  {
  public:
    // must define
    void func()
    {
      cout<<"Derived1's func()\n";
    }
  };

  // derived from class derived1
  class derived2 : public derived1
  {
  public:
    void func()
    {
      cout<<"Derived2's func()\n";
    }
  };

  // main
  void main()
  {
    // although objects of abstract classes
    // cannot be declared but we can have
    // their pointers
    base *bptr;

    derived1 d1;
    derived2 d2;

    // point to derived1 's object
    bptr=&d1;

    // derived1's func will be called
    bptr->func();

    // point to derived2's object
    bptr=&d2;

    // derived2's func will be called
    // same interface is used
    // but different function
    // is called
    bptr->func();
  }