क्लास नाम स्ट्रिंग्स से लचीला ऑब्जेक्ट इंस्टेंटिएशन

परिचय

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, इंस्टेंटियेट करना आम बात है विशिष्ट वर्गों से वस्तुएँ। हालाँकि, कुछ परिदृश्यों में, स्ट्रिंग के रूप में संग्रहीत वर्ग नामों के आधार पर गतिशील रूप से ऑब्जेक्ट बनाना फायदेमंद हो सकता है। यह बढ़ी हुई लचीलापन और कोड रखरखाव प्रदान कर सकता है। यह आलेख C में इस गतिशील ऑब्जेक्ट निर्माण को प्राप्त करने की संभावनाओं की खोज करता है। वर्ग नाम रखने वाली स्ट्रिंग को वास्तविक प्रकार की जानकारी में परिवर्तित करने के लिए प्रत्यक्ष तंत्र। इसका मतलब यह है कि स्थिर रूप से परिभाषित वर्गों को स्पष्ट कोड परिवर्तनों के बिना गतिशील रूप से त्वरित नहीं किया जा सकता है।

वैकल्पिक दृष्टिकोण

हालांकि प्रत्यक्ष स्ट्रिंग-टू-टाइप रूपांतरण उपलब्ध नहीं है, गतिशील वस्तु निर्माण प्राप्त करने के लिए वैकल्पिक तकनीकें:

1. मैपिंग संरचना का उपयोग करना:

आप क्लास नामों (स्ट्रिंग्स के रूप में) और फ़ंक्शन पॉइंटर्स के बीच मैपिंग बना सकते हैं जो उन कक्षाओं के उदाहरण बनाते हैं। यह फ़ंक्शन पॉइंटर को देखकर और उसे कॉल करके गतिशील ऑब्जेक्ट निर्माण की अनुमति देता है।

template Base* createInstance() { return new T; } std::map<:string base> नक्शा; मानचित्र["व्युत्पन्नए"] = &createInstance; // ...और इसी तरह

template  Base* createInstance() { return new T; }

std::map<:string base> map;
map["DerivedA"] = &createInstance;  // ... and so on

#define REGISTER_DEC_TYPE(NAME) \ स्टेटिक DerivedRegister के संबंध में #रजिस्टर_डीईएफ_प्रकार(नाम) को परिभाषित करें \ व्युत्पन्नरजिस्टर नाम::reg(#NAME) वर्ग व्युत्पन्नबी { ...; REGISTER_DEF_TYPE(व्युत्पन्नबी); };

#define REGISTER_DEC_TYPE(NAME) \
    static DerivedRegister reg

#define REGISTER_DEF_TYPE(NAME) \
    DerivedRegister NAME::reg(#NAME)

class DerivedB {
    ...;
    REGISTER_DEF_TYPE(DerivedB);
};

typedef boost::variantvariant_type; टेम्प्लेट वेरिएंट_टाइप क्रिएटइंस्टेंस() { रिटर्न वेरिएंट_टाइप(टी()); }

typedef boost::variant variant_type;
template  variant_type createInstance() { return variant_type(T()); }