अध्याय 11: ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (Object-Oriented Programming)

अध्याय 11: ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (Object-Oriented Programming)

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) C++ प्रोग्रामिंग की एक प्रमुख और शक्तिशाली अवधारणा है, जो आपको प्रोग्राम को वास्तविक दुनिया की वस्तुओं और उनकी विशेषताओं के अनुरूप डिज़ाइन करने की अनुमति देती है। OOP प्रोग्रामिंग कोड को अधिक संरचित, पुन: प्रयोज्य और बनाए रखने में आसान बनाता है। इस अध्याय में, हम OOP की मूलभूत अवधारणाओं जैसे कि क्लास, ऑब्जेक्ट, इनहेरिटेंस, पॉलिमॉर्फिज्म, एब्स्ट्रैक्शन, और एंकैप्सुलेशन को समझेंगे। इन अवधारणाओं को सीखकर, आप न केवल C++ में बड़े और जटिल प्रोजेक्ट्स को कुशलता से प्रबंधित कर सकेंगे, बल्कि अपने प्रोग्राम को अधिक संगठित और लचीला भी बना सकेंगे। इस अध्याय के अंत तक, आप OOP के सिद्धांतों को समझकर उन्हें अपने प्रोग्रामिंग प्रोजेक्ट्स में आत्मसात करने के लिए तैयार होंगे।

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग क्या है? (What is Object-Oriented Programming?)

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) एक प्रोग्रामिंग पैराडाइम है जो प्रोग्राम को ऑब्जेक्ट्स के संग्रह के रूप में व्यवस्थित करता है। प्रत्येक ऑब्जेक्ट में डेटा और उस डेटा पर काम करने वाली विधियाँ (methods) होती हैं। OOP का मुख्य उद्देश्य प्रोग्राम को अधिक मॉड्यूलर, पुन: प्रयोज्य, और बनाए रखने में आसान बनाना है। यह वास्तविक दुनिया की वस्तुओं और उनके व्यवहार को प्रोग्रामिंग में शामिल करने की क्षमता प्रदान करता है, जिससे कोड को समझना और प्रबंधित करना आसान हो जाता है।

OOP के मुख्य सिद्धांत (Main Principles of OOP)

OOP चार मुख्य सिद्धांतों पर आधारित है:

  1. क्लास और ऑब्जेक्ट्स (Class and Objects):
    • क्लास: क्लास एक ब्लूप्रिंट या टेम्पलेट होता है, जो ऑब्जेक्ट्स के निर्माण के लिए उपयोग किया जाता है। यह डेटा (अट्रीब्यूट्स) और उन पर काम करने वाली विधियों (फंक्शन्स) को एक साथ समूहित करता है।
    • ऑब्जेक्ट: ऑब्जेक्ट एक क्लास का उदाहरण होता है। यह क्लास में परिभाषित गुणों और विधियों का उपयोग करके वास्तविक दुनिया की किसी इकाई का प्रतिनिधित्व करता है। उदाहरण के लिए, “कार” एक क्लास हो सकता है, और “मेरी कार” एक ऑब्जेक्ट हो सकता है।
  2. इनहेरिटेंस (Inheritance):
    • इनहेरिटेंस के माध्यम से, एक क्लास (चाइल्ड क्लास) दूसरी क्लास (पैरेंट क्लास) की विशेषताओं और विधियों को प्राप्त कर सकती है। इससे कोड का पुन: उपयोग संभव होता है और कोड की संरचना को अधिक संगठित किया जा सकता है।
  3. पॉलिमॉर्फिज्म (Polymorphism):
    • पॉलिमॉर्फिज्म का मतलब है कि एक ही नाम की विधियाँ विभिन्न प्रकारों के डेटा पर काम कर सकती हैं। यह दो प्रकार का हो सकता है: कंपाइल-टाइम पॉलिमॉर्फिज्म (फंक्शन ओवरलोडिंग) और रन-टाइम पॉलिमॉर्फिज्म (वर्चुअल फंक्शन्स)।
  4. एब्स्ट्रैक्शन (Abstraction):
    • एब्स्ट्रैक्शन का उद्देश्य प्रोग्राम से जटिलता को छिपाना है। यह केवल आवश्यक जानकारी को दिखाता है और बाकी की जानकारी को छुपाता है, जिससे प्रोग्राम को समझना और काम करना आसान हो जाता है।
  5. एंकैप्सुलेशन (Encapsulation):
    • एंकैप्सुलेशन डेटा और विधियों को एक इकाई में बाँधने की प्रक्रिया है। यह डेटा को बाहरी हस्तक्षेप और गलत उपयोग से सुरक्षित रखता है। प्राइवेट, प्रोटेक्टेड, और पब्लिक एक्सेस स्पेसिफायर का उपयोग करके यह सुनिश्चित किया जाता है कि डेटा सुरक्षित रहे और उसे केवल उपयुक्त विधियों के माध्यम से ही एक्सेस किया जा सके।

