अंतिम अद्यतन：2026-10-12

C++ प्योर वर्चुअल फ़ंक्शन और एब्स्ट्रैक्ट क्लास¶

लेखक के बारे में:¶

व्यक्तिगत WeChat सार्वजनिक अकाउंट:

wechat

1.प्योर वर्चुअल फ़ंक्शन और एब्स्ट्रैक्ट क्लास¶

C++ में प्योर वर्चुअल फ़ंक्शन (या एब्स्ट्रैक्ट फ़ंक्शन) वह वर्चुअल फ़ंक्शन है जिसे हमने implement नहीं किया! हमें केवल उसे declare करना है! declaration में 0 assign करके प्योर वर्चुअल फ़ंक्शन declare किया जाता है!

// 抽象类
Class A {
public: 
    virtual void show() = 0; // 纯虚函数
    /* Other members */
};

प्योर वर्चुअल फ़ंक्शन: बिना फ़ंक्शन बॉडी वाला वर्चुअल फ़ंक्शन
एब्स्ट्रैक्ट क्लास: जिस क्लास में प्योर वर्चुअल फ़ंक्शन हो

एब्स्ट्रैक्ट क्लास केवल बेस क्लास की तरह नई क्लास derive करने के लिए उपयोग होती है, एब्स्ट्रैक्ट क्लास का ऑब्जेक्ट नहीं बनाया जा सकता, एब्स्ट्रैक्ट क्लास का पॉइंटर और रेफ़रें-> एब्स्ट्रैक्ट क्लास से derive हुई क्लास का ऑब्जेक्ट!

कोड उदाहरण: abstract_base.h, pure_virtual.cpp

2.एब्स्ट्रैक्ट क्लास implement करना¶

एब्स्ट्रैक्ट क्लास में: मेंबर फ़ंक्शन के अंदर प्योर वर्चुअल फ़ंक्शन कॉल किया जा सकता है, कंस्ट्रक्टर/डिस्ट्रक्टर के अंदर प्योर वर्चुअल फ़ंक्शन उपयोग नहीं किया जा सकता।

अगर कोई क्लास एब्स्ट्रैक्ट क्लास से derive हुई है, तो उसे बेस क्लास के सभी प्योर वर्चुअल फ़ंक्शन implement करने होंगे, तभी वह non-abstract क्लास बन सकती है।

// A为抽象类
class A {
public:
    virtual void f() = 0;  // 纯虚函数
    void g(){ this->f(); }
    A(){}  // 构造函数
};

class B : public A{
public:
    void f(){ cout<<"B:f()"<<endl;}  // 实现了抽象类的纯虚函数
};

कोड उदाहरण: abstract.cpp

3.महत्वपूर्ण बिंदु¶

प्योर वर्चुअल फ़ंक्शन किसी क्लास को एब्स्ट्रैक्ट क्लास बना देता है

// 抽象类至少包含一个纯虚函数
class Base{
public: 
    virtual void show() = 0; // 纯虚函数
    int getX() { return x; } // 普通成员函数

private:
     int x; 
};

एब्स्ट्रैक्ट क्लास टाइप का पॉइंटर और रेफ़रेंस

class Derived : public Base { 
public: 
    void show() { cout << "In Derived \n"; } // 实现抽象类的纯虚函数
    Derived(){} // 构造函数
}; 

int main(void) 
{ 
    //Base b;  // error! 不能创建抽象类的对象
    //Base *b = new Base(); error!

    Base *bp = new Derived(); // 抽象类的指针和引用 -> 由抽象类派生出来的类的对象
    bp->show();
    return 0; 
}

अगर हम derived क्लास में प्योर वर्चुअल फ़ंक्शन को override न करें, तो derived क्लास भी एब्स्ट्रैक्ट क्लास बन जाएगी
```
// Derived为抽象类
class Derived: public Base 
{ 
public: 
//    void show() {}
}; 
```

एब्स्ट्रैक्ट क्लास में कंस्ट्रक्टर हो सकता है

// 抽象类
class Base { 
    protected: 
        int x; 
    public: 
        virtual void fun() = 0; 
        Base(int i) { x = i; }  // 构造函数
}; 
// 派生类
class Derived: public Base 
{ 
    int y; 
public: 
    Derived(int i, int j) : Base(i) { y = j; } // 构造函数
    void fun() { cout << "x = " << x << ", y = " << y; }
};

कंस्ट्रक्टर वर्चुअल फ़ंक्शन नहीं हो सकता, जबकि डिस्ट्रक्टर वर्चुअल डिस्ट्रक्टर हो सकता है
```
// 抽象类
class Base  {
public:
    Base(){ cout << "Constructor: Base" << endl; }
    virtual ~Base(){ cout << "Destructor : Base" << endl; }

    virtual void func() = 0;
};

class Derived: public Base {
public:
    Derived(){ cout << "Constructor: Derived" << endl; }
    ~Derived(){ cout << "Destructor : Derived" << endl;}

    void func(){cout << "In Derived.func()." << endl;}
};
```
जब बेस क्लास पॉइंटर derived क्लास ऑब्जेक्ट की ओर पॉइंट करे और ऑब्जेक्ट delete किया जाए, हम शायद उपयुक्त डिस्ट्रक्टर कॉल होना चाहें। अगर डिस्ट्रक्टर virtual न हो, तो केवल बेस क्लास का डिस्ट्रक्टर कॉल होगा।

4.पूरा उदाहरण¶

एब्स्ट्रैक्ट क्लास को derived क्लास inherit करके implement करती है!

कोड उदाहरण: derived_full.cpp