दिलचस्प पोस्ट
TransactSQL दूसरे TransactSQL स्क्रिप्ट को चलाने के लिए आप प्रदर्शन परीक्षण जावास्क्रिप्ट कोड कैसे करते हैं? Microsoft.ACE.OLEDB.12.0 प्रदाता पंजीकृत नहीं है क्या% ~ डीपी 0 का मतलब है, और यह कैसे काम करता है? सरल PHP फॉर्म: ईमेल के लिए अनुलग्नक (कोड गोल्फ) एक्सेल डाउनलोड पर फ़ाइल को भ्रष्ट चेतावनी को दबाने के लिए कैसे? फ़ंक्शन से एक आइटम के साथ टपल को रिटर्निंग करना बूटस्ट्रैप popover सभी तत्वों के शीर्ष पर नहीं दिखा रहा है लिनक्स में निर्देशिकाओं पर लूप कैसे करें? jQuery UI Accordion विस्तार / संक्षिप्त सभी जावा में सामान्य प्रकार का उदाहरण बनाएं? विस्तार अंक में विभाजित मुद्दा देखें टीएफएस में फाइल / निर्देशिकाओं को कैसे नजरअंदाज कर उन्हें केंद्रीय स्रोत भंडार में जाने से बचने के लिए? .NET में एक स्ट्रिंग से यूआरएल पैरामीटर प्राप्त करें डीबगिंग करते समय मैं क्लासएनोटलोडेड अपवाद के साथ कैसे व्यवहार करूं?

C ++ में एक टाइप किए गए एफएफ़ के आगे घोषणा

कंपाइलर ने मुझे एक टाइपिंगफेड घोषित करने के लिए आगे क्यों नहीं कहा?

यह मानना ​​असंभव है, मेरे शामिल किए जाने के पेड़ को छोटे रखने के लिए सबसे अच्छा अभ्यास क्या है?

Solutions Collecting From Web of "C ++ में एक टाइप किए गए एफएफ़ के आगे घोषणा"

आप टाइप टाइपफे को आगे बढ़ा सकते हैं लेकिन ऐसा करने के लिए

typedef AB; 

आपको पहली बार घोषित करना होगा:

 class A; typedef AB; 

आपके जैसे उन लोगों के लिए, जो कि सी-स्टाइल स्ट्रक्चर को अग्रेषित करने की तलाश कर रहे हैं, जिसे टाइपपीफे का उपयोग करके परिभाषित किया गया था, कुछ सी ++ कोड में, मुझे एक ऐसा हल मिल गया है जो निम्नानुसार है …

 // ah typedef struct _bah { int a; int b; } bah; // bh struct _bah; typedef _bah bah; class foo { foo(bah * b); foo(bah b); bah * mBah; }; // b.cpp #include "bh" #include "ah" foo::foo(bah * b) { mBah = b; } foo::foo(bah b) { mBah = &b; } 

सी ++ में (लेकिन सादा सी नहीं), यह दो बार टाइप टाइप करने के लिए पूरी तरह से कानूनी है, जब तक कि दोनों परिभाषा पूरी तरह से समान हों:

 // foo.h struct A{}; typedef A *PA; // bar.h struct A; // forward declare A typedef A *PA; void func(PA x); // baz.cc #include "bar.h" #include "foo.h" // We've now included the definition for PA twice, but it's ok since they're the same ... A x; func(&x); 

क्योंकि एक प्रकार की घोषणा करने के लिए, इसके आकार को जाना जाना चाहिए। आप प्रकार में एक संकेतक को अग्रेषित कर सकते हैं, या टाइप करने के लिए टाइप सूचक को टाइप कर सकते हैं।

यदि आप वास्तव में चाहते हैं, तो आप इसमें शामिल होने के लिए pimpl idiom का उपयोग कर सकते हैं लेकिन अगर आप एक संकेतक की बजाय एक प्रकार का उपयोग करना चाहते हैं, तो संकलक को उसके आकार का पता होना चाहिए।