OOP के फायदे (Advantages of OOP)

  • मॉड्यूलरिटी: OOP प्रोग्राम्स को छोटे, स्वतंत्र मॉड्यूल्स में विभाजित करने की अनुमति देता है, जिससे कोड को समझना और प्रबंधित करना आसान हो जाता है।
  • पुन: प्रयोज्यता: क्लास और इनहेरिटेंस के माध्यम से, एक बार लिखे गए कोड का पुन: उपयोग किया जा सकता है, जिससे विकास समय और प्रयास की बचत होती है।
  • डाटा सुरक्षा: एंकैप्सुलेशन के माध्यम से, OOP में डेटा को सुरक्षित रखा जाता है और केवल अधिकृत विधियों के माध्यम से ही एक्सेस किया जा सकता है।
  • बड़ी परियोजनाओं में उपयोगी: OOP का उपयोग बड़ी और जटिल परियोजनाओं में किया जाता है, जहाँ कई डेवलपर्स एक साथ काम करते हैं और कोड को मॉड्यूलर और प्रबंधनीय बनाना आवश्यक होता है।

 

क्लास और ऑब्जेक्ट्स (Classes and Objects)

C++ में ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) की मूलभूत इकाइयाँ क्लास और ऑब्जेक्ट्स हैं। ये दोनों अवधारणाएँ OOP की नींव हैं और प्रोग्रामिंग में वास्तविक दुनिया की वस्तुओं और उनकी विशेषताओं को मॉडल करने के लिए उपयोग की जाती हैं। आइए समझते हैं कि क्लास और ऑब्जेक्ट्स क्या होते हैं और उनका उपयोग कैसे किया जाता है।

क्लास क्या है? (What is a Class?)

क्लास एक ब्लूप्रिंट या टेम्पलेट है जो ऑब्जेक्ट्स बनाने के लिए उपयोग किया जाता है। यह एक डेटा संरचना है जो डेटा और विधियों (methods) को एक साथ समूहित करती है। क्लास के अंदर डेटा को अट्रीब्यूट्स (attributes) के रूप में जाना जाता है, और विधियों को फंक्शन्स या मेथड्स के रूप में जाना जाता है।

क्लास के माध्यम से, आप एक प्रकार की वस्तु (जैसे, कार, व्यक्ति, खाता) की संरचना और व्यवहार को परिभाषित कर सकते हैं। एक बार क्लास को परिभाषित कर लेने के बाद, आप इस क्लास के उदाहरण के रूप में कई ऑब्जेक्ट्स बना सकते हैं, जो इस क्लास की सभी विशेषताओं और विधियों का उपयोग कर सकते हैं।

क्लास का निर्माण (Defining a Class):

#include <iostream>
using namespace std;

class Car {
public:
    string brand;
    string model;
    int year;

    void displayInfo() {
        cout << "Brand: " << brand << ", Model: " << model << ", Year: " << year << endl;
    }
};

इस उदाहरण में, Car नामक क्लास परिभाषित की गई है, जिसमें तीन अट्रीब्यूट्स (brand, model, और year) और एक विधि (displayInfo()) शामिल हैं।

ऑब्जेक्ट क्या है? (What is an Object?)

