C++ टेम्पलेट विशेषज्ञता संकलन समय मूल्य

Question

मैं टेम्पलेट मेटा प्रोग्रामिंग में मेरे रास्ते महसूस कर रहा हूँ, धीरे धीरे और मुझे यकीन है कि निम्नलिखित लागू करने के लिए कैसे नहीं कर रहा हूँ के आधार पर:

// hpp file 
enum MyEnum { Alive = 0, Dead }; 
class A { 
    public: 
     template<typename T, typename O, MyEnum ls> 
     static int Register(); 
}; 

// elsewhere in the code... 
A::Register<IType1, Type1, Dead>(); 

संकलन समय मैं क्या पता चल जाएगा पर enum मान तीसरा टेम्पलेट प्रकार है (संकलन-समय invariant), या तो मृत या जीवित। यह रजिस्टर समारोह के लिए दो शरीर को परिभाषित करना संभव तरह कुछ है,:

// desired hpp file 
template<typename T, typename O, Alive> 
int Register(); 

template<typename T, typename O, Dead> 
int Register(); 

// corresponding desired .inc file 
template<typename T, typename O, Alive> 
int Register() { // Alive specific implementation ... } 

template<typename T, typename O, Dead> 
int Register() { // Dead specific implementation ... } 

मैं पर एक नज़र ले लिया है: C++ Template Specialization with Constant Value

लेकिन मैं यह पता लगाने की कैसे इसे लागू करने के लिए करने में सक्षम नहीं किया गया है यह स्थिति।

Answer 1

टेम्पलेट फ़ंक्शंस आंशिक रूप से विशिष्ट नहीं हो सकते हैं। यहां पार्टी के लिए बहुत देर हो चुकी

template<typename T, typename O, MyEnum ls> 
struct foo; 

template<typename T, typename O> 
struct foo <T, O, Alive> { 
    static int Register() { 
    // ... 
    } 
}; 

template<typename T, typename O> 
struct foo <T, O, Dead> { 
    static int Register() { 
    // ... 
    } 
}; 

template<typename T, typename O, MyEnum ls> 
int Register() { 
    return foo<T, O, ls>::Register(); 
} 

Answer 2

, लेकिन: समाधान एक struct में लपेट के लिए है।

यह है कि मुझे लगता है कि ऐसा करने के लिए एक तरह से धारणात्मक सरल और भी आसान हो गया है (एक नाम स्थान के अंदर यह साफ रखने के लिए) को पढ़ने के लिए बस अपने enum अलग प्रकार के विभिन्न मान कर रहा है, और (टेम्पलेट का लाभ लेने) समारोह से अधिक भार:

namespace State { 
    struct Dead {}; 
    struct Alive {}; 
} 

template<typename T, typename O> 
int Register(State::Dead) { 
    return 1; 
} 

template<typename T, typename O> 
int Register(State::Alive) { 
    return 2; 
} 

आप उन्हें इस तरह कहते हैं:

int main() { 
    Register<int,int>(State::Dead()); 
    Register<int,int>(State::Alive()); 
    return 0; 
}