यहाँ 2 वर्ग हैं, एक अभिभावक और एक उपवर्ग:

class Model
{
    protected:
    static std::list<char *>   list;
}

class SubModel : public Model
{
    // Should add itself to Model::list...
}

तो, यहाँ 2 उदाहरण वर्ग हैं। मैं एक सामान्य मॉडल बनाना चाहता हूं जिस तरह से प्रत्येक उपवर्ग (सही ढंग से कार्यान्वित) खुद को static Model::list में पंजीकृत करेगा। इस तरह, कोई भी अन्य उपवर्ग अन्य "मौजूदा" मॉडल (और प्रकार के नाम) की पहचान करने में सक्षम है।

मैंने कई तरीकों की कोशिश की है, लेकिन मुझे कोई सुराग नहीं है कि एक स्थिर सदस्य को कई अन्य फाइलों में केवल एक बार कैसे पॉप्युलेट किया जाए।

कोई विचार, यदि संभव हो तो?

संपादित करें: मैं प्रत्येक उप मॉडल में कहीं न कहीं Model::list.push_back("SubModel"); जैसा कुछ करने का तरीका ढूंढ रहा हूं (पाठ्यक्रम के अनुसार नाम के साथ)

संपादित करें2: जाहिरा तौर पर, केवल एक ही फ़ंक्शन में सभी push_back के साथ संभव है। मैं जो चाहता था वह सबक्लास को स्वचालित रूप से खुद को पंजीकृत करना है। वर्चुअल register बनाने के लिए एक वैकल्पिक हल होगा जिसमें एक static bool init(false); होगा और कक्षा को पंजीकृत करेगा। फिर, सही पर सेट करें, अगर इनिट सही है तो कंस्ट्रक्टर वापस आ जाएंगे ...

0
Max13 4 अगस्त 2017, 03:11

2 जवाब

सबसे बढ़िया उत्तर

सस्ते हैक ट्रिक। प्रत्येक उपवर्ग कंस्ट्रक्टर में अप्रयुक्त चारों ओर लटकने वाले चर की लागत के लिए आप यह सुनिश्चित कर सकते हैं कि पंजीकरण प्रति वर्ग एक बार और केवल एक बार चलता है। एक static वेरिएबल को केवल एक बार इनिशियलाइज़ किया जाता है, इसलिए इसे इनिशियलाइज़ करने के लिए कॉल किया जाने वाला फंक्शन केवल एक बार ही कॉल किया जाता है।

#include <iostream>
#include <list>

class Model
{
public:
    static std::list<const char *>   list; // made public for ease of demonstration
                                           // const char * to store string literals
protected:
    // registration method
    bool reg(const char * name)
    {
        list.push_back(name);
        return true;
    }

};
std::list<const char *>   Model::list; // allocate storage for list


class SubModel1 : public Model
{
public:
    SubModel1()
    {
        // once will only be initialized once, so the reg method will only run once
        static bool once = reg("SubModel1");
        (void) once; // silence unused variable warning.
    }
};

class SubModel2 : public Model
{
public:
    SubModel2()
    {
        static bool once = reg("SubModel2");
        (void) once;
    }
};

class SubModel3 : public Model
{
public:
    SubModel3()
    {
        static bool once = reg("SubModel3");
        (void) once;
    }
};

int main()
{
    SubModel1 one;
    SubModel1 two;
    SubModel2 three;
    // note no SubModel3

    for (const char * model: Model::list)
    {
        std::cout << model << '\n';
    }
    return 0;
}

आउटपुट:

SubModel1
SubModel2
3
user4581301 4 अगस्त 2017, 03:52
class Model
{
protected:
    static std::vector<std::string> list;

};

// this line initializes 'list'
// this line must be outside the class 
std::vector<std::string> Model::list;

class SubModel : public Model
{
    // in the constructor, push the name of this class on to the vector:
    SubModel()
    {
       // you could check for duplicates first,
       // if you don't want the name to appear
       // multiple times (if you create multiple instances of this class)

       list.push_back("SubModel");
    }
};

class SubModel2 : public Model
{
    SubModel2()
    {
       list.push_back("SubModel2");
    }
};



int main()
{
    SubModel mod1;
    SubModel2 mod2;

    // list now contains two entries:
    // "SubModel"
    // "SubModel2"


}
0
ttemple 4 अगस्त 2017, 04:35