C++ में डिज़ाइन पैटर्न: उदाहरणों के साथ पूर्ण गाइड

C++ में डिज़ाइन पैटर्न का परिचय

डिज़ाइन पैटर्न (design patterns) सामान्य विकास कार्यों के लिए समय-परीक्षित आर्किटेक्चरल समाधान हैं। C++ की दुनिया में ये विशेष रूप से महत्वपूर्ण हैं, क्योंकि ये लचीला, विस्तार योग्य और रखरखाव योग्य कोड बनाने में मदद करते हैं। इस लेख में हम चार मौलिक पैटर्न को समझेंगे: Singleton, Factory Method, Observer और Strategy — आधुनिक C++ (C++17/20) पर पूर्ण उदाहरणों के साथ।

प्रत्येक पैटर्न के साथ एक व्यावहारिक उदाहरण, क्लास आरेख और उपयोग के लिए स्पष्टीकरण दिया जाएगा। यह सामग्री उन डेवलपर्स के लिए है जो पहले से C++ और OOP की मूल बातों से परिचित हैं।

1. क्रिएशनल पैटर्न Singleton (एकल)

Singleton यह सुनिश्चित करता है कि क्लास का केवल एक इंस्टेंस हो, और उस तक वैश्विक पहुंच प्रदान करता है। C++ में क्लासिकल कार्यान्वयन स्टैटिक मेथड और प्राइवेट कंस्ट्रक्टर का उपयोग करता है।

कब उपयोग करें

• डेटाबेस कनेक्शन प्रबंधन
• लॉगिंग सिस्टम
• कैश-मैनेजर
• एप्लिकेशन कॉन्फ़िगरेशन

कार्यान्वयन उदाहरण (थ्रेड-सेफ Singleton)

#include <iostream>#include <mutex>#include <memory>

class Logger {private:    static std::unique_ptr<Logger> instance;    static std::mutex mtx;        Logger() {        std::cout << "Logger बनाया गया" << std::endl;    }    public:    Logger(const Logger&) = delete;    Logger& operator=(const Logger&) = delete;        static Logger* getInstance() {        std::lock_guard<std::mutex> lock(mtx);        if (!instance) {            instance.reset(new Logger());        }        return instance.get();    }        void log(const std::string& msg) {        std::cout << "[LOG] " << msg << std::endl;    }};

std::unique_ptr<Logger> Logger::instance = nullptr;std::mutex Logger::mtx;

int main() {    Logger* log1 = Logger::getInstance();    Logger* log2 = Logger::getInstance();        log1->log("परीक्षण संदेश");        // log1 और log2 एक ही ऑब्जेक्ट को इंगित करते हैं    std::cout << "log1 == log2: " << (log1 == log2) << std::endl;    return 0;}

आधुनिक C++ दृष्टिकोण (Meyers' Singleton)

class ConfigManager {public:    static ConfigManager& getInstance() {        static ConfigManager instance;  // C++11+ में थ्रेड-सेफ        return instance;    }        void setParam(const std::string& key, const std::string& value) {        params[key] = value;    }        std::string getParam(const std::string& key) {        return params[key];    }    private:    ConfigManager() = default;    std::map<std::string, std::string> params;};

2. क्रिएशनल पैटर्न Factory Method (फैक्टरी विधि)

Factory Method ऑब्जेक्ट बनाने के लिए एक इंटरफ़ेस परिभाषित करता है, लेकिन उपवर्गों को बनाए जाने वाले ऑब्जेक्ट के विशिष्ट क्लास को चुनने की अनुमति देता है। यह पैटर्न विशेष रूप से तब उपयोगी होता है जब ऑब्जेक्ट का प्रकार पहले से ज्ञात न हो।

पैटर्न की संरचना

• Product — उत्पाद का अमूर्त क्लास
• ConcreteProduct — उत्पाद का ठोस कार्यान्वयन
• Creator — फैक्टरी विधि वाला अमूर्त क्रिएटर क्लास
• ConcreteCreator — फैक्टरी विधि को ओवरराइड करता है

उदाहरण: सूचना प्रणाली

#include <iostream>#include <memory>#include <string>

// अमूर्त उत्पादclass Notification {public:    virtual void send(const std::string& message) = 0;    virtual ~Notification() = default;};

// ठोस उत्पादclass EmailNotification : public Notification {public:    void send(const std::str
```