ऑब्जेक्ट एक क्लास का उदाहरण (instance) होता है। यह वह वास्तविक इकाई है जो क्लास के अनुसार परिभाषित की गई विशेषताओं और विधियों का उपयोग कर सकता है। आप एक ही क्लास से कई ऑब्जेक्ट्स बना सकते हैं, और प्रत्येक ऑब्जेक्ट का अपना अलग डेटा होगा, लेकिन सभी ऑब्जेक्ट्स एक ही क्लास की संरचना और व्यवहार का पालन करेंगे।

ऑब्जेक्ट का निर्माण (Creating an Object):

int main() {
    Car car1;  // Car क्लास का एक ऑब्जेक्ट बनाना
    car1.brand = "Toyota";
    car1.model = "Corolla";
    car1.year = 2020;

    Car car2;  // Car क्लास का दूसरा ऑब्जेक्ट बनाना
    car2.brand = "Honda";
    car2.model = "Civic";
    car2.year = 2019;

    car1.displayInfo();  // car1 का डेटा प्रदर्शित करना
    car2.displayInfo();  // car2 का डेटा प्रदर्शित करना

    return 0;
}

इस उदाहरण में, car1 और car2 नामक दो ऑब्जेक्ट्स बनाए गए हैं, जो Car क्लास के उदाहरण हैं। ये दोनों ऑब्जेक्ट्स अपनी-अपनी विशेषताओं (ब्रांड, मॉडल, और वर्ष) को धारण करते हैं और displayInfo() विधि का उपयोग करके अपने डेटा को प्रदर्शित करते हैं।

क्लास और ऑब्जेक्ट्स के बीच संबंध (Relationship Between Class and Objects)

क्लास एक टेम्पलेट है, जबकि ऑब्जेक्ट उस टेम्पलेट का एक वास्तविक उदाहरण है। इसे वास्तविक दुनिया के उदाहरण से समझा जा सकता है: यदि “कार” एक क्लास है, तो “मेरी कार” एक ऑब्जेक्ट है। क्लास में परिभाषित विशेषताएँ और व्यवहार सभी ऑब्जेक्ट्स के लिए समान होते हैं, लेकिन प्रत्येक ऑब्जेक्ट के अपने अलग डेटा होते हैं।

क्लास और ऑब्जेक्ट्स के लाभ (Advantages of Classes and Objects)

  • मॉड्यूलरिटी: क्लास डेटा और विधियों को एक इकाई में बाँधकर प्रोग्राम को मॉड्यूलर बनाती है, जिससे कोड को समझना और बनाए रखना आसान हो जाता है।
  • पुन: प्रयोज्यता: एक बार क्लास को परिभाषित कर लेने के बाद, उसे कई ऑब्जेक्ट्स बनाने के लिए पुन: उपयोग किया जा सकता है, जिससे कोड की पुनरावृत्ति कम होती है।
  • डेटा सुरक्षा: एंकैप्सुलेशन के माध्यम से, क्लास के डेटा को बाहरी हस्तक्षेप से सुरक्षित रखा जा सकता है।

इंहेरिटेंस (Inheritance)

इंहेरिटेंस (Inheritance) ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) का एक प्रमुख सिद्धांत है, जो एक क्लास को दूसरी क्लास की विशेषताओं और विधियों को प्राप्त करने की अनुमति देता है। इस प्रक्रिया में, एक क्लास (जिसे चाइल्ड क्लास या डेरिव्ड क्लास कहा जाता है) दूसरी क्लास (जिसे पैरेंट क्लास या बेस क्लास कहा जाता है) की सभी विशेषताओं (अट्रीब्यूट्स) और विधियों (मेटोड्स) को प्राप्त कर लेती है।

इंहेरिटेंस का मुख्य उद्देश्य कोड का पुन: उपयोग करना, कोड की संरचना को अधिक संगठित बनाना, और प्रोग्राम में रिश्तों का प्रतिनिधित्व करना है।

इंहेरिटेंस के प्रकार (Types of Inheritance)

