C++ में SOLID सिद्धांत: स्वच्छ कोड के लिए सिद्धांत और व्यवहार

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

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

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

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

खराब उदाहरण (SRP का उल्लंघन):

class Report {public:    void generateReport() { /* रिपोर्ट जनरेट करना */ }    void saveToFile(const std::string& filename) { /* फ़ाइल में सहेजना */ }    void printReport() { /* रिपोर्ट प्रिंट करना */ }};

यहाँ Report वर्ग जनरेशन, सेविंग और प्रिंटिंग — तीन अलग-अलग जिम्मेदारियों के लिए जिम्मेदार है।

अच्छा उदाहरण (SRP का पालन):

class Report {public:    std::string generate() { /* रिपोर्ट जनरेट करना */ return "report data"; }};

class ReportSaver {public:    void save(const std::string& data, const std::string& filename) {        // फ़ाइल में सहेजना    }};

class ReportPrinter {public:    void print(const std::string& data) {        // रिपोर्ट प्रिंट करना    }};

अब प्रत्येक वर्ग की एक स्पष्ट जिम्मेदारी है, जो परीक्षण और संशोधन को सरल बनाती है।

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

सार: वर्ग विस्तार के लिए खुले होने चाहिए, लेकिन संशोधन के लिए बंद होने चाहिए। आपको मौजूदा कोड को बदले बिना नई कार्यक्षमता जोड़ने में सक्षम होना चाहिए।

खराब उदाहरण:

enum class ShapeType { Circle, Rectangle };

class Shape {public:    ShapeType type;};

class AreaCalculator {public:    double calculateArea(const Shape& shape) {        if (shape.type == ShapeType::Circle) {            // वृत्त का क्षेत्रफल गणना            return 3.14 * radius * radius;        } else if (shape.type == ShapeType::Rectangle) {            // आयत का क्षेत्रफल गणना            return width * height;        }        return 0.0;    }};

नई आकृति (जैसे त्रिभुज) जोड़ने पर AreaCalculator को बदलना होगा।

अच्छा उदाहरण (पॉलीमॉर्फिज़्म के माध्यम से):

class Shape {public:    virtual double area() const = 0;    virtual ~Shape() = default;};

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

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 AreaCalculator {public:    double calculateArea(const Shape& shape) {        return shape.area();    }};

अब नई आकृति जोड़ने के लिए, AreaCalculator को छुए बिना बस एक नया व्युत्पन्न वर्ग बनाना पर्याप्त है।

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

सार: उपवर्गों की वस्तुएँ बेस क्लास की वस्तुओं के साथ प्रोग्राम की शुद्धता को भंग किए बिना विनिमेय होनी चाहिए।

शास्त्रीय उल्लंघन (आयत-वर्ग):

class Rectangle {protected:    int width, height;public:    void setWidth(int w) { width = w; }    void setHeight(int h) { height = h; }    int area() const { return width * height; }};

class Square : public Rectangle {public:    void setWidth(int w) override {        width = w;        height