रनटाइम पर टेम्पलेट प्रकार प्राप्त करना

Question

मुझे निम्न विधि मिली है जो सी-स्टाइल structs का वेक्टर प्राप्त करती है और एक समय में अपने तत्वों को संसाधित करती है।

मैं इसे अपने कोड को डुप्लिकेट किए बिना अधिक प्रकार की संरचना प्राप्त करने के लिए विस्तारित करना चाहता हूं।

चूंकि सभी प्रकार के structs में समान फ़ील्ड नाम होंगे, यह टेम्पलेट का उपयोग करके इस नई आवश्यकता को लागू करने के लिए सबसे अधिक सुरुचिपूर्ण होगा।

हालांकि, मैं यह तय नहीं कर सकता कि write_db फ़ंक्शन पर दूसरा तर्क कैसे पारित किया जाए; वह तर्क जो प्रति संरचना प्रकार — पर एक enum है रनटाइम पर इसे प्राप्त करने के लिए कोई विकल्प है?

enum policy_types { 
    POLICY_TYPE_A, 
    POLICY_TYPE_B, 
    ... 
}; 

// old implementation - suitable for single struct only 
int policyMgr::write_rule(std::vector <struct policy_type_a> & list) { 
    //conduct boring pre-write check 
    //... 

    for (auto & item : list) { 
     int ret = write_db(item.key1, POLICY_TYPE_A_ENUM, &item.blob); 
} 

//new implementation - suitable for multiple structs. 
template <POLICY> 
int policyMgr::write_rule(std::vector <POLICY> & list) { 
    for (auto & item : list) { 
     int ret = write_db(item.key1, type(POLICY) /* how can i get enum according to template type */, &item.blob); 
} 

मैं struct के प्रत्येक उदाहरण के लिए के रूप में निरंतर enum मूल्य जोड़ने के बारे में सोचा, लेकिन मैं एक बेहतर दृष्टिकोण है कि मेरी बुनियादी struct प्रारूप में बदलाव की आवश्यकता नहीं होगी की आशा है।

Answer 1

यदि आप कोई सदस्य नहीं जोड़ना चाहते हैं, तो आप "लक्षण" प्रकार प्रदान कर सकते हैं।

template<typename P> 
struct PolicyTraits {}; 

template<> 
struct PolicyTraits<policy_type_a> 
{ 
    static enum { Type = POLICY_TYPE_A }; 
}; 

template<> 
struct PolicyTraits<policy_type_b> 
{ 
    static enum { Type = POLICY_TYPE_B }; 
}; 

template <typename A> 
int policyMgr::write_rule(const std::vector<A> & list) { 
    for (const auto & item : list) { 
     int ret = write_db(item.key1, PolicyTraits<A>::Type, &item.blob); 
    } 
} 

Answer 2

हर वर्ग कि है POLICY सुलभ पर एक प्रकार क्षेत्र है (तुम मेरे अर्थ मिलता है), जिनमें से foo एक उदाहरण है:

struct foo 
{ 
    /*your other bits*/ 
    static const policy_types type = POLICY_TYPE_whatever; /*older standards 
            might require definition in a source file */. 
}; 

फिर write_db(item.key1, POLICY::type) के रूप में उपयुक्त का उपयोग करें।