C++ में, इंहेरिटेंस के कई प्रकार होते हैं:

  1. सिंगल इंहेरिटेंस (Single Inheritance):
    • इसमें एक चाइल्ड क्लास केवल एक ही पैरेंट क्लास से विरासत प्राप्त करता है।
    • उदाहरण: class B : public A { … }; जहाँ B क्लास A से विरासत प्राप्त कर रहा है।
  2. मल्टीपल इंहेरिटेंस (Multiple Inheritance):
    • इसमें एक चाइल्ड क्लास एक से अधिक पैरेंट क्लास से विरासत प्राप्त करता है।
    • उदाहरण: class C : public A, public B { … }; जहाँ C क्लास A और B दोनों से विरासत प्राप्त कर रहा है।
  3. मल्टीलेवल इंहेरिटेंस (Multilevel Inheritance):
    • इसमें एक क्लास दूसरी क्लास से विरासत प्राप्त करता है, और वह क्लास किसी तीसरी क्लास से विरासत प्राप्त करता है।
    • उदाहरण: class C : public B { … }; और class B : public A { … }; यहाँ C को B से और B को A से विरासत मिलती है।
  4. हाइरार्किकल इंहेरिटेंस (Hierarchical Inheritance):
    • इसमें एक से अधिक क्लासेस एक ही पैरेंट क्लास से विरासत प्राप्त करते हैं।
    • उदाहरण: class B : public A { … }; और class C : public A { … }; यहाँ B और C दोनों क्लासेस A से विरासत प्राप्त कर रहे हैं।
  5. हाइब्रिड इंहेरिटेंस (Hybrid Inheritance):
    • इसमें इंहेरिटेंस के कई प्रकारों का संयोजन होता है, जैसे मल्टीपल और मल्टीलेवल इंहेरिटेंस।
    • C++ में डायमंड प्रॉब्लम को संभालने के लिए वर्चुअल इंहेरिटेंस का उपयोग किया जाता है।

इंहेरिटेंस का उपयोग और लाभ (Usage and Benefits of Inheritance)

  • कोड का पुन: उपयोग: इंहेरिटेंस के माध्यम से, आप पैरेंट क्लास में परिभाषित विशेषताओं और विधियों का पुन: उपयोग कर सकते हैं, जिससे कोड की पुनरावृत्ति कम होती है।
  • कोड की संरचना: इंहेरिटेंस प्रोग्राम की संरचना को अधिक संगठित और मॉड्यूलर बनाता है, जिससे कोड को समझना और बनाए रखना आसान हो जाता है।
  • रिश्तों का प्रतिनिधित्व: इंहेरिटेंस वास्तविक दुनिया के रिश्तों का प्रतिनिधित्व करने में मदद करता है, जैसे कि “एक प्रकार का” (is-a) संबंध। उदाहरण के लिए, “कुत्ता” एक “जानवर” है, इसलिए Dog क्लास Animal क्लास से विरासत प्राप्त कर सकती है।

इंहेरिटेंस का एक उदाहरण (Example of Inheritance)

cpp
Copy code
#include <iostream>
using namespace std;

// बेस क्लास
class Animal {
public:
    void eat() {
        cout << "Eating..." << endl;
    }
};

// डेरिव्ड क्लास
class Dog : public Animal {
public:
    void bark() {
        cout << "Barking..." << endl;
    }
};

int main() {
    Dog myDog;

    myDog.eat();  // बेस क्लास का फंक्शन
    myDog.bark(); // डेरिव्ड क्लास का फंक्शन

    return 0;
}

इस उदाहरण में, Dog क्लास Animal क्लास से इंहेरिट करती है। इसलिए, Dog क्लास Animal क्लास के eat() फंक्शन का उपयोग कर सकती है, इसके साथ ही Dog का अपना bark() फंक्शन भी हो सकता है।

एक्सेस स्पेसिफायर और इंहेरिटेंस (Access Specifiers and Inheritance)

इंहेरिटेंस में, पैरेंट क्लास के मेंबर को किस प्रकार से चाइल्ड क्लास में एक्सेस किया जा सकता है, यह एक्सेस स्पेसिफायर द्वारा निर्धारित होता है:

  1. Public Inheritance:
    • पैरेंट क्लास के public मेंबर्स चाइल्ड क्लास में public ही रहते हैं।
    • पैरेंट क्लास के protected मेंबर्स चाइल्ड क्लास में protected ही रहते हैं।
    • प्राइवेट मेंबर्स का डायरेक्ट एक्सेस नहीं होता, लेकिन उन्हें protected या public मेथड्स के जरिए एक्सेस किया जा सकता है।
  2. Protected Inheritance:
    • पैरेंट क्लास के public और protected मेंबर्स चाइल्ड क्लास में protected हो जाते हैं।
  3. Private Inheritance:
    • पैरेंट क्लास के public और protected मेंबर्स चाइल्ड क्लास में private हो जाते हैं।

