Ad

Saturday, August 11, 2007

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();
  }

Related Articles:

2 comments:

  1. I recently came across your blog and have been reading along. I thought I would leave my first comment. I don't know what to say except that I have enjoyed reading. Nice blog. I will keep visiting this blog very often.

    Betty


    http://www.my-foreclosures.info

    ReplyDelete
  2. @Betty

    Thanks very much!

    Enjoy!

    ReplyDelete

You are free to comment anything, although you can comment as 'Anonymous' it is strongly recommended that you supply your name. Thank You.

Please don't use abusive language.