सीआरटीपी - आधार वर्ग से जांच कर रहा है कि व्युत्पन्न व्यक्ति

Question

उत्सुकता से आवर्ती टेम्पलेट पैटर्न का उपयोग एक प्रकार के स्थैतिक बहुरूपता को लागू करने के लिए किया जा सकता है। उदाहरण के लिए:

#include <iostream> 

template< 
class Derived 
> 
struct Base 
{ 
    static void print () 
    { 
     std::cout << Derived::number_to_print << '\n'; 
    } 
}; 

struct Derived final : 
    Base< 
    Derived 
    > 
{ 
    static constexpr unsigned int number_to_print = 27; 
}; 

int main () 
{ 
    Derived::print(); 
} 

इस रूप में की उम्मीद और प्रिंट 27 व्यवहार करता है।

अब, मैं आधार वर्ग के लिए जाँच करता है जोड़ने के लिए जोर देने के लिए है कि व्युत्पन्न वर्ग कुछ आवश्यकताओं को पूरा करना चाहते हैं। ऊपर दिए गए उदाहरण में, इस तरह की जांच हो सकता है:

#include <iostream> 
#include <type_traits> 

template< 
class Derived 
> 
struct Base 
{ 
    // --- Checks begin 
    static_assert(std::is_same< 
     decltype(Derived::number_to_print), 
     unsigned int 
     >::value, 
     "static member `number_to_print' should be of type `unsigned int'"); 
    // --- Checks end 

    static void print () 
    { 
     std::cout << Derived::number_to_print << '\n'; 
    } 
}; 

struct Derived final : 
    Base< 
    Derived 
    > 
{ 
    static constexpr unsigned int number_to_print = 27; 
}; 

int main () 
{ 
    Derived::print(); 
} 

इस बिंदु जहां Base<Derived> instantiated है क्योंकि काम नहीं करता,, Derived केवल आगे की घोषित किया गया है, यानी, यह अधूरा है, और यह कुछ भी नहीं की अभी तक इस तथ्य से परे जाना जाता है कि यह एक संरचना है।

मैं अपने सिर खरोंच किया गया है, के रूप में मुझे लगता है कि इन चेकों आधार वर्ग के उपयोगकर्ताओं के लिए मददगार साबित हो सकता है, लेकिन किसी भी तरह से यह करने के लिए नहीं मिला है।

क्या यह संभव है ?, और यदि हां, तो कैसे?

Answer 1

noted by Kerrek SB के रूप में आप एक सदस्य समारोह के मुख्य भाग में स्थिर जोर स्थानांतरित कर सकते हैं।

और जब आप वर्तमान static सदस्य फ़ंक्शंस के बजाय कार्यक्षमता प्रदान करते हैं, तो वर्तमान static सदस्य फ़ंक्शन के बजाय, आप फ़ंक्शन बॉडी को कन्स्ट्रक्टर का बॉडी दे सकते हैं।

उदा।

#include <iostream> 
#include <type_traits> 
using namespace std; 

#define STATIC_ASSERT(e) static_assert(e, #e " // <- is required") 

template< class A, class B > 
constexpr auto is_same_() -> bool { return std::is_same<A, B>::value; } 

template< class Derived > 
struct Base 
{ 
    Base() 
    { 
     STATIC_ASSERT((
      is_same_< remove_cv_t< decltype(Derived::number_to_print) >, int >() 
      )); 
    } 

    void print() const 
    { 
     std::cout << Derived::number_to_print << '\n'; 
    } 
}; 

struct Derived final 
    : Base<Derived> 
{ 
    static constexpr int number_to_print = 27; 
}; 

auto main() 
    -> int 
{ 
    Derived::Base().print(); 
} 

Answer 2

एक गंदा चाल के रूप में, आप एक सदस्य समारोह के मुख्य भाग में स्थिर दावे को स्थानांतरित कर सकते हैं। चूंकि सदस्य फ़ंक्शन परिभाषा कक्षा परिभाषा के बाद तुरंत प्रभावी ढंग से दिखाई देती है, Derived का प्रकार सदस्य फ़ंक्शन बॉडी के अंदर पूरा हो जाता है।

खबरदार वर्ग टेम्पलेट्स के उस सदस्य कार्यों के लिए खुद को समारोह टेम्पलेट्स कर रहे हैं, और इस तरह वे केवल तभी इस्तेमाल किया instantiated कर रहे हैं (या वर्ग टेम्पलेट स्पष्ट रूप से instantiated है)।

Answer 3

एक वैकल्पिक दृष्टिकोण के रूप में, आप एक निजी विधि का उपयोग कर सकते हैं (अन्य उत्तर वास्तव में बहुत अच्छी हैं) और sfinae पर भरोसा करते हैं:

#include <iostream> 
#include <type_traits> 

template<class Derived> 
struct Base { 
    static void print () { 
     print<Derived>(); 
    } 

private: 
    template<class D> 
    static 
    std::enable_if_t<std::is_same<std::remove_cv_t<decltype(D::N)>, unsigned int>::value> 
    print() { 
     std::cout << D::N << '\n'; 
    } 
}; 

struct Derived final: Base<Derived> { 
    static constexpr unsigned int N = 27; 
}; 

int main () { 
    Derived::print(); 
} 

इस तरह त्रुटि केवल उठता है अगर आप वास्तव में print का उपयोग करें।