पोलिमॉर्फिज़्म (Polymorphism)

पोलिमॉर्फिज़्म (Polymorphism) ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) का एक महत्वपूर्ण सिद्धांत है, जो एक ही नाम की विधियों (methods) का उपयोग विभिन्न रूपों में करने की अनुमति देता है। इस अवधारणा का अर्थ है “कई रूप” और इसका उपयोग एक ही इंटरफ़ेस के साथ कई कार्यों को निष्पादित करने के लिए किया जाता है। C++ में, पोलिमॉर्फिज़्म मुख्य रूप से दो प्रकार का होता है: कम्पाइल-टाइम पोलिमॉर्फिज़्म और रन-टाइम पोलिमॉर्फिज़्म।

कम्पाइल-टाइम पोलिमॉर्फिज़्म (Compile-Time Polymorphism)

कम्पाइल-टाइम पोलिमॉर्फिज़्म, जिसे स्ट्रेटिक पोलिमॉर्फिज़्म (Static Polymorphism) भी कहा जाता है, तब होता है जब किसी फ़ंक्शन का चयन कम्पाइल के समय किया जाता है। C++ में, कम्पाइल-टाइम पोलिमॉर्फिज़्म को फंक्शन ओवरलोडिंग और ऑपरेटर ओवरलोडिंग के माध्यम से प्राप्त किया जा सकता है।

1. फंक्शन ओवरलोडिंग (Function Overloading):

फंक्शन ओवरलोडिंग वह प्रक्रिया है जिसमें एक ही नाम के साथ कई फंक्शन्स को परिभाषित किया जाता है, लेकिन उनके पैरामीटर या तो प्रकार में भिन्न होते हैं या उनकी संख्या में। कम्पाइलर पैरामीटर की संख्या या प्रकार के आधार पर यह तय करता है कि किस फंक्शन को कॉल करना है।

उदाहरण:

cpp
Copy code
#include <iostream>
using namespace std;

class Print {
public:
    void show(int i) {
        cout << "Integer: " << i << endl;
    }

    void show(double d) {
        cout << "Double: " << d << endl;
    }

    void show(string s) {
        cout << "String: " << s << endl;
    }
};

int main() {
    Print p;

    p.show(10);       // Integer संस्करण को कॉल करता है
    p.show(10.5);     // Double संस्करण को कॉल करता है
    p.show("Hello");  // String संस्करण को कॉल करता है

    return 0;
}

2. ऑपरेटर ओवरलोडिंग (Operator Overloading):

ऑपरेटर ओवरलोडिंग के माध्यम से, आप C++ के मौजूदा ऑपरेटरों को ओवरलोड कर सकते हैं ताकि वे यूज़र-डिफाइन्ड डेटा प्रकारों पर काम कर सकें।

उदाहरण:

cpp
Copy code
#include <iostream>
using namespace std;

class Complex {
private:
    float real, imag;

public:
    Complex(float r = 0, float i = 0) : real(r), imag(i) {}

    Complex operator + (const Complex &obj) {
        Complex temp;
        temp.real = real + obj.real;
        temp.imag = imag + obj.imag;
        return temp;
    }

    void display() {
        cout << real << " + i" << imag << endl;
    }
};

int main() {
    Complex c1(3.3, 4.4), c2(1.1, 2.2);
    Complex c3 = c1 + c2;

    c3.display();  // 4.4 + i6.6

    return 0;
}

रन-टाइम पोलिमॉर्फिज़्म (Run-Time Polymorphism)

रन-टाइम पोलिमॉर्फिज़्म, जिसे डायनामिक पोलिमॉर्फिज़्म (Dynamic Polymorphism) भी कहा जाता है, तब होता है जब फंक्शन कॉल का चयन रनटाइम के दौरान किया जाता है। इसे वर्चुअल फंक्शन्स और पॉइंटर्स या रिफरेंस के माध्यम से प्राप्त किया जा सकता है।