संपादित करें: j_random_hacker इस उत्तर के लिए एक महत्वपूर्ण योग्यता जोड़ता है, मूलतः यह कि प्रकार का उपयोग करने के लिए आकार को पता होना चाहिए, लेकिन एक आगे घोषणा की जा सकती है अगर हमें केवल यह पता होना चाहिए कि प्रकार मौजूद है , संकेतक बनाने के लिए प्रकार। चूंकि ओपी ने कोड नहीं दिखाया, लेकिन शिकायत की कि यह संकलन नहीं करेगा, मैंने (शायद सही ढंग से) ग्रहण किया है कि ओपी प्रकार का उपयोग करने की कोशिश कर रहा था, न कि इसका संदर्भ लें।

"एक टाइपिंगफेड घोषित करने के लिए" आपको एक क्लास या स्ट्रेट घोषित करने की आवश्यकता है और फिर आप घोषित प्रकार टाइप कर सकते हैं। एकाधिक समान टाइपफ़ेफ़ को कंपाइलर द्वारा स्वीकार्य है।

लंबा फार्म:

 class MyClass; typedef MyClass myclass_t; 

संक्षिप्त रूप:

 typedef class MyClass myclass_t; 

पूर्ण #include बजाय अग्रेषण घोषणाओं का उपयोग केवल तभी संभव होता है जब आप स्वयं को इस प्रकार (इस फ़ाइल के दायरे में) का उपयोग करने का इरादा नहीं रखते हैं, लेकिन इसका एक सूचक या संदर्भ

खुद को टाइप करने के लिए, संकलक को इसके आकार का पता होना चाहिए – इसलिए इसकी पूर्ण घोषणा #include इसलिए पूर्ण #include की आवश्यकता है

हालांकि, पॉइन्टर या संदर्भ का आकार कंपाइलर के लिए जाना जाता है, पॉइंट के आकार की परवाह किए बिना, इसलिए आगे की घोषणा पर्याप्त है – यह एक प्रकार पहचानकर्ता नाम की घोषणा करता है।

दिलचस्प बात यह है कि जब पॉइंटर या class या struct प्रकार के संदर्भ का इस्तेमाल किया जाता है, तो कंपाइलर अपूर्ण प्रकारों को संभाल सकता है जिससे आपको पॉइन्टेई प्रकारों को भी अग्रेषित करने की आवश्यकता होती है:

 // header.h // Look Ma! No forward declarations! typedef class A* APtr; // class A is an incomplete type - no fwd. decl. anywhere typedef class A& ARef; typedef struct B* BPtr; // struct B is an incomplete type - no fwd. decl. anywhere typedef struct B& BRef; // Using the name without the class/struct specifier requires fwd. decl. the type itself. class C; // fwd. decl. type typedef C* CPtr; // no class/struct specifier typedef C& CRef; // no class/struct specifier struct D; // fwd. decl. type typedef D* DPtr; // no class/struct specifier typedef D& DRef; // no class/struct specifier 

मेरे पास एक ही मुद्दा था, विभिन्न फाइलों में कई टाइप-फेफ्स के साथ गड़बड़ नहीं करना चाहता था, इसलिए मैंने इसे विरासत से हल किया:

था:

 class BurstBoss { public: typedef std::pair<Ogre::ParticleSystem*, bool> ParticleSystem; // removed this with... 

किया:

 class ParticleSystem : public std::pair<Ogre::ParticleSystem*, bool> { public: ParticleSystem(Ogre::ParticleSystem* system, bool enabled) : std::pair<Ogre::ParticleSystem*, bool>(system, enabled) { }; }; 

एक जादू की तरह काम किया। बेशक, मुझे इसके बारे में कोई भी संदर्भ बदलना पड़ा

 BurstBoss::ParticleSystem 

बस के लिए

 ParticleSystem 

जैसा कि बिल कोत्सियास ने उल्लेख किया था, निजी पॉइंट के टाइप टाइप किए गए ब्योरे को रखने का एकमात्र उचित तरीका है, और उन्हें यह बताएं कि विरासत के साथ है आप इसे C ++ 11 के साथ थोड़ा अच्छा कर सकते हैं हालांकि। इस पर विचार करो:

 // LibraryPublicHeader.h class Implementation; class Library { ... private: Implementation* impl; }; 
 // LibraryPrivateImplementation.cpp // This annoyingly does not work: // // typedef std::shared_ptr<Foo> Implementation; // However this does, and is almost as good. class Implementation : public std::shared_ptr<Foo> { public: // C++11 allows us to easily copy all the constructors. using shared_ptr::shared_ptr; };