java.io.Serializable का सी/सी ++ समतुल्य क्या है?

Question

java.io.Serializable का सी/सी ++ समतुल्य क्या है?

वहाँ पर अनुक्रमण पुस्तकालयों रहे हैं संदर्भ:

• Serialize Data Structures in C

और देखते हैं:

• http://troydhanson.github.io/tpl/index.html
• http://www.boost.org/doc/libs/1_41_0/libs/serialization/doc/index.html
• https://developers.google.com/protocol-buffers/docs/cpptutorial#optimization-tips

लेकिन इस तरह के एक तुल्यता भी मौजूद हैं?

तो यदि मेरे पास जावा में निम्नानुसार सार तत्व है, तो सी/सी ++ में एक धारावाहिक वर्ग कैसा दिखता है?

import java.io.Serializable; 

public interface SuperMan extends Serializable{ 

    /** 
    * Count the number of abilities. 
    * @return 
    */ 
    public int countAbility(); 

    /** 
    * Get the ability with index k. 
    * @param k 
    * @return 
    */ 
    public long getAbility(int k); 

    /** 
    * Get the array of ability from his hand. 
    * @param k 
    * @return 
    */ 
    public int[] getAbilityFromHand(int k); 

    /** 
    * Get the finger of the hand. 
    * @param k 
    * @return 
    */ 
    public int[][] getAbilityFromFinger(int k); 

    //check whether the finger with index k is removed. 
    public boolean hasFingerRemoved(int k); 

    /** 
    * Remove the finger with index k. 
    * @param k 
    */ 
    public void removeFinger(int k); 

} 

किसी भी serializable C/C सिर्फ जावा में तरह प्राप्त की जा वस्तु ++ सकते हैं?

Answer 1

कोई मानक पुस्तकालय वर्गों कि क्रमबद्धता उसी तरह Java करता है को लागू कर रहे हैं। वहाँ कुछ पुस्तकालयों कि क्रमबद्धता की सुविधा है, लेकिन बुनियादी जरूरतों के लिए आप आम तौर पर अपनी कक्षा प्रविष्टि और निष्कर्षण ऑपरेटरों इस तरह अधिक भार से serializable बनाने:

class MyType 
{ 
    int value; 
    double factor; 
    std::string type; 

public: 
    MyType() 
    : value(0), factor(0.0), type("none") {} 
    MyType(int value, double factor, const std::string& type) 
    : value(value), factor(factor), type(type) {} 

    // Serialized output 
    friend std::ostream& operator<<(std::ostream& os, const MyType& m) 
    { 
     return os << m.value << ' ' << m.factor << ' ' << m.type; 
    } 

    // Serialized input 
    friend std::istream& operator>>(std::istream& is, MyType& m) 
    { 
     return is >> m.value >> m.factor >> m.type; 
    } 
}; 

int main() 
{ 
    std::vector<MyType> v {{1, 2.7, "one"}, {4, 5.1, "two"}, {3, 0.6, "three"}}; 

    std::cout << "Serialize to standard output." << '\n'; 

    for(auto const& m: v) 
     std::cout << m << '\n'; 

    std::cout << "\nSerialize to a string." << '\n'; 

    std::stringstream ss; 
    for(auto const& m: v) 
     ss << m << '\n'; 

    std::cout << ss.str() << '\n'; 

    std::cout << "Deserialize from a string." << '\n'; 

    std::vector<MyType> v2; 

    MyType m; 
    while(ss >> m) 
     v2.push_back(m); 

    for(auto const& m: v2) 
     std::cout << m << '\n'; 

} 

आउटपुट:

Serialize to standard output. 
1 2.7 one 
4 5.1 two 
3 0.6 three 

Serialize to a string. 
1 2.7 one 
4 5.1 two 
3 0.6 three 

Deserialize from a string. 
1 2.7 one 
4 5.1 two 
3 0.6 three 

क्रमबद्धता प्रारूप en tirely प्रोग्रामर करने के लिए और आपको लगता है कि यह है कि आप serialize करना चाहते वर्ग के प्रत्येक सदस्य को ही serializable है सुनिश्चित करने के लिए जिम्मेदार हैं (एक प्रविष्टि/निष्कर्षण ऑपरेटर परिभाषित किया गया है)। आपको यह भी निपटाना होगा कि फ़ील्ड कैसे अलग हो जाते हैं (रिक्त स्थान या नई लाइनें या शून्य-समाप्त?)।