वर्चुअल फंक्शन्स (Virtual Functions):

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

उदाहरण:

cpp
Copy code
#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base class show function" << endl;
    }
    void display() {
        cout << "Base class display function" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {  // ओवरराइड किया गया वर्चुअल फंक्शन
        cout << "Derived class show function" << endl;
    }
    void display() {  // ओवरराइड किया गया नॉन-वर्चुअल फंक्शन
        cout << "Derived class display function" << endl;
    }
};

int main() {
    Base *bptr;
    Derived d;
    bptr = &d;

    bptr->show();    // Derived class का show() फंक्शन कॉल होता है
    bptr->display(); // Base class का display() फंक्शन कॉल होता है

    return 0;
}

इस उदाहरण में, bptr->show() के माध्यम से वर्चुअल फंक्शन को कॉल करने पर Derived क्लास का show() फंक्शन कॉल होता है, जबकि bptr->display() के माध्यम से Base क्लास का display() फंक्शन कॉल होता है।

पोलिमॉर्फिज़्म के लाभ (Benefits of Polymorphism)

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

एब्स्ट्रैक्शन और एनकैप्सुलेशन (Abstraction and Encapsulation)

एब्स्ट्रैक्शन और एनकैप्सुलेशन ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग (OOP) के दो महत्वपूर्ण सिद्धांत हैं, जो कोड को अधिक संरचित, सुरक्षित और उपयोग में आसान बनाते हैं। इन दोनों अवधारणाओं का उद्देश्य प्रोग्रामिंग में जटिलता को कम करना और डेटा को सुरक्षा प्रदान करना है।

एब्स्ट्रैक्शन (Abstraction)

एब्स्ट्रैक्शन एक ऐसी प्रक्रिया है, जिसमें जटिलता को छिपाकर केवल आवश्यक जानकारी को उजागर किया जाता है। यह सिद्धांत वास्तविक दुनिया की वस्तुओं और उनके व्यवहार को प्रोग्रामिंग में शामिल करता है, लेकिन यह केवल वही जानकारी दिखाता है जो उपयोगकर्ता के लिए महत्वपूर्ण है, जबकि अनावश्यक विवरणों को छिपा दिया जाता है।

एब्स्ट्रैक्शन का मुख्य उद्देश्य यह सुनिश्चित करना है कि उपयोगकर्ता केवल वही जानकारी देखें और उसका उपयोग करें, जिसकी उन्हें आवश्यकता है, जबकि जटिल विवरणों को छिपाकर कोड को सरल और उपयोगकर्ता के अनुकूल बनाया जाता है।

उदाहरण:

मान लीजिए कि आप एक कार चला रहे हैं। जब आप कार चलाते हैं, तो आपको इंजन के अंदर क्या हो रहा है, इसकी जानकारी नहीं होती। आप केवल स्टीयरिंग व्हील, एक्सेलेरेटर, और ब्रेक का उपयोग करते हैं। यहाँ, कार की जटिलता (जैसे इंजन का कार्य) आपके लिए एब्स्ट्रैक्ट (छिपा हुआ) है, और केवल आवश्यक नियंत्रण (जैसे स्टीयरिंग, एक्सेलेरेटर) आपके सामने हैं।

C++ में, एब्स्ट्रैक्शन को प्राप्त करने के लिए क्लास और इंटरफेस का उपयोग किया जाता है, जो उपयोगकर्ता को केवल आवश्यक कार्यक्षमता प्रदान करते हैं, जबकि आंतरिक विवरण छिपे रहते हैं।

कोड उदाहरण:

cpp
Copy code
#include <iostream>
using namespace std;

class Car {
public:
    void start() {
        cout << "Car started" << endl;
    }

    void drive() {
        cout << "Driving the car" << endl;
    }

private:
    void engineIgnition() {
        cout << "Engine ignited" << endl;
    }
};

int main() {
    Car myCar;
    myCar.start();  // उपयोगकर्ता को केवल स्टार्ट और ड्राइव का एक्सेस मिलता है
    myCar.drive();

    // myCar.engineIgnition();  // इस फंक्शन को एक्सेस नहीं कर सकते क्योंकि यह private है

    return 0;
}

