C++ प्रोग्रामिंग इंटर्नल्स: कंपाइलर कैसे काम करता है

C++ इंटर्नल्स क्या है?

C++ इंटर्नल्स का अर्थ है कि C++ कंपाइलर कैसे .cpp कोड को कंपाइल करता है और हमें आउटपुट देता है। C++ सिस्टम सॉफ्टवेयर लिखने के लिए सबसे लोकप्रिय प्रोग्रामिंग भाषा है। यह C प्रोग्रामिंग भाषा का विस्तार है। C एक कंपाइल्ड भाषा है। C++ कंपाइलर C++ कोड को कंपाइल करके ऑब्जेक्ट या एक्जीक्यूटेबल फाइल उत्पन्न करता है। एक्जीक्यूटेबल या बाइनरी फाइलों में मशीन एक्जीक्यूटेबल निर्देश और मशीन निर्देशों का कुछ मेटाडेटा होता है।

कंपाइलेशन प्रक्रिया

1. प्रीप्रोसेसिंग - #include, #define, मैक्रोज़ का विस्तार
2. कंपाइलेशन - C++ कोड को असेंबली कोड में अनुवाद
3. असेंबली - असेंबली कोड को मशीन कोड (ऑब्जेक्ट फाइल) में बदलना
4. लिंकिंग - ऑब्जेक्ट फाइलों और लाइब्रेरी को जोड़कर एक्जीक्यूटेबल बनाना

C++ इंटर्नल्स के प्रमुख घटक

• फंक्शन ओवरलोडिंग - एक ही नाम को कई परिभाषाएं देना
• क्लास - एक इकाई जो डेटा और संबंधित फंक्शन्स को एक साथ रखती है
• स्ट्रक्चर - एक इकाई जो विभिन्न डेटा प्रकारों का डेटा रखती है
• कंस्ट्रक्टर - क्लास का डिफ़ॉल्ट फंक्शन जो ऑब्जेक्ट्स बनने पर कॉल होता है
• डिस्ट्रक्टर - क्लास का डिफ़ॉल्ट फंक्शन जो ऑब्जेक्ट्स नष्ट होने पर कॉल होता है
• इनहेरिटेंस - एक क्लास के सदस्यों का उपयोग दूसरी क्लास द्वारा करने की अवधारणा
• मल्टीपल इनहेरिटेंस - सिंगल क्लास एक से अधिक बेस क्लास से इनहेरिट करती है
• मल्टीलिवेल इनहेरिटेंस - A, B से इनहेरिट करता है जो C से इनहेरिट करता है
• वर्चुअल फंक्शन्स - चाइल्ड क्लास में परिभाषित फंक्शन
• वर्चुअल बेस क्लास - एक ही बेस क्लास के कई इंस्टेंस को रोकता है

कंपाइलर इंटर्नल्स उदाहरण

#include <iostream>
using namespace std;

class Base {
public:
    // कंपाइलर क्लास "Base" के लिए एक कंस्ट्रक्टर बनाएगा
};

class ClassA {
public:
    ClassA() {
        cout << "ClassA Constructor defined by user" << endl;
    }
    int x; // यह इनिशियलाइज़ नहीं होगा
};

class ClassB : public ClassA {
    // कंपाइलर ClassB कंस्ट्रक्टर बनाएगा और ClassA कंस्ट्रक्टर को कॉल करने का कोड जोड़ेगा
};

class ClassC : public ClassA {
public:
    ClassC() { // यूजर डिफाइंड कंस्ट्रक्टर, लेकिन कंपाइलर A कंस्ट्रक्टर को कॉल करने का कोड जोड़ेगा
        cout << "User defined ClassC Constructor" << endl;
    }
};

class ClassD {
public:
    ClassD() {
        // यूजर डिफाइंड डिफ़ॉल्ट कंस्ट्रक्टर। कंपाइलर ClassA के ऑब्जेक्ट को कॉल करने का कोड जोड़ेगा
        cout << "User-defined constructor for ClassD Constructor" << endl;
    }
private:
    ClassA obj;
};

int main() {
    Base baseObj;
    ClassB b;
    ClassC c;
    ClassD d;
    return 0;
}

आउटपुट

ClassA Constructor defined by user
ClassA Constructor defined by user
User defined ClassC Constructor
ClassA Constructor defined by user
User-defined constructor for ClassD Constructor

व्याख्या

1. Base baseObj: कंपाइलर द्वारा डिफ़ॉल्ट कंस्ट्रक्टर प्रदान किया गया
2. ClassB b: ClassB का कंपाइलर-जनरेटेड कंस्ट्रक्टर ClassA कंस्ट्रक्टर को कॉल करता है
3. ClassC c: यूजर-डिफाइंड ClassC कंस्ट्रक्टर, लेकिन कंपाइलर पहले ClassA कंस्ट्रक्टर को कॉल करता है
4. ClassD d: ClassD का कंस्ट्रक्टर, फिर मेंबर ऑब्जेक्ट obj के लिए ClassA कंस्ट्रक्टर

कंपाइलर इंटर्नल्स समझने के लाभ

• बेहतर कोड लिखने में मदद करता है
• मिक्स्ड-मोड कोड (C, C++, असेंबली) लिखने वालों के लिए आवश्यक
• परफॉरमेंस ऑप्टिमाइज़ेशन समझने में सहायक
• डिबगिंग और अनडिफाइंड बिहेवियर से बचने में मदद