सभी बुनियादी प्रकार क्रमबद्धता (प्रविष्टि/निष्कर्षण) ऑपरेटरों पूर्व निर्धारित है, लेकिन आप अभी भी std::string की तरह चीजें हैं जो शामिल कर सकते हैं रिक्तियों या नई लाइनों (उदाहरण के लिए) के साथ सावधान रहना चाहिए (यदि आप अपने क्षेत्र के डिलीमीटर के रूप में रिक्त स्थान या नई लाइनों का उपयोग कर रहे हैं)।

Answer 2

इसके लिए कोई मानक नहीं है। वास्तव में हर पुस्तकालय इसे विभिन्न तरीकों से कार्यान्वित कर सकता है।

• वर्ग आम आधार वर्ग से प्राप्त किया जा करने के लिए किया है और लागू read() और write() आभासी तरीके:: - सी में इस ++

  class SuperMan : public BaseObj 
  { 
  public: 
      virtual void read(Stream& stream); 
      virtual void write(Stream& stream); 
  }; 
  

• वर्ग विशेष इंटरफ़ेस को लागू करना चाहिए यहाँ कुछ दृष्टिकोण जो किया जा सकता है विशेष अमूर्त वर्ग से वर्ग प्राप्त करके किया जाता है।

  class Serializable 
  { 
  public: 
      virtual Serializable() {} 
      virtual void read(Stream& stream) = 0; 
      virtual void write(Stream& stream) = 0; 
  }; 
  
  class SuperMan : public Man, public Serializable 
  { 
  public: 
      virtual void read(Stream& stream); 
      virtual void write(Stream& stream); 
  }; 
  

• पुस्तकालय अनुमति दे सकता है (या आवश्यकता होती है) दिया प्रकार के लिए "serializers" रजिस्टर करने के लिए: यह पिछली पद्धति का variaton है।

  #define SUPERMAN_CLASS_ID 111 
  
  class SuperMan 
  { 
  public: 
      virtual int getClassId() 
      { 
       return SUPERMAN_CLASS_ID; 
      } 
  }; 
  
  class SuperManSerializer : public Serializer 
  { 
      virtual void* read(Stream& stream); 
      virtual void write(Stream& stream, void* object); 
  }; 
  
  int main() 
  { 
      register_class_serializer(SUPERMAN_CLASS_ID, new SuperManSerializer()); 
  } 
  

• serializers भी लागू किया जा सकता functors का उपयोग कर, उदा: वे विशेष आधार वर्ग या इंटरफ़ेस से वर्ग बनाने, और फिर उन्हें दिए गए प्रकार के लिए पंजीकरण करके लागू किया जा सकता lambdas:

  तरह

  int main 
  { 
      register_class_serializer<SuperManSerializer>(); 
  } 
  

• वर्ग अतिभारित प्रदान करना चाहिए ऑपरेटरों < < ':

  int main 
  { 
      register_class_serializer(SUPERMAN_CLASS_ID, 
             [](Stream&, const SuperMan&) {}, 
             [](Stream&) -> SuperMan {}); 
  } 
  

• बजाय कुछ कार्य करने के लिए serializer वस्तु पास करने का है, यह विशेष टेम्पलेट कार्य करने के लिए अपनी तरह से पारित करने के लिए पर्याप्त हो सकता है और '>>'। उनके लिए पहला तर्क कुछ स्ट्रीम क्लास है, और दूसरा क्लास इंस्टेंस है। स्ट्रीम std::stream हो सकता है, लेकिन यह इन ऑपरेटरों के लिए डिफ़ॉल्ट उपयोग के साथ संघर्ष का कारण बनता है - उपयोगकर्ता के अनुकूल टेक्स्ट प्रारूप में और उससे कनवर्ट करना। इस स्ट्रीम क्लास के कारण एक समर्पित एक है (हालांकि यह std :: स्ट्रीम को लपेट सकता है), या लाइब्रेरी वैकल्पिक विधि का समर्थन करेगी यदि << को भी समर्थित होना चाहिए।

  class SuperMan 
  { 
  public: 
      friend Stream& operator>>(const SuperMan&); 
      friend Stream& operator<<(const SuperMan&); 
  }; 
  

