c++ - सी++ में कक्षा प्रारंभकर्ता में एक कॉन्स सरणी प्रारंभ करें




initialization c++03 (7)

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

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

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

#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

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

#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 << "v.a => " << v.a[0] << ", " << v.a[1] << "\n";
    return 0;
}

मेरे पास सी ++ में निम्न श्रेणी है:

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 लिए अलग-अलग मान रख सकता हूं, लेकिन मानों को उदाहरण के जीवनकाल के लिए स्थिर माना जाता है।



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

#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;
}

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

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 करता हूं, सीपीपी में संपादित करने के लिए एक टिप्पणी के साथ-साथ यदि कोई परिवर्तन होता है।


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


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

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() {
 a a;
}

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){};
};






array-initialize