The abstract class whose pure virtual method has to be 
implemented by all the classes which derive on these. 
Otherwise it would result in a compilation error.
This construct should be used when one wants to ensure that 
all the derived classes implement the method defined as 
pure virtual in base class. 

in inheritance if the base class contains a virtual 
function equating to zero, it is known also as do-nothing  
function & that base class is called as abstract base class 
as there are no instances or objects can be created by this 
base class. And this pure virtual can be filled with the 
codes in successiv derived classes accordin to the user 
requirements.
          The syntax of the pure virtual function is....
          
      class class_name
      {
         visibility mode:\\should be protected:
         virtual return_type function_name()=0;
       }
      new class_name : inheritance_type old class_name
       {
         ........  //class body
         ........
        }

Virtual function vs pure virtual function :

Virtual function :-

1. Virtual function have a function body.
2. Overloaded can be done by the virtual funciton. 
(Optional)
3. It is define as : virtual int myfunction();


Pure virtual function :-

1. Pure virtual function have no function body.
2. Overloading is must in pure virtual funciton. (Must)
3. It is define as : virtual int myfunction() = 0;
4. A class is "abstract class" when it has at least one 
pure virtual function.
5. You cann't create instance of "abstract class", rather 
you have to inherit the "abstract class" and overload all 
pure virtual function.

Like :- CControlBar class is an "abstract class".

A virtual function that is initialized to zero (0) is 
referred to as pure virtual function.It has no body and 
hence also known as do-nothing or the dummy function.
Example: virtual void show()=0;

A class containing one or more pure virtual functions is 
called an Abstract class, which means an instance of such 
class can't be created (but pointer to that class can be 
created).We should use pure virtual function if we do not 
want to instantiate a class but make it act as a base class 
for all the classes that derive from it.An important thing 
to note about pure virtual functions is that these 
functions must be overridden in all the derived classes 
otherwise the compile would flag out an error.

Sample program:

class alpha
{
public:virtual void show()=0; //pure virtual function
};
class beta:public alpha
{
public:void show()   //overriding
       {
       cout<<"OOP in C++";
       }
};
void main()
{
alpha *p;
beta b;
p=&b;
p->show();
}

Output: OOP in C++