इस उदाहरण में, Car क्लास में engineIgnition() फंक्शन private है और उपयोगकर्ता से छिपा हुआ है। उपयोगकर्ता केवल start() और drive() फंक्शन्स को एक्सेस कर सकते हैं।

एनकैप्सुलेशन (Encapsulation)

एनकैप्सुलेशन का अर्थ है डेटा और संबंधित विधियों को एक साथ एक इकाई (क्लास) में बाँधना। एनकैप्सुलेशन का मुख्य उद्देश्य डेटा को बाहरी हस्तक्षेप और गलत उपयोग से सुरक्षित रखना है।

एनकैप्सुलेशन के माध्यम से, आप डेटा को प्राइवेट या प्रोटेक्टेड घोषित कर सकते हैं, जिससे वह केवल क्लास की विधियों के माध्यम से ही एक्सेस किया जा सकता है। इससे डेटा की सुरक्षा बढ़ती है और कोड अधिक संरचित और मॉड्यूलर बनता है।

उदाहरण:

जब आप बैंक में एक खाता खोलते हैं, तो आपकी जानकारी जैसे बैलेंस और पासवर्ड निजी होती है। केवल अधिकृत व्यक्ति (जैसे बैंक अधिकारी) ही आपके खाते की जानकारी एक्सेस कर सकते हैं। इसी तरह, C++ में एनकैप्सुलेशन डेटा को छिपाने और केवल आवश्यक कार्यों के माध्यम से उसे एक्सेस करने की अनुमति देता है।

कोड उदाहरण:

cpp
Copy code
#include <iostream>
using namespace std;

class BankAccount {
private:
    double balance;

public:
    BankAccount() : balance(0.0) {}

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            cout << "Deposited: $" << amount << endl;
        }
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            cout << "Withdrew: $" << amount << endl;
        } else {
            cout << "Insufficient balance" << endl;
        }
    }

    void showBalance() {
        cout << "Balance: $" << balance << endl;
    }
};

int main() {
    BankAccount myAccount;
    myAccount.deposit(1000);
    myAccount.withdraw(500);
    myAccount.showBalance();

    // myAccount.balance = 100000;  // इस लाइन से एरर होगा क्योंकि balance private है

    return 0;
}

इस उदाहरण में, balance डेटा मेंबर private है और इसे सीधे एक्सेस नहीं किया जा सकता। इसे केवल deposit(), withdraw(), और showBalance() विधियों के माध्यम से ही एक्सेस किया जा सकता है, जो कि एनकैप्सुलेशन का एक उदाहरण है।

एब्स्ट्रैक्शन और एनकैप्सुलेशन के लाभ (Benefits of Abstraction and Encapsulation)

  • डेटा सुरक्षा: एनकैप्सुलेशन के माध्यम से डेटा को बाहरी हस्तक्षेप और गलत उपयोग से सुरक्षित रखा जाता है।
  • सरलता: एब्स्ट्रैक्शन के माध्यम से उपयोगकर्ताओं को केवल आवश्यक कार्यक्षमता प्रदान की जाती है, जिससे जटिलता को छिपाया जा सकता है और कोड को सरल बनाया जा सकता है।
  • कोड का पुन: उपयोग: एनकैप्सुलेशन के माध्यम से क्लास में डेटा और विधियों को एक साथ रखा जाता है, जिससे कोड को पुन: उपयोग करना और बनाए रखना आसान हो जाता है।

मॉड्यूलरिटी: एब्स्ट्रैक्शन और एनकैप्सुलेशन दोनों ही कोड को मॉड्यूलर बनाते हैं, जिससे बड़े प्रोजेक्ट्स को संभालना आसान हो जाता है।

यह भी जानें

c plus plus tutorial in hindi Good Vibes Only

अध्याय 8: C++ में स्ट्रिंग्स (Strings in C++)

c plus plus tutorial in hindi Good Vibes Only

अध्याय 9: C++ में पॉइंटर्स (Pointers in C++)

c plus plus tutorial in hindi Good Vibes Only

अध्याय 12: C++ में फाइल हैंडलिंग (File Handling in C++)

c plus plus tutorial in hindi Good Vibes Only

अध्याय 5: C++ लूप्स (C++ Loops)



Table of Contents

→ Index