मैं सी ++

Question

में किसी फ़ंक्शन में "किसी भी प्रकार का डेटा" कैसे पास कर सकता हूं, मान लें कि मेरे पास स्ट्रिंगहैंडर, कुछ टाइप टाइपलर, अन्य टाइप टाइपलर जैसे कुछ उप-वर्गों के साथ एक कक्षा हैंडलर है। कक्षा हैंडलर सभी उप-वर्गों के लिए एक सामान्य इंटरफ़ेस के रूप में एक विधि "हैंडल" को परिभाषित करता है। "हैंडल" के लिए तर्क विभिन्न हैंडलरों के लिए पूरी तरह से अलग है।

तो मुझे जो करना है वह हैडल विधि में किसी भी चीज़ का मूल्य पास कर रहा है। विशिष्ट वर्ग तब "कुछ भी" उस प्रकार के प्रकार को डाल सकते हैं जिसकी वे अपेक्षा करते हैं।

असल में मैं क्या जरूरत है जावा वर्ग वस्तु की तरह कुछ है: डी

पहली बात मैंने कोशिश की एक void* था, लेकिन जाहिरा तौर पर आप B* someB = dynamic_cast<B*>(theVoidPointer) ऐसा नहीं कर सकते, इसलिए कोई किस्मत वहाँ।

मेरा दूसरा विचार boost::any का उपयोग करना था। हालांकि, बूस्ट :: किसी भी का उपयोग करने की आवश्यकता यह है कि मान को प्रतिलिपि बनाने योग्य प्रतिलिपि बनाना चाहिए, जो मेरे डेटा का मामला नहीं है।

इसे काम करने के लिए कोई विचार?

धन्यवाद

संपादित करें: ध्यान दें मैं मैं सब पर कोई सदस्यों के साथ एक SomeData वर्ग इस्तेमाल कर सकते हैं पता है कि, और अपने डेटा के उपवर्गों रहने दो, लेकिन मैं एक अधिक सामान्य दृष्टिकोण है जो मुझे आवश्यकता नहीं है के लिए देख रहा हूँ अपना खुद का रैपर वर्ग बनाने के लिए।

Answer 1

ठीक है, एक सरल बढ़ावा का उपयोग कर :: किसी भी आपके डेटाटाइप्स की ओर इशारा धारण करने के लिए दृष्टिकोण है। हालांकि, सावधान रहें कि कोई भी ओवरहेड कोड थोड़ा कम प्रदर्शन करता है (ज्यादातर मामलों में उपेक्षित) .. बूस्ट :: भावना :: hold_any का उपयोग करने पर विचार करें, या शून्य * यदि आपको टाइप सुरक्षा की आवश्यकता नहीं है।

class Handler { 
public: 
    void handle(boost::any value) { 
     do_handle(value); 
    } 
private: 
    virtual void do_handle(boost::any& value) = 0; 
}; 

template<class T> 
class HandlerBase : public Handler { 
private: 
    void do_handle(boost::any& value) { 
     // here you should check if value holds type T*... 
     handle_type(*(boost::any_cast<T*>(value))); 
    } 

    void handle_type(const T& value) = 0; 
}; 

class StringHandler : HandlerBase<std::string> { 
private: 
    void handle_type(const std::string& value) { 
     // do stuff 
    } 
}; 

अब आप हैंडलर वर्गों के बहुत सारे लिख सकते हैं, HandlerBase से पाने, यह सोचते हैं कि संभाला प्रकार एक आम आधार वर्ग है बिना।

Answer 2

आप

B* someB = static_cast<B*>(theVoidPointer); 

Answer 3

आप DataObject या कुछ और कहा जाता है एक आधार वर्ग की आवश्यकता कर सकते हैं। आपके सभी डेटा प्रकार, (स्ट्रिंग, संख्या, whatnot) DataObject के उप वर्ग हैं। आप इस तरह हैंडल परिभाषित करते हैं:

void Handle(DataObject *dataObject); 

यह वही करने का एक सुरक्षित तरीका है जो आप चाहते हैं। इसे और भी बेहतर बनाने के लिए, डेटाऑब्जेक्ट यह भी जान सकता है कि इसमें किस प्रकार का डेटा है। फिर हैंडलर जांच सकते हैं कि उन्हें सही प्रकार का डेटा भेजा गया है।

class BaseHandlerData { 
    ... 
}; 

फिर अपने विशिष्ट डेटा कक्षाएं, जो अपने संचालकों द्वारा की उम्मीद कर रहे निकाले जाते हैं:

Answer 4

आप उदाहरण के लिए एक आधार वर्ग को परिभाषित कर सकते

class StringData: public BaseHandlerData { 
    ... 
}; 

class SomeData: public BaseHandlerData { 
    ... 
}; 

तो फिर तुम एक BaseHandlerData पारित करने के लिए सक्षम होना चाहिए * हैंडल विधि के लिए तर्क, और कुछ का उपयोग करें:

void handle(BaseHandlerData *data) { 
    StringData* stringData = dynamic_cast<StringData*>(...); 
    // handle your string data here ... 
} 

सुरक्षित अपने अपेक्षित डेटा प्रकार के लिए ly cast।

गेराल्ड

Answer 5

एक और विकल्प, C दुनिया की ओर अधिक हो रहा है, union प्रकार (http://en.wikipedia.org/wiki/Union_(computer_science)#C.2FC.2B.2B) होगा। यह आपको केवल प्रकार से निर्दिष्ट प्रकारों को पारित करने की अनुमति देगा, लेकिन आपके द्वारा वर्णित व्यवहार का प्रकार है।