मैं पूर्णांक मानों की एक श्रृंखला के लिए सी ++ टेम्पलेट का विशेषज्ञ कैसे बना सकता हूं?

Question

क्या एक के बजाय मूल्यों की एक श्रृंखला के आधार पर टेम्पलेट विशेषज्ञता रखने का कोई तरीका है? मुझे पता है कि निम्न कोड वैध C++ कोड मान्य नहीं है लेकिन यह दिखाता है कि मैं क्या करना चाहता हूं। मैं 8-बिट मशीन के लिए कोड लिख रहा हूं, इसलिए इन्स और वर्णों का उपयोग करने के लिए गति में अंतर है।

template<unsigned SIZE> 
class circular_buffer { 
    unsigned char buffer[SIZE]; 
    unsigned int head; // index 
    unsigned int tail; // index 
}; 

template<unsigned SIZE <= 256> 
class circular_buffer { 
    unsigned char buffer[SIZE]; 
    unsigned char head; // index 
    unsigned char tail; // index 
}; 

Answer 1

std::conditional का प्रयास करें:

#include <type_traits> 

template<unsigned SIZE> 
class circular_buffer { 

    typedef typename 
     std::conditional< SIZE < 256, 
          unsigned char, 
          unsigned int 
         >::type 
     index_type; 

    unsigned char buffer[SIZE]; 
    index_type head; 
    index_type tail; 
}; 

अपने संकलक अभी तक सी ++ 11 के इस हिस्से का समर्थन नहीं करता है, वहाँ में बराबर है boost libraries.

फिर फिर, इसे रोल करना आसान है खुद (क्रेडिट KerrekSB को जाता है):

template <bool, typename T, typename F> 
struct conditional { 
    typedef T type; 
}; 

template <typename T, typename F> // partial specialization on first argument 
struct conditional<false, T, F> { 
    typedef F type; 
}; 

Answer 2

उपयोग एक अतिरिक्त bool पैरामीटर चूक:

// primary template handles false 
template<unsigned SIZE, bool IsSmall = SIZE <= 256> 
class circular_buffer { 
    unsigned char buffer[SIZE]; 
    unsigned int head; // index 
    unsigned int tail; // index 
}; 

// specialization for true 
template<unsigned SIZE> 
class circular_buffer<SIZE, true> { 
    unsigned char buffer[SIZE]; 
    unsigned char head; // index 
    unsigned char tail; // index 
}; 

Answer 3

एक अन्य संभावित विकल्प:

template <unsigned SIZE> 
struct offset_size { 
    typedef typename offset_size<SIZE - 1>::type type; 
}; 

template <> 
struct offset_size<0> { 
    typedef unsigned char type; 
}; 

template <> 
struct offset_size<257> { 
    typedef unsigned int type; 
}; 

template<unsigned SIZE> 
class circular_buffer { 
    unsigned char buffer[SIZE]; 
    typename offset_size<SIZE>::type head; // index 
    typename offset_size<SIZE>::type tail; // index 
}; 

(Ideone example)

Answer 4

मुझे नफरत कैसे गन्दा निपटने प्रकार के साथ हो सकता है इसलिए मैं थोड़ा सरल कुछ प्रस्ताव, लीवरेजिंग constexpr। इस प्रकार व्यवहार भिन्न है जब एक अलग प्रकार की आवश्यकता नहीं है के लिए अनुमति देता है और एक सीमा के भीतर फिट करने के लिए और एक मूल्य के न सिर्फ एक तरफ की जरूरत पते: से प्रेरित होकर

template<bool> struct If; 

constexpr bool InClosedRange(std::size_t Value, std::size_t Lower, std::size_t Upper) 
{ 
    return (Lower <= Value) && (Value <= Upper); 
} 

// Usage: 
template<size_t Width, If<true>> 
class Foo; 

template<size_t Width, If<InClosedRange(Width, 1, 41)>> 
class Foo { /* ... */ }; 

template<size_t Width, If<InClosedRange(Width, 42, 142)>> 
class Foo { /* ... */ }; 

: https://stackoverflow.com/a/9516959/929315