• हमारे वर्ग प्रकार के लिए कुछ वर्ग टेम्पलेट का विशेषज्ञता होना चाहिए। यह समाधान << और >> ऑपरेटरों के साथ एक साथ इस्तेमाल किया जा सकता है - पुस्तकालय पहले इस टेम्पलेट का उपयोग करने की कोशिश करेंगे, और ऑपरेटरों पर वापस लौटने अगर यह विशेष नहीं किया जाएगा (यह डिफ़ॉल्ट टेम्पलेट संस्करण के रूप में लागू किया जा सकता है, या SFINAE का प्रयोग करके)

  // default implementation 
  template<class T> 
  class Serializable 
  { 
  public: 
      void read(Stream& stream, const T& val) 
      { 
       stream >> val; 
      } 
      void write(Stream& stream, const T& val) 
      { 
       stream << val; 
      } 
  }; 
  
  // specialization for given class 
  template<> 
  class Serializable<SuperMan> 
  { 
      void read(Stream& stream, const SuperMan& val); 
      void write(Stream& stream, const SuperMan& val); 
  } 
  

• वर्ग टेम्पलेट लायब्रेरी के बजाय वैश्विक अतिभारित कार्यों के साथ सी-शैली इंटरफ़ेस का उपयोग कर सकते हैं:

  template<class T> 
  void read(Stream& stream, const T& val); 
  template<class T> 
  void write(Stream& stream, const T& val); 
  
  template<> 
  void read(Stream& stream, const SuperMan& val); 
  template<> 
  void write(Stream& stream, const SuperMan& val); 
  

C++ भाषा, लचीला है तो उपरोक्त सूची यकीन है कि पूरा नहीं हुआ है। मुझे विश्वास है कि एक और समाधान का आविष्कार करना संभव होगा।

Answer 3

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

Answer 4

सौभाग्य से ... सी ++ कक्षा पदानुक्रम के क्रमिकरण के लिए एक डिफ़ॉल्ट तंत्र लागू नहीं करता है।(मैं मानक पुस्तकालय या कुछ में एक विशेष आधार प्रकार के द्वारा आपूर्ति की एक वैकल्पिक तंत्र की आपूर्ति यह कोई फ़र्क नहीं पड़ेगा, लेकिन कुल इस मौजूदा Abis पर सीमा डाल सकता है)

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

आप जटिलताओं के विचार के लिए here भी देखना चाहेंगे और यदि आप वास्तव में मानक के खिलाफ सत्यापित करना चाहते हैं तो आप purchase a copy here कर सकते हैं। ऐसा लगता है कि अगले मानक के लिए वर्किंग ड्राफ्ट github पर है।

आवेदन विशिष्ट प्रणालियों

सी ++/सी आवेदन के लेखक स्वतंत्रता प्रौद्योगिकियों लोगों को ले के कई के पीछे यांत्रिकी चयन करने के लिए नए और अक्सर उच्च स्तर भाषाओं के साथ प्रदान करने के लिए अनुमति देते हैं। प्रतिबिंब (RTTI), अपवाद, संसाधन/मेमोरी प्रबंधन (कचरा संग्रह, RAII, आदि)। ये सिस्टम सभी किसी विशेष उत्पाद की समग्र गुणवत्ता को संभावित रूप से प्रभावित कर सकते हैं।

मैंने वास्तविक समय गेम, एम्बेडेड डिवाइस, मोबाइल ऐप्स, वेब अनुप्रयोगों से सबकुछ पर काम किया है और विशेष परियोजना के समग्र लक्ष्यों में से सभी के बीच भिन्नता है।

अक्सर वास्तविक समय के लिए उच्च प्रदर्शन गेम के लिए आप स्पष्ट रूप से RTTI अक्षम कर सकते हैं (यह ईमानदार होने के लिए सी ++ में बहुत उपयोगी नहीं है) और संभवतः यहां तक ​​कि अपवाद भी (कई लोग यहां उत्पादित ओवरहेड की इच्छा नहीं रखते हैं और यदि आप थे वास्तव में पागल आप अपने स्वयं के रूप को लंबे कूद से और इस तरह से लागू कर सकते हैं। मेरे लिए अपवाद एक अदृश्य इंटरफ़ेस बनाते हैं जो प्रायः बग बनाता है जो लोग संभव होने की उम्मीद भी नहीं करेंगे, इसलिए मैं अक्सर उन्हें अधिक स्पष्ट तर्क के पक्ष में उनसे बचता हूं।)।

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

प्रकार पदानुक्रम का स्वत: क्रमांकन के जनरल विचार

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

मैं बेस प्रतिबिंब पाठक/लेखक प्रकार का भी उपयोग करता हूं जो व्युत्पन्न स्वरूपण को ओवरराइड करने की अनुमति देने के लिए कुछ iostream इंटरफेस का खुलासा करता है। मेरे पास वर्तमान में एक बाइनरी ऑब्जेक्टियो, JSONObjectIO, और ASTObjectIO है लेकिन दूसरों को जोड़ने के लिए यह छोटा है। इसका मुद्दा पदानुक्रम से किसी विशेष डेटा प्रारूप को क्रमबद्ध करने और इसे धारावाहिक में डालने की जिम्मेदारी को हटाना है।भाषा के स्तर

