C++ Virtual Functions

Introduction to C++ Virtual Functions

C++ आपको polymorphism की capability provide करती है। Polymorphism का मतलब एक interface से कई तरह के अलग अलग codes को execute करना होता है। जैसा की function overloading और constructor overloading में आप करते है।

Function overloading में आप एक ही नाम के function को अलग अलग data types के साथ create करते है। इसके बाद function को call करवाते समय user जिस तरह का data type pass करते है उसके अनुसार function की appropriate definition execute हो जाती है। इसे run-time polymorphism कहा जाता है। क्योंकि इसमें run time पर decide किया जाता है की function की कौनसी definition execute होगी।

उसी प्रकार pointers के माध्यम से भी आप polymorphism achieve कर सकते है। सिर्फ base class के pointer से ही आप दोनों classes के functions को execute करवा सकते है। ऐसा virtual functions के माध्यम से किया जाता है। Virtual functions के बारे में और अधिक जानने से पहले आपको ये जानने की जरुरत है की virtual functions की जरुरत क्यों पड़ी। इसे निचे एक उदाहरण के माध्यम से समझाया जा रहा है।

उदाहरण के लिए मान लीजिये आपने एक class create की है जिसका नाम color है। इस class में आपने display() नाम से एक function भी create किया हुआ है।

class Color
{
     public:
            void display()
            {
                 cout<<"Red Green Blue";
            }  
};

Color class को एक दूसरी class inherit करती है जिसका नाम RedColor है। इस class में भी एक display() नाम का function create किया गया है।

class RedColor : public Color
{
      public:
              void display()
              {
                       cout<<"Red";               
              }
};

मान लीजिये आप main() function में base class का एक pointer create करते है। सबसे पहले आप इस pointer को base class object assign करते है और फिर pointer के माध्यम से base class का display() function call करते है। जब आप ऐसा करते है तो display() function “Red Green Blue” print करता है।

int main()
{
      Color *basepntr;  //base class pointer
      color baseobj;  //base class object
      RedColor derivedObj  //derived class object

      basepntr = &baseobj; //assigning base class obj to base class pointer
      basepntr->display(); //executing base class display() function

      basepntr=&derivedObj; // assigning derived class obj to base class pointer
      basepntr->display(); //Will still execute base class display() function

      return 0;
}

इसके बाद आप derived class का object create करते है और इसे base class के pointer को assign करते है। अब आप वापस base class के pointer के द्वारा display() function को call करते है। जब आप ऐसा करते है तो वापस base class का ही display() function execute होता है। और “Red Green Blue” output show होता है।

लेकिन क्योंकि यँहा पर derived class का object pointer को assign किया गया है तो derived class का display() function execute होना चाहिए, पर ऐसा नहीं होता है। इसका main कारण ये है की pointer उसी type के functions को execute कर रहा है जिस type का वह खुद है।

यानी की ऊपर दिए गए उदाहरण में base class का pointer create किया गया है, इसलिए वह pointer सिर्फ base class के function को ही execute कर रहा है। ऐसी situation में C++ polymorphism feature work नहीं कर रहा है।

इस situation में polymorphism achieve करने एक लिए C++ आपको एक mechanism provide करती है जिसे virtual function कहते है। Virtual functions को virtual keywords से create किया जाता है। Virtual functions सिर्फ base class में ही create किये जाते है। Virtual functions compiler को बताते है की same नाम का function derived class में भी create किया गया है। इसलिए यदि object derived class का है तो function भी derived class का ही execute किया जायेगा।

Rules For Creating C++ Virtual Functions

Virtual function को create और use करने के कुछ नियम होते है जिन्हें follow करना बहुत जरूरी है। आइये इनके बारे में जानने का प्रयास करते है।

  1. Virtual functions static नहीं हो सकते है।
  2. Virtual functions को object pointers के द्वारा access किया जाता है।
  3. Virtual functions को base class में define किया जाना चाहिए, चाहे फिर उन्हें बाद में यूज़ किया जाये या नहीं।
  4. Virtual functions किसी दूसरी class के friend function भी हो सकते है।
  5. Virtual function का declaration और derived class में same नाम के function का declaration same होना चाहिए। यदि data types भी different है तो virtual function mechanism work नहीं करेगा।
  6. हालाँकि base class के pointer से किसी भी derived class को point किया जा सकता है, लेकिन derived class के pointer से base class को point नहीं किया जा सकता है।
  7. Base class में define किये गए virtual function को derived class में दुबारा define करने की आवश्यकता नहीं होती है। यदि ऐसा किया जाता है तो base class का function ही execute होगा।

अब तक आप virtual functions create करने के नियम पढ़ चुके है। आइये अब देखते है की आप किस प्रकार virtual functions को create कर सकते है।

Creating & Using C++ Virtual Functions

Virtual functions define करने के लिए आप virtual keyword यूज़ करते है। इसका general syntax नीचे दिया जा रहा है।

virtual data-type function-name(parameters-list)
{
       //definition to virtual function
}

Example: पहले ऊपर create किये गए program को वापस virtual function का यूज़ करते हुए नीचे create किया गया है।

#include <iostream>
using namespace std;

class Color
{
      public:
             virtual void display()
             {
                     cout<<"Base : Red Green Blue"<<endl;
             }
};

class RedColor : public Color
{
      public:
             void display()
             {
                    cout<<"Derived : Red";
             }    
}

int main()
{
    Color baseobj;
    RedColor derivedobj;

    Color *basepntr;

    basepntr = &baseobj;
    basepntr->display();  //base class display() function will be exeucted

    basepntr = &derivedobj;
    basepntr->display();  //derived class display() function will be executed;

    return 0;
}

जैसा की आप देख सकते है base class में display() function को virtual keyword के साथ define किया गया है। इस program को जब आप execute करेंगे तो ये base class और derived class दोनों के ही display() function का result show करेगा। ये program निचे दिया गया output generate करता है।

Base : Red Green Blue
Derived : Red

Pure Virtual Function

जब आप base class में virtual function create करते है और derived class में भी same ही function create करते है तो आप base class के function को बहुत कम यूज़ करते है या फिर करते ही नहीं है। ऐसी situation में आपको base class के virtual function की definition provide करने की कोई आवश्यकता नहीं होती है।

इस situation में आप एक ऐसा virtual function create करते है जो कुछ भी नहीं करता है। इस तरह के function को pure virtual function कहा जाता है। Pure virtual function create करने के लिए आप normal virtual के declaration के बाद definition की बजाय assignment operator (=) लगाकर कर उसे 0 assign कर देते है। इसका syntax नीचे दिया जा रहा है।

virtual data-type function-name(parameter-list) = 0;

उदाहरण के लिए ऊपर दिए program के लिए pure virtual function इस प्रकार create किया जायेगा।

virtual void display() = 0;

Related Posts