बनाम सी में गतिशील प्रकार की जाँच ++

Question

स्टेटिक मुझे पता है कि स्थिर और गतिशील प्रकार की जाँच और उनके बीच मतभेद हैं क्या चाहते हैं।

Answer 1

स्टेटिक प्रकार की जाँच का मतलब है कि प्रकार की जाँच संकलन समय पर होता है। उस मामले में रनटाइम पर कोई भी प्रकार की जानकारी का उपयोग नहीं किया जाता है।

गतिशील प्रकार की जाँच तब होता है जब प्रकार की जानकारी कार्यावधि में प्रयोग किया जाता है। सी ++ इसे लागू करने के लिए आरटीटीआई (रनटाइम प्रकार की जानकारी) नामक एक तंत्र का उपयोग करता है।

// assuming that Circle derives from Shape... 
Shape *shape = new Circle(50); 
Circle *circle = dynamic_cast<Circle*> shape; 

इसके अलावा, आप typeid ऑपरेटर का उपयोग कर सकते हैं वस्तुओं के क्रम प्रकार के बारे में पता लगाने के लिए: सबसे आम उदाहरण जहां RTTI प्रयोग किया जाता है dynamic_cast ऑपरेटर जो बहुरूपी प्रकार की downcasting अनुमति देता है। उदाहरण के लिए, आप इसका उपयोग यह जांचने के लिए कर सकते हैं कि उदाहरण में आकार एक सर्कल या आयताकार है या नहीं। यहां कुछ further information है।

Answer 2

स्टेटिक प्रकार की जाँच की जाँच कि संकलन समय पर किया जाता है प्रकार है। यह एकमात्र प्रकार की जांच है जो सी ++ करता है। डायनामिक टाइप चेकिंग रन टाइम पर टाइप चेकिंग की जाती है। यह आमतौर पर गतिशील व्याख्या की गई भाषाओं में देखा जाता है, लेकिन संकलित भाषाओं में कम आम है। आखिरी बार मैंने जांच की, सी ++ किसी प्रकार की गतिशील प्रकार की जांच नहीं करता है।

संपादित करें: जाहिर है मैं पुराना हो चुका हूँ। नीचे रीड की टिप्पणी देखें।

Answer 3

सी ++ में उपलब्ध डाले के कई प्रकार के होते हैं।

सबसे आम क्रम दूसरे करने के लिए सूचक का एक प्रकार से एक चर कास्ट करने के लिए में static_cast उपयोग करने के लिए किया जाएगा। हालांकि, आप dynamic_cast का भी उपयोग कर सकते हैं, जो सुनिश्चित करने के लिए जांच करेगा (रनटाइम पर) कि पॉइंटर्स सही प्रकार के हैं। Dynamic_cast के साथ, यदि पॉइंटर सही प्रकार का नहीं है, तो रनटाइम पर, यह बदले में 0 लौटाएगा।

// Assume these classes exist 
// class A 
// class B 
// class C : B 

C* c = new C(); 
A* a = new A(); 

B* b = static_cast<B*>(a); // this will work! 
b = dynamic_cast<B*>(a); // b == NULL 
b = dynamic_cast<B*>(c); // b is valid 

Answer 4

सी गतिशील प्रकार एक जाँच के लिए बहुत कम समर्थन है ++ dynamic_cast के माध्यम से है और अन्य type id के माध्यम से .Both इस्तेमाल किया जा सकता है केवल जब RTTI समर्थन संकलक में सक्षम है।

TYPE& dynamic_cast<TYPE&> (object); 
TYPE* dynamic_cast<TYPE*> (object); 

dynamic_cast कीवर्ड एक से दूसरे सूचक या संदर्भ प्रकार से एक गृहीत डाले, एक क्रम की जांच प्रदर्शन कर डाली की वैधता सुनिश्चित करने के लिए।

आप एक प्रकार है कि वास्तविक वस्तु का एक प्रकार नहीं है करने के लिए सूचक को कास्ट करने के लिए प्रयास करते हैं, कलाकारों का परिणाम शून्य हो जाएगा। आप एक प्रकार है कि वास्तविक वस्तु का एक प्रकार नहीं है के संदर्भ को कास्ट करने के लिए प्रयास करते हैं, डाली एक bad_cast अपवाद फेंक देते हैं।

यकीन है कि कम से कम एक बेस कक्षा में आभासी समारोह dynamicast काम करने के लिए नहीं है सुनिश्चित करें। ,

class A {}; 
class B:A {}; 

A* a = new B(); 
B* b = new B(); 

---

स्थिर प्रकार के लिए आप कैसे चर घोषित किया जाता है पर नज़र डालें:

// expre_typeid_Operator.cpp 
// compile with: /GR /EHsc 
#include <iostream> 
#include <typeinfo.h> 

class Base { 
public: 
    virtual void vvfunc() {} 
}; 

class Derived : public Base {}; 

using namespace std; 
int main() { 
    Derived* pd = new Derived; 
    Base* pb = pd; 
    cout << typeid(pb).name() << endl; //prints "class Base *" 
    cout << typeid(*pb).name() << endl; //prints "class Derived" 
    cout << typeid(pd).name() << endl; //prints "class Derived *" 
    cout << typeid(*pd).name() << endl; //prints "class Derived" 
    delete pd; 
} 

Answer 5

मान लें आप कर सकते है।

A* a = ... 
B* b = ... 

तो a के स्थिर प्रकार A* है (या दूसरे शब्दों में कहें को, *a के स्थिर प्रकार A है)।

और b के स्थिर प्रकार B* है (या दूसरे शब्दों में कहें को, *b के स्थिर प्रकार B है)।

ध्यान दें कि a और b एक स्थिर प्रकार है कि यह की घोषणा से तय हो गई है है - यह कोई फर्क नहीं पड़ता कि आप उन्हें में डाल दिया, वे एक ही स्थिर प्रकार रखेंगे। ("स्थैतिक" का मतलब है "अपरिवर्तनीय")।

---

गतिशील प्रकार के लिए, आप अभी वैरिएबल में क्या होता है यह देखते हैं।

a = new B(); 
b = new B(); 

तो a और b के गतिशील प्रकार दोनों B* (या दूसरे शब्दों में कहें को, *a और *b के गतिशील प्रकार दोनों B हैं)।

ध्यान दें कि गतिशील प्रकार बदल सकता है - यदि आपने a = new A() किया तो वे गतिशील प्रकार a बस A* में बदल गए। कभी-कभी आप नहीं जानते कि गतिशील प्रकार क्या है - उदा। यदि आप a = somefunc() करना तो a गतिशील प्रकार A*, B* या यहाँ तक कि C* (कुछ कोड आप नहीं देखा है A या B का एक उपवर्ग के रूप में परिभाषित करता है C हैं) हो सकता है।

यदि A पर virtual विधि थी, तो आप डायनामिक प्रकार क्या है, यह जानने के लिए dynamic_cast का उपयोग कर सकते हैं। (आमतौर पर, यदि आप इस तरह के कोड का उपयोग कर रहे हैं, तो आप delete a करने में सक्षम होना चाहते हैं; इसके लिए A के विनाशक को virtual होना चाहिए। और A का विनाशक वर्चुअल dynamic_cast काम करने के लिए पर्याप्त है)।