पर

प्रतिबिंब कई स्थितियों में आवेदन जानता है कि यह क्रमानुसार करने चाहते हैं और वहाँ यह भाषा में हर वस्तु में निर्माण करने के लिए कोई कारण नहीं है कि कौन सा डेटा। कई आधुनिक भाषाओं में RTTI भी सिस्टम के मूल प्रकारों में शामिल हैं (यदि वे प्रकार आधारित सामान्य इंट्रिनिक्स हैं, तो int, float, double, आदि)। आवेदन के उपयोग के बावजूद सिस्टम में सब कुछ के लिए अतिरिक्त डेटा संग्रहीत करने की आवश्यकता है। मुझे यकीन है कि कई आधुनिक कंपाइलर कभी-कभी पेड़ को हिलाकर कुछ अनुकूलित कर सकते हैं, लेकिन आप इसकी गारंटी भी नहीं दे सकते। हालांकि वे पदानुक्रम संभाल वास्तविक क्रमबद्धता कार्य होने से कुछ लचीलापन की कमी

एक कथात्मक दृष्टिकोण

तरीकों पहले ही उल्लेख किया, सभी वैध उपयोग के मामलों रहे हैं। यह पदानुक्रम पर बॉयलरप्लेट स्ट्रीम हेरफेर के साथ आपके कोड को भी मिटा सकता है।

मैं व्यक्तिगत रूप से प्रतिबिंब के माध्यम से एक और घोषणात्मक दृष्टिकोण पसंद करता हूं। मैंने अतीत में क्या किया है और कुछ स्थितियों में करना जारी रखना मेरे सिस्टम में एक आधार प्रतिबिंबित प्रकार है। मैं कुछ बॉयलरप्लेट तर्क के साथ-साथ स्ट्रिंग कॉन्सटेनेशन मैक्रोज़ के प्रीप्रोसेसर के साथ मदद करने के लिए template metaprogramming का उपयोग कर समाप्त करता हूं। अंत परिणाम एक आधार प्रकार है जिसे मैं इंटरफेस का पर्दाफाश करने के लिए एक परावर्तनीय मैक्रो घोषणा और गड़बड़ी को लागू करने के लिए एक परावर्तनीय मैक्रो परिभाषा (प्रकार के लुकअप टेबल में पंजीकृत सदस्य को जोड़ने जैसे कार्य) से प्राप्त होता हूं।

class ASTNode : public Reflectable 
{ 

... 

public: 
    DECLARE_CLASS 

    DECLARE_MEMBER(mLine,int) 
    DECLARE_MEMBER(mColumn,int) 

... 

}; 

फिर कुछ इस तरह सीपीपी में:

BEGIN_REGISTER_CLASS(ASTNode,Reflectable); 
REGISTER_MEMBER(ASTNode,mLine); 
REGISTER_MEMBER(ASTNode,mColumn); 
END_REGISTER_CLASS(ASTNode); 

ASTNode::ASTNode() 
: mLine(0) 
, mColumn(0) 
{ 
} 

मैं तो साथ सीधे प्रतिबिंब इंटरफ़ेस का उपयोग कर सकते हैं

तो मैं सामान्य रूप से कुछ है कि में ज इस तरह दिखता है के साथ खत्म कुछ विधियां जैसे:

int id = myreflectedObject.Get<int>("mID"); 
myreflectedObject.Set("mID", 6); 

लेकिन आमतौर पर मैं कुछ "लक्षण" डेटा को फिर से शुरू करता हूं कि मैं एक और इंटरफेस के साथ संपर्क में है:

ReflectionInfo::RefTraitsList::const_iterator it = info->getReflectionTraits().begin(); 

वर्तमान लक्षण आपत्ति इस तरह दिखता है:

class ReflectionTraits 
    { 
    public: 
     ReflectionTraits(const uint8_t& type, const uint8_t& arrayType, const char* name, const ptrType_t& offset); 

     std::string getName() const{ return mName; } 
     ptrType_t getOffset() const{ return mOffset; } 
     uint8_t getType() const{ return mType; } 
     uint8_t getArrayType() const{ return mArrayType; } 

    private:  
     std::string  mName; 
     ptrType_t  mOffset; 
     uint8_t   mType; 
     uint8_t   mArrayType; // if mType == TYPE_ARRAY this will give the type of the underlying data in the array 
    }; 

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

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

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

