इनहेरिटेंस
C++ में इनहेरिटेंस (Inheritance) ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग का एक महत्वपूर्ण तत्व है, जो एक क्लास (Derived Class) को दूसरी क्लास (Base Class) की प्रॉपर्टीज़ और मेथड्स अपनाने की अनुमति देता है। इनहेरिटेंस कोड को पुन: उपयोग योग्य, मॉड्यूलर और मेंटेन करने योग्य बनाने में मदद करता है और सॉफ्टवेयर आर्किटेक्चर में हायरार्किकल रिलेशनशिप को प्रभावी ढंग से मैनेज करता है। उदाहरण के लिए, यदि आपके पास वाहन और उसके प्रकार जैसे कार और बाइक हैं, तो आप इनहेरिटेंस का उपयोग करके साझा विशेषताओं को बेस क्लास में रख सकते हैं और विशिष्ट विवरण डेरिव्ड क्लास में जोड़ सकते हैं।
C++ में इनहेरिटेंस तब उपयोगी होता है जब विभिन्न क्लासों में समानताएं होती हैं या जब पॉलिमॉर्फ़िज़्म (Polymorphism) की आवश्यकता होती है। यह सुसंगत डेटा स्ट्रक्चर और एल्गोरिदम के साथ मिलकर अधिक जटिल सिस्टम के निर्माण में मदद करता है। इनहेरिटेंस सार्वजनिक (public), संरक्षित (protected), या निजी (private) रूप में घोषित किया जा सकता है, जो बेस क्लास के मेंबर्स की दृश्यता को नियंत्रित करता है। इस ट्यूटोरियल में आप सीखेंगे कि कैसे बेस क्लास और डेरिव्ड क्लास बनाते हैं, कंस्ट्रक्टर और डिस्ट्रक्टर का क्रम संभालते हैं, वर्चुअल फंक्शन्स और पॉलिमॉर्फ़िज़्म का उपयोग करते हैं और इनहेरिटेंस मॉडल को वास्तविक दुनिया के प्रोजेक्ट्स में लागू करते हैं।
मूल उदाहरण
text\#include <iostream>
\#include <string>
class Vehicle {
protected:
std::string brand;
int year;
public:
Vehicle(const std::string& b, int y) : brand(b), year(y) {}
virtual void display() const {
std::cout << "Brand: " << brand << ", Year: " << year << std::endl;
}
virtual \~Vehicle() {}
};
class Car : public Vehicle {
private:
int doors;
public:
Car(const std::string& b, int y, int d) : Vehicle(b, y), doors(d) {}
void display() const override {
std::cout << "Brand: " << brand << ", Year: " << year << ", Doors: " << doors << std::endl;
}
};
int main() {
Vehicle v("Generic Vehicle", 2020);
Car c("Toyota", 2023, 4);
v.display();
c.display();
Vehicle* ptr = &c;
ptr->display(); // Polymorphism demonstration
return 0;
}इस उदाहरण में Vehicle बेस क्लास है जिसमें brand और year मेंबर्स हैं और एक वर्चुअल फंक्शन display है। protected मेंबर्स डेरिव्ड क्लास द्वारा एक्सेस किए जा सकते हैं। Car क्लास Vehicle से public इनहेरिटेंस का उपयोग करके डेरिव्ड की गई है। Car का कंस्ट्रक्टर बेस क्लास के कंस्ट्रक्टर को कॉल करता है। display फंक्शन को override करके पॉलिमॉर्फ़िज़्म दिखाया गया है, जिससे Vehicle पॉइंटर के माध्यम से सही मेथड रन होती है। virtual डिस्ट्रक्टर के कारण मेमोरी लीक्स नहीं होती। main में ऑब्जेक्ट्स को इनिशियलाइज किया गया है और पॉलिमॉर्फ़िज़्म का डेमो दिया गया है।
व्यावहारिक उदाहरण
text\#include <iostream>
\#include <vector>
\#include <memory>
class Employee {
protected:
std::string name;
double salary;
public:
Employee(const std::string& n, double s) : name(n), salary(s) {}
virtual void display() const {
std::cout << "Employee: " << name << ", Salary: " << salary << std::endl;
}
virtual double calculateBonus() const = 0; // Pure virtual function
virtual \~Employee() {}
};
class Manager : public Employee {
private:
int teamSize;
public:
Manager(const std::string& n, double s, int t) : Employee(n, s), teamSize(t) {}
void display() const override {
std::cout << "Manager: " << name << ", Salary: " << salary << ", Team Size: " << teamSize << std::endl;
}
double calculateBonus() const override {
return salary * 0.1 + teamSize * 100;
}
};
class Developer : public Employee {
private:
std::string language;
public:
Developer(const std::string& n, double s, const std::string& l) : Employee(n, s), language(l) {}
void display() const override {
std::cout << "Developer: " << name << ", Salary: " << salary << ", Language: " << language << std::endl;
}
double calculateBonus() const override {
return salary * 0.15;
}
};
int main() {
std::vector\<std::unique_ptr<Employee>> team;
team.push_back(std::make_unique<Manager>("Alice", 90000, 5));
team.push_back(std::make_unique<Developer>("Bob", 80000, "C++"));
for (const auto& e : team) {
e->display();
std::cout << "Bonus: $" << e->calculateBonus() << std::endl;
}
return 0;
}इस उदाहरण में Employee एक abstract बेस क्लास है जिसमें pure virtual function calculateBonus है। Manager और Developer डेरिव्ड क्लासेस हैं जो display और calculateBonus को override करती हैं। std::unique_ptr का उपयोग मेमोरी सुरक्षित बनाने के लिए किया गया है। std::vector
C++ इनहेरिटेंस के लिए best practices में वर्चुअल डिस्ट्रक्टर का उपयोग, "is-a" रिलेशनशिप के लिए public इनहेरिटेंस, और कंस्ट्रक्टर में इनिशियलाइजेशन लिस्ट शामिल हैं। Object slicing से बचें और override का उपयोग वर्चुअल फंक्शन्स में करें। गहरी हायरार्की से बचें और कम्पोज़िशन का विचार करें। Performance के लिए STL containers और algorithms का उपयोग करें। Debugging के लिए vtable और Valgrind जैसे टूल्स मददगार हैं। सुरक्षा के लिए प्रोटेक्टेड/प्राइवेट मेंबर्स का ध्यान रखें और dangling pointers से बचें।
📊 संदर्भ तालिका
| C++ Element/Concept | Description | Usage Example |
|---|---|---|
| Base Class | डेरिव्ड क्लास के लिए मूल क्लास | class Vehicle { /* members */ }; |
| Derived Class | Base Class से विरासत में प्राप्त | class Car : public Vehicle { /* members */ }; |
| Virtual Function | डेरिव्ड क्लास में override की जा सकती है | virtual void display() const; |
| Pure Virtual Function | डेरिव्ड क्लास में implement करना अनिवार्य | virtual double calculateBonus() const = 0; |
| Polymorphism | रनटाइम पर सही फंक्शन कॉल | Vehicle* ptr = \&c; ptr->display(); |
| Initialization List | डेरिव्ड ऑब्जेक्ट के लिए efficient construction | Car(const std::string& b,int y,int d): Vehicle(b,y), doors(d){} |
इनहेरिटेंस C++ में रिलेशनशिप मॉडलिंग, कोड पुन: उपयोग, और पॉलिमॉर्फ़िज़्म को लागू करने का एक शक्तिशाली तरीका है। इसका ज्ञान आपको maintainable और extensible सिस्टम बनाने, hierarchical डेटा स्ट्रक्चर पर एल्गोरिद्म लागू करने और advanced OOP principles का सही उपयोग करने में सक्षम बनाता है। अगले कदम में multiple inheritance, abstract classes, और design patterns जैसे Factory या Strategy सीखना शामिल है। STL और polymorphic objects के साथ प्रैक्टिकल अनुभव advanced C++ कौशल को मजबूत करता है।
🧠 अपने ज्ञान की परीक्षा करें
Test Your Knowledge
Test your understanding of this topic with practical questions.
📝 निर्देश
- हर प्रश्न को ध्यान से पढ़ें
- हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
- आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
- आपकी प्रगति शीर्ष पर दिखाई जाएगी