सी ++: क्या स्थैतिक सरणी इनलाइन को परिभाषित करने का कोई तरीका है?

Question

मैं एक साधारण टेम्पलेट फ़ंक्शन को परिभाषित करना चाहता हूं जो रनटाइम मान लेता है और यह निर्धारित करता है कि यह संभावित मानों के कुछ सेट का सदस्य है या नहीं।

उपयोग:

int x; // <- pretend this came from elsewhere... 
if (isoneof(x, {5,3,9,25}) ... 

कुछ की तरह:

template <typename T, size_t size> 
bool isoneof(T value, T (&arr)[size]) 
{ 
    for (size_t i = 0; i < size; ++i) 
     if (value == arr[i]) 
      return true; 
    return false; 
} 

मुझे लगता है कि इस विफलता के लिए अभिशप्त है, जैसा कि मैंने नहीं दिख रहा है कि कैसे एक एक स्थिर सरणी इनलाइन बना सकते हैं।

मैं उपयोग कर सकते हैं:

int kPossibilities[] = {5,3,9,25}; 
if (isoneodf(6, kPossibilities)) ... 

isoneof करने के लिए एक मामूली परिवर्तन के साथ:

template <typename T1, typename T2, size_t size> 
bool isoneof(T1 value, const T2 (&arr)[size]) 
{ 
    for (size_t i = 0; i < size; ++i) 
     if (value == arr[i]) 
      return true; 
    return false; 
} 

कौन सा भी यह एक बालक और अधिक लचीला बनाता है।

क्या किसी के पास प्रस्ताव करने में कोई सुधार है? "स्थिर मूल्य इनलाइन सेट" को परिभाषित करने का एक बेहतर तरीका?

Answer 1

यदि आपको ऐसी चीजें पसंद हैं, तो आप Boost.Assign का बहुत खुश उपयोगकर्ता होंगे।

Boost.Assign वास्तव में साबित होता है कि इस तरह के अर्थ विज्ञान संभव है, तथापि एक असाइन आप को समझाने होगा के स्रोत पर नज़र है कि आप अपने आप को कि :) द्वारा

आप में सक्षम हो जाएगा करने के लिए नहीं करना चाहते हैं इस तथापि की तरह कुछ बनाने के लिए:

if (isoneof(x, list_of(2)(3)(5)(7)(11)) { ... 

... नकारात्मक पक्ष यह जा रहा है आप एक अंतर्निहित सरणी (धन्यवाद, मैनुअल) के बजाय पैरामीटर के रूप में boost::array उपयोग करने के लिए चाहते हैं - यह है कि एक अच्छा पल के लिए है वास्तव में उनका उपयोग करना शुरू करें:>

Answer 2

यह एक?

int ints[] = {2,3,5,7,11}; 
#define ARRAY_SIZE(Array) (sizeof(Array)/sizeof((Array)[0])) 
#define INLIST(x,array) isoneof(x,array,ARRAY_SIZE(array)) 

अलावा:

template <typename T> 
bool isoneof(const T& x, T *array, int n) 
{ 
     for(int i=0; i<n; ++i) 
       if(x==array[i]) 
         return true; 
     return false; 
} 

Answer 3

यह अगले सी ++ मानक में संभव है।

तब तक, आप इसके आसपास काम कर सकते हैं उदा। एक स्थिर वस्तु के लिए operator, ओवरलोडिंग जो स्थिर सरणी शुरू करता है।

नोट: यह कार्यान्वयन ओ (एन^2) है और इसे अनुकूलित किया जा सकता है - यह सिर्फ विचार प्राप्त करने के लिए है।

using namespace std; 

template< typename T, size_t N > 
struct CHead { 
    T values[N]; 
    template< typename T > CHead<T,N+1> operator,(T t) { 
     CHead<T,N+1> newhead; 
     copy(values, values+N, newhead.values); 
     newhead.values[N]=t; 
     return newhead; 
    } 
    bool contains(T t) const { 
     return find(values, values+N, t) != values+N; 
    } 
}; 

struct CHeadProto { 
    template< typename T > 
    CHead<T,1> operator,(T t) { 
    CHead<T,1> h = {t}; 
    return h; 
    } 
} head; 



int main() 
{ 
    assert((head, 1,2,3,4).contains(1)); 
    return 0; 
} 

Answer 4

पूर्णता के लिए, मैं बूस्ट.एमपीएल का उपयोग करने वाला एक समाधान पोस्ट करूंगा। निम्नलिखित कार्य करता है, लेकिन मुझे लगता है कि कॉर्नेल का समाधान सबसे अच्छा है।

#include <iostream> 
#include <boost/mpl/for_each.hpp> 
#include <boost/mpl/vector_c.hpp> 

struct Contains 
{ 
    Contains(int value, bool& result) : value(value), result(result) 
    { 
     result = false; 
    } 

    template< typename T > void operator()(T x) 
    { 
     result = result || (x == value); 
    } 

    int value; 
    bool& result; 
}; 


template <class IntList> 
bool isoneof(int val) 
{ 
    namespace mpl = boost::mpl; 
    bool result; 
    mpl::for_each<IntList>(Contains(val, result)); 
    return result; 
} 


int main() 
{ 
    namespace mpl = boost::mpl; 
    std::cout << isoneof< mpl::vector_c<int, 1,2,3,5,7,11> >(4) << "\n"; 
    std::cout << isoneof< mpl::vector_c<int, 1,2,3,5,7,11> >(5) << "\n"; 
} 

आप देख सकते हैं, संकलन समय सरणी इनलाइन isoneof के लिए एक टेम्पलेट तर्क के रूप में पारित कर दिया है।

Answer 5

सी ++ 11 का उपयोग करना, यह इस तरह से लिखा जाएगा:

template <typename T> 
bool isoneof(T value, std::initializer_list<T> arr) 
{ 
    using namespace std; 

    return any_of(begin(arr), end(arr), [&](const T& x) { return x == value; }); 
} 

Answer 6

बस FYI - मैं vararg टेम्पलेट्स और प्रारंभकर्ता सूचियों का उपयोग मेरी विशेष समस्या हल:

template <typename T, typename U> 
bool isoneof(T v, U v1) { return v == v1; } 

template <typename T, typename U, typename... Args> 
bool isoneof(T v, U v1, Args ... others) { return isoneof(v, v1) || isoneof(v, others...); } 

template <typename T, typename U> 
bool isoneof(T value, std::initializer_list<U> values) 
{ 
    for (const auto & e : values) 
     if (value == e) 
      return true; 
    return false; 
}