इस तकनीक के बारे में एक अंतिम नोट यह है कि आप स्पष्ट रूप से नियंत्रित कर रहे हैं जो यहां क्रमबद्ध है। आप उस डेटा को चुन और चुन सकते हैं जिसे आप क्रमबद्ध करना चाहते हैं और वह डेटा जो कुछ क्षणिक ऑब्जेक्ट स्थिति का ट्रैक रख सकता है।

सी ++ लैक्स की गारंटी देता है

एक बात नोट करने के लिए ... के बाद से सी ++ डेटा वास्तव में कैसा दिखता है के बारे में बहुत सुस्त है। आपको अक्सर कुछ प्लेटफ़ॉर्म विशिष्ट विकल्प बनाना पड़ता है (यह शायद मानक सिस्टम प्रदान नहीं किए जाने वाले मुख्य कारणों में से एक है)। आप वास्तव में टेम्पलेट मेटाप्रोग्रामिंग के साथ संकलन समय पर एक बड़ा सौदा कर सकते हैं, लेकिन कभी-कभी 8 बिट्स होने के लिए अपने char को मानना ​​आसान होता है। हां, यह सरल धारणा सी ++ में 100% सार्वभौमिक नहीं है, सौभाग्य से ज्यादातर स्थितियों में यह है।

मैं जिस दृष्टिकोण का उपयोग करता हूं वह स्मृति लेआउट निर्धारित करने के लिए नल पॉइंटर्स के कुछ गैर-मानक कास्टिंग करता है (फिर मेरे उद्देश्यों के लिए यह जानवर की प्रकृति है)। निम्नलिखित मैक्रो द्वारा प्रदान किए जाने वाले प्रकार के सदस्य ऑफसेट की गणना करने के लिए मैक्रो कार्यान्वयन में से एक से एक उदाहरण स्निपेट है जहां क्लास प्रदान किया जाता है।

(ptrType_t)&reinterpret_cast<ptrType_t&>((reinterpret_cast<CLASS*>(0))->member) 

प्रतिबिंब

प्रतिबिंब के साथ सबसे बड़ी समस्या के बारे में एक सामान्य चेतावनी है कि यह कैसे शक्तिशाली हो सकता है। प्रतिबिंब के बहुत अधिक असंगत उपयोग के साथ आप आसानी से एक आसानी से बनाए रखने योग्य कोडबेस को एक विशाल गड़बड़ में बदल सकते हैं।

मैं व्यक्तिगत रूप से निचले स्तर के सिस्टम (मुख्य रूप से क्रमबद्धता) के लिए प्रतिबिंब आरक्षित करता हूं और व्यापार तर्क के लिए रनटाइम प्रकार की जांच के लिए इसका उपयोग करने से बचता हूं। वर्चुअल फ़ंक्शंस जैसे भाषा संरचनाओं के साथ गतिशील प्रेषण प्रतिबिंब प्रकार चेक सशर्त कूदों को प्राथमिकता दी जानी चाहिए।

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

निष्कर्ष

वर्तमान में है सी ++ में एक serializable वर्ग पदानुक्रम के आम प्रतिमान करने के लिए कोई मानक बराबर है, लेकिन यह ज्यादा किसी अन्य प्रणाली आप नए भाषाओं में देखने की तरह जोड़ा जा सकता है। आखिरकार सबकुछ सरल मशीन कोड के लिए अनुवाद करता है जिसे आपके सीपीयू मरने में शामिल ट्रांजिस्टर की अविश्वसनीय सरणी की बाइनरी स्थिति द्वारा दर्शाया जा सकता है।

मैं यह नहीं कह रहा हूं कि हर किसी को किसी भी तरह से अपना खुद का रोल करना चाहिए। यह जटिल और त्रुटि प्रवण काम है। मुझे बस इस विचार को बहुत पसंद आया और वैसे भी इस तरह की चीज में दिलचस्पी रही है। मुझे यकीन है कि इस तरह के काम के लिए लोग कुछ मानक फॉलबैक उपयोग करते हैं। जैसा आपने ऊपर बताया है, सी ++ की तलाश करने वाला पहला स्थान boost होगा।

यदि आप "सी ++ प्रतिबिंब" की खोज करते हैं तो आप कई उदाहरण देखेंगे कि दूसरों को एक समान परिणाम कैसे प्राप्त होता है।

एक त्वरित खोज this को एक उदाहरण के रूप में खींच लिया गया।