C++ में SOLID सिद्धांत: कोड उदाहरणों के साथ सिद्धांत और व्यवहार

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

Here is the translated HTML content in Hindi, with all HTML tags preserved and only the text content translated. Programming terms, code examples, and proper nouns remain in English. ```html

SOLID सिद्धांत C++ में: सिद्धांत से व्यवहार तक

SOLID सिद्धांत ऑब्जेक्ट-ओरिएंटेड डिज़ाइन के पाँच मूलभूत नियम हैं, जिन्हें रॉबर्ट मार्टिन ने प्रतिपादित किया था। ये लचीला, स्केलेबल और आसानी से रखरखाव योग्य कोड बनाने में मदद करते हैं। इस लेख में, हम प्रत्येक सिद्धांत को C++ उदाहरणों के साथ, सरल सिद्धांत से लेकर वास्तविक व्यावहारिक मामलों तक, समझेंगे।

1. Single Responsibility Principle (SRP) — एकल उत्तरदायित्व का सिद्धांत

सिद्धांत: प्रत्येक वर्ग में बदलाव का केवल एक ही कारण होना चाहिए। दूसरे शब्दों में, वर्ग प्रोग्राम की कार्यक्षमता के केवल एक भाग के लिए उत्तरदायी होता है।

समस्या: अक्सर डेवलपर एक ही वर्ग में डेटा के साथ काम करने, उसे सहेजने और स्क्रीन पर प्रदर्शित करने का तर्क रख देते हैं। यह SRP का उल्लंघन करता है।

C++ में व्यवहार: Report वर्ग को तीन अलग-अलग वर्गों में विभाजित करें।

// बुरा: SRP का उल्लंघन करता हैclass Report {    std::string title;    std::string content;public:    void generate() { /* रिपोर्ट जनरेशन */ }    void saveToFile(const std::string& filename) { /* फ़ाइल में सहेजना */ }    void print() { /* प्रिंटर पर आउटपुट */ }};

// अच्छा: SRP का पालन करता हैclass Report {    std::string title;    std::string content;public:    void generate() { /* केवल जनरेशन */ }};

class ReportSaver {public:    void saveToFile(const Report& report, const std::string& filename) { /* सहेजना */ }};

class ReportPrinter {public:    void print(const Report& report) { /* प्रिंट */ }};

निष्कर्ष: अब प्रत्येक वर्ग अपने कार्य के लिए उत्तरदायी है। कोड का परीक्षण और संशोधन करना आसान हो गया है।

2. Open-Closed Principle (OCP) — खुले/बंद का सिद्धांत

सिद्धांत: सॉफ्टवेयर संस्थाएँ (वर्ग, मॉड्यूल, फ़ंक्शन) विस्तार के लिए खुली होनी चाहिए, लेकिन संशोधन के लिए बंद। अर्थात, हमें मौजूदा कोड को बदले बिना नई कार्यक्षमता जोड़ने में सक्षम होना चाहिए।

C++ में व्यवहार: पॉलीमॉर्फिज़्म और एब्सट्रैक्ट वर्गों का उपयोग करें।

#include <iostream>#include <vector>#include <memory>

// आकृतियों के लिए बेस वर्गclass Shape {public:    virtual double area() const = 0;    virtual ~Shape() = default;};

class Rectangle : public Shape {    double width, height;public:    Rectangle(double w, double h) : width(w), height(h) {}    double area() const override { return width * height; }};

class Circle : public Shape {    double radius;public:    Circle(double r) : radius(r) {}    double area() const override { return 3.14159 * radius * radius; }};

// कुल क्षेत्रफल की गणना के लिए वर्ग — नई आकृतियाँ जोड़ने पर इसमें बदलाव की आवश्यकता नहींclass AreaCalculator {public:    double totalArea(const std::vector<std::unique_ptr<Shape>>& shapes) {        double total = 0;        for (const auto& shape : shapes) {            total += shape->area();        }        return total;    }};

int main() {    std::vector<std::unique_ptr<Shape>> shapes;    shapes.push_back(std::make_unique<Rectangle>(4, 5));    shapes.push_back(std::make_unique<Circle>(3));

    AreaCalculator calc;    std::cout << "Total area: " << calc.totalArea(shapes) << std::endl;    return 0;}

निष्कर्ष: हम AreaCalculator को छुए बिना नई आकृतियाँ (जैसे, Triangle) जोड़ सकते हैं।

3. Liskov Substitution Principle (LSP) — बारबरा लिस्कोव का प्रतिस्थापन सिद्धांत

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

व्यवहार ```