दिलचस्प पोस्ट
वस्तु संपत्ति पर आधारित सरणी तत्व निकालें .resx फ़ाइल में सभी संसाधनों के माध्यम से लूप cudaMemcpy विभाजन त्रुटि javascript regexp सभी विशेष वर्णों को हटा दें क्या सूची बनाई जा सकती है जो स्वयं नाम के आधार पर इनपुट ऑब्जेक्ट नाम है? पृष्ठ के मध्य (क्षैतिज / चौड़ाई) से एक <div> कैसे संरेखित करें PHP: एक सरणी में दो तिथियों के बीच सभी तिथियां लौटें "प्रथम श्रेणी" ऑब्जेक्ट क्या हैं? सी में सर्वोच्च ऑर्डर बिट खोजें एन्क्रिप्ट करना / डिक्रिप्टिंग फाइल मैक्रिप्ट के साथ सी में एक +++++ बी काम क्यों नहीं करता? टैग्स का उपयोग करके फोर्स आईई संगतता मोड बंद करें मैं यूनिक्स कमांड लाइन पर या किसी शेल स्क्रिप्ट में पाठ फ़ाइल की लाइनों को कैसे फेर सकती हूँ? लैम्ब्डा में कैप्चर ले जाएं Regex के साथ बैकस्लैश से बच नहीं सकता है?

सी ++ में क्लास प्रारंभकर्ता में एक कॉन्स्ट ऑरेरेज़ को प्रारंभ करें

मेरे पास सी ++ में निम्न वर्ग है:

class a { const int b[2]; // other stuff follows // and here's the constructor a(void); } 

प्रश्न यह है कि, प्रारंभिक सूची में मैं कैसे बी को इनिशियलाइज़ करूँगा, बशर्ते कि मैं इसे कंस्ट्रक्टर के फ़ंक्शन के शरीर के अंदर आरंभ नहीं कर सकता, क्योंकि ब const ?

यह काम नहीं करता है:

 a::a(void) : b([2,3]) { // other initialization stuff } 

संपादित करें: बिंदु में यह मामला है कि जब मैं अलग-अलग उदाहरणों के लिए b लिए अलग-अलग मान कर सकता हूं, लेकिन मूल्यों को उदाहरण के जीवनकाल के लिए स्थिर रखने के लिए जाना जाता है

वेब के समाधान से एकत्रित समाधान "सी ++ में क्लास प्रारंभकर्ता में एक कॉन्स्ट ऑरेरेज़ को प्रारंभ करें"

दूसरों की तरह, आईएसओ सी ++ का समर्थन नहीं करता है लेकिन आप इसका समाधान कर सकते हैं। बस इसके बजाय std :: vector का उपयोग करें

 int* a = new int[N]; // fill a class C { const std::vector<int> v; public: C():v(a, a+N) {} }; 

सी ++ के साथ इस प्रश्न का उत्तर अब बदल गया है और आप वास्तव में ऐसा कर सकते हैं:

 struct a { const int b[2]; // other bits follow // and here's the constructor a(); }; a::a() : b{2,3} { // other constructor work } int main() { aa; } 

वर्तमान मानक में यह संभव नहीं है। मेरा मानना ​​है कि आप इसे प्रारंभिक सूची के साथ सी ++ 0x में करने में सक्षम होंगे (प्रारंभिक सूची और अन्य अच्छे सी + + 0x सुविधाओं के बारे में अधिक जानकारी के लिए, Bjarne Stroustrup द्वारा C ++ 0x पर एक संक्षिप्त देखें देखें)।

std::vector ढेर का उपयोग करता है गीज़, क्या बर्बादी है जो सिर्फ एक विवेक-जांच के लिए होगी std::vector का बिंदु रन-टाइम पर गतिशील विकास है, न कि कोई भी पुराने सिंटैक्स जांच जो संकलन-समय पर किया जाना चाहिए। यदि आप बढ़ने नहीं जा रहे हैं तो सामान्य श्रेणी को लपेटने के लिए एक क्लास बनाएं।

 #include <stdio.h> template <class Type, size_t MaxLength> class ConstFixedSizeArrayFiller { private: size_t length; public: ConstFixedSizeArrayFiller() : length(0) { } virtual ~ConstFixedSizeArrayFiller() { } virtual void Fill(Type *array) = 0; protected: void add_element(Type *array, const Type & element) { if(length >= MaxLength) { // todo: throw more appropriate out-of-bounds exception throw 0; } array[length] = element; length++; } }; template <class Type, size_t Length> class ConstFixedSizeArray { private: Type array[Length]; public: explicit ConstFixedSizeArray( ConstFixedSizeArrayFiller<Type, Length> & filler ) { filler.Fill(array); } const Type *Array() const { return array; } size_t ArrayLength() const { return Length; } }; class a { private: class b_filler : public ConstFixedSizeArrayFiller<int, 2> { public: virtual ~b_filler() { } virtual void Fill(int *array) { add_element(array, 87); add_element(array, 96); } }; const ConstFixedSizeArray<int, 2> b; public: a(void) : b(b_filler()) { } void print_items() { size_t i; for(i = 0; i < b.ArrayLength(); i++) { printf("%d\n", b.Array()[i]); } } }; int main() { ax; x.print_items(); return 0; } 

ConstFixedSizeArrayFiller और ConstFixedSizeArray पुन: प्रयोज्य हैं

सबसे पहले सरणी को प्रारंभ करते समय रन-टाइम बाउंडिंग की अनुमति देता है (एक वेक्टर की तरह), जो बाद में इस आरंभीकरण के बाद const बन सकता है

दूसरा ऑरेंज को किसी अन्य ऑब्जेक्ट के भीतर आवंटित करने की अनुमति देता है, जो ढेर पर हो सकता है या बस स्टैक अगर वह ऑब्जेक्ट है जहां है। ढेर से आवंटित समय का कोई अपशिष्ट नहीं है। यह सरणी पर कंसीबल-टाइम कंसोल जांच भी करता है।

b_filler प्रारंभिक मूल्य प्रदान करने के लिए एक छोटा निजी वर्ग है। सरणी का आकार टेम्प्लेट तर्क के साथ संकलित समय पर चेक किया जाता है, इसलिए सीमा से बाहर जाने की कोई संभावना नहीं है।

मुझे यकीन है कि इस को संशोधित करने के लिए और अधिक विदेशी तरीके हैं। यह एक शुरुआती शिकारी है मुझे लगता है कि कक्षाओं के साथ आप किसी संकलक की कमी के लिए बहुत ज्यादा मेकअप कर सकते हैं

आईएसओ मानक सी ++ आपको ऐसा करने नहीं देता है। अगर ऐसा होता है, तो वाक्यविन्यास संभवतः होगा:

 a::a(void) : b({2,3}) { // other initialization stuff } 

या उनके जैसे की कुछ और। आपके प्रश्न से यह वास्तव में लगता है कि आप क्या चाहते हैं एक स्थिर वर्ग (उर्फ स्थिर) सदस्य जो सरणी है C ++ आपको यह करने देता है। इस तरह:

 #include <iostream> class A { public: A(); static const int a[2]; }; const int A::a[2] = {0, 1}; A::A() { } int main (int argc, char * const argv[]) { std::cout << "A::a => " << A::a[0] << ", " << A::a[1] << "\n"; return 0; } 

उत्पादन किया जा रहा है:

 A::a => 0, 1 

अब निश्चित रूप से यह एक स्थैतिक वर्ग सदस्य है क्योंकि यह कक्षा ए के प्रत्येक उदाहरण के लिए एक जैसा है। अगर वह ऐसा नहीं है जो आप चाहते हैं, अर्थात आप चाहते हैं कि ए के प्रत्येक इंस्टेंस को अरै में अलग तत्व मान मिलें, तब आप कर रहे हैं सरणी के साथ शुरू करने के लिए const बनाने की कोशिश की गलती। आपको यह करना चाहिए:

 #include <iostream> class A { public: A(); int a[2]; }; A::A() { a[0] = 9; // or some calculation a[1] = 10; // or some calculation } int main (int argc, char * const argv[]) { A v; std::cout << "va => " << va[0] << ", " << va[1] << "\n"; return 0; } 

जहां मेरे पास एक स्थिर सरणी है, यह हमेशा स्थिर रूप में किया जाता है यदि आप यह स्वीकार कर सकते हैं, तो यह कोड संकलित और चलाना चाहिए।

 #include <stdio.h> #include <stdlib.h> class a { static const int b[2]; public: a(void) { for(int i = 0; i < 2; i++) { printf("b[%d] = [%d]\n", i, b[i]); } } }; const int a::b[2] = { 4, 2 }; int main(int argc, char **argv) { a foo; return 0; } 

आप प्रारंभिक सूची से ऐसा नहीं कर सकते हैं,

कृपया एक नज़र इसे देखिये:

http://www.cprogramming.com/tutorial/initialization-lists-c++.html

🙂

std::vector साथ ढेर का उपयोग किए बिना एक समाधान boost::array का उपयोग करना है, हालांकि आप सरणी सदस्यों को सीधे कन्स्ट्रक्टर में प्रारंभ नहीं कर सकते हैं।

 #include <boost/array.hpp> const boost::array<int, 2> aa={ { 2, 3} }; class A { const boost::array<int, 2> b; A():b(aa){}; }; 

दिलचस्प बात यह है कि सी # में आपके पास कन्स्ट्रेट कॉन्स्ट है जो सी ++ के स्थैतिक कॉन्स्ट का अनुवाद करता है, जो केवल पढ़ने वाले के विपरीत है, जिसे केवल कंस्ट्रक्शर्स और इनिशिअलाइजेशन पर सेट किया जा सकता है, यहां तक ​​कि गैर-स्थिरों के द्वारा, पूर्व:

 readonly DateTime a = DateTime.Now; 

मैं सहमत हूं, यदि आपके पास एक निश्चित प्री-डिफ़ाइंड सरणी है तो आप इसे स्थिर बना सकते हैं। उस बिंदु पर आप इस दिलचस्प वाक्यविन्यास का उपयोग कर सकते हैं:

 //in header file class a{ static const int SIZE; static const char array[][10]; }; //in cpp file: const int a::SIZE = 5; const char array[SIZE][10] = {"hello", "cruel","world","goodbye", "!"}; 

हालांकि, मुझे निरंतर '10' के आसपास कोई रास्ता नहीं मिला इसका कारण स्पष्ट है, यह जानने की जरूरत है कि सरणी तक कैसे पहुंचें। एक संभव विकल्प #define का उपयोग करना है, लेकिन मैं उस पद्धति को नापसंद और शीर्ष पर, मैं सीडीपी पर वहां टिप्पणी करने के लिए एक टिप्पणी के साथ और #undef को बदल सकता हूं, अगर कोई परिवर्तन हो।

कैसे एक accessor समारोह के माध्यम से एक const सरणी के अनुकरण के बारे में? यह गैर-स्थिर है (जैसा आपने अनुरोध किया है), और इसमें STL या किसी अन्य पुस्तकालय की आवश्यकता नहीं है:

 class a { int privateB[2]; public: a(int b0,b1) { privateB[0]=b0; privateB[1]=b1; } int b(const int idx) { return privateB[idx]; } } 

क्योंकि :: PrivateB निजी है, यह एक :: के बाहर प्रभावी रूप से स्थिर है, और आप इसे किसी सरणी के समान एक्सेस कर सकते हैं, जैसे

 a aobj(2,3); // initialize "constant array" b[] n = aobj.b(1); // read b[1] (write impossible from here) 

यदि आप कक्षाओं की एक जोड़ी का उपयोग करने के लिए तैयार हैं, तो आप सदस्य कार्य से निजी बी की रक्षा कर सकते हैं यह एक विरासत से किया जा सकता है; लेकिन मुझे लगता है कि मैं एक कॉन्स्ट क्लास का इस्तेमाल करते हुए जॉन हैरिसन के comp.lang.c ++ पोस्ट को पसंद करता हूं ।