सरणी के प्रारंभिक निकाय को फ़ंक्शन पैरामीटर (सी-सरणी) के रूप में, क्या यह संभव है?

Question

मैं अगले स्थिति में कुछ मदद की तलाश कर रहा हूँ:
मैं कुछ वर्ग और इसमें कुछ विधि है, वाक्य रचना इस तरह है:

class SomeClass { 
    public: 
      void doSomething(int *a); 
}; 

तो मैं

SomeClass::doSomething({ 0, 1, 2, 3, 4 }); 

की तरह इस विधि कॉल करना चाहते हैं

क्या यह किसी भी भाषा में संभव है? कोई भी (सी ++, सी, ओबीजे-सी, ओबीजे-सी ++) कार्यान्वयन स्वागत है! मुझे पता है कि यह प्रारंभ ब्लॉक

int *a = { 0, 1, 2, 3, 4 }; 
SomeClass::doSomething(a); 

लेकिन इंटरफ़ेस की तरह, सरणी की एक संस्था है बहुत अच्छी लग रही होगी, मुझे लगता है, अगर वहाँ फ़ंक्शन कॉल से पहले कोई अस्थायी चर हो जाएगा (जैसा कि हम जानते हैं की जरूरत नहीं है कक्षा-क्लाइंट में पैरामीटर का प्रकार)। तो, क्या ऐसा करने का कोई मौका है?

Answer 1

यह सी ++ 11 initializer lists (सेक्शन 18.9) के बारे में है।

void foo (std :: initializer_list <int> inputs) { 
    for (auto i : inputs) { 
     // ... 
    } 
} 

foo ({10, 20, 30}); 

केवल संकलक एक प्रारंभकर्ता सूची बना सकते हैं, लेकिन आप begin(), end(), size(), और यादृच्छिक अभिगम iterators के साथ एक मानक एसटीएल शैली कंटेनर जैसे कि यह इलाज कर सकते हैं।

std::vector (और मैं कुछ अन्य कंटेनरों की उम्मीद) अब प्रारंभकर्ता सूचियों के साथ निर्माण किया जा सकता है, तो

std :: vector <std :: string> foo {"a", "b"}; 

std :: vector <std :: string> foo; 
foo .push_back ("a"); 
foo .push_back ("b"); 

छोड़कर

के बराबर है कि यह कम आवंटन प्रदर्शन कर सकते हैं। ध्यान दें कि const char* को स्वचालित रूप से std::string में बदल दिया गया है।

Answer 2

C99 में यह काम करता है:

functionThatTakesIntPtrOrArray((int []){ 1, 2, 3, 4 }); 

..और इसी तरह की बातों structs के साथ किया जा सकता है।

Answer 3

तो initializer_list उपलब्ध नहीं है, और सरणियों ज्यादातर छोटे हैं, वहाँ एक और विकल्प है, एसटीडी के लिए << ऑपरेटर :: इस तरह वेक्टर अधिक भार:

template <typename T> 
inline std::vector<T> operator <<(const std::vector<T>& vec, const T& val) { 
    std::vector<T> result(vec); 
    result.push_back(val); 
    return result; 
} 

कि के साथ, आप ऐसा कर सकते हैं:

void foo (const std::vector<int>& inputs) { 
    // ... 
} 

foo (std::vector<int>() << 10 << 20 << 30); 

सिंगल लाइन प्रारंभिकता की सुविधा और वेक्टर आकार निर्दिष्ट करने के लिए भुगतान करने की कीमत नहीं है। पूर्व वेक्टर की एक प्रति जोड़ी गई है, प्रत्येक तत्व के लिए बनाई गई है, कम से कम वर्ग में वेक्टर आकार में चलने का समय बना रहा है - यही कारण है कि यह छोटे वैक्टरों और मामलों के लिए सबसे उपयुक्त है जब प्रदर्शन कोई फर्क नहीं पड़ता। स्पैफ के जवाब में बताए गए अनुसार, सी ++ 11 के लिए एक बेहतर समाधान है।