स्वत: संदर्भ खाका

Question

क्या मैं इस काम करने के लिए कर सकते हैं:

template<class C, class V, Test V::*> 
class Test { 
}; 

यह मेरे संकलक त्रुटि देता है:

unknown type name 'Test' 

यह अब के लिए एक स्वयं को संदर्भित टेम्पलेट है, जो नहीं करता है संभव प्रतीत नहीं होता है। इसे काम करने के लिए संभवतः क्या किया जा सकता है?

संपादित करें:

यहां मुझे इसकी आवश्यकता होगी। मैं कम से कम न्यूनतम कोडिंग प्रयास के साथ एक द्वि-दिशात्मक (सोच माता-पिता) संबंध स्कीमा को कार्यान्वित करना चाहता हूं।

template <class O, class T, Reference<T, O, Reference O::*> T::* opposite> 
class Reference 
{ 
    T **data; 
    int count; 
public: 
    Reference(): data(new T*[N]), count(0) {} 
    ~Reference() {delete[] data;} 
    Reference &add(T *t) { 
     handleOtherSide(); 
     return link(t); 
    } 
    // a lot of stuff to implement this 
}; 

यह संग्रह वर्ग है। यह इस प्रकार से इस्तेमाल किया जाएगा है:

class Partner 
{ 
public: 
    Reference<Partner, Address, &Address::partner> addresses; 
}; 

class Address 
{ 
public: 
    Reference<Address, Partner, &Partner::addresses> partner; 
}; 

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

इस बारे में सोचने का सबसे आसान तरीका boost :: bimap है। लेकिन बिमप के साथ समस्या यह है कि मैं संलग्न बिमप नहीं चाहता बल्कि सिर्फ बाएं और दाएं हिस्से को चाहता हूं। बिमाप भी व्यवहार्य नहीं है क्योंकि इससे एक विशिष्ट रिश्ते के सभी संगठनों का प्रबंधन करने वाला एक ही बिमाप होता है। यह संभवत: उस पर संचालन को धीमा करने वाली बड़ी संख्या में ऑब्जेक्ट्स रखेगा।

Answer 1

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

समाधान टेम्पलेट से बचने के लिए संदर्भ संदर्भ सदस्यों या ओओ स्टाइल बेस क्लास या बूस्ट :: किसी स्टाइल कंटेनर का उपयोग करना है। बाद के 2 के साथ मूल्यवान सदस्यों के लिए संभव हो सकता है।

Answer 2

क्या आप इस तरह कुछ ढूंढ रहे हैं? यह न स्वयं को संदर्भित टेम्पलेट है, लेकिन आप आधार वर्ग और आधार वर्ग के लिए एक टेम्पलेट प्रकार व्युत्पन्न तरीकों आदि .:

template< typename PType, typename PDerived > 
class TBase 
{ 
    //do stuff with TDerived 
public: 
    bool foo(void) 
    { 
    return (static_cast< PDerived* > (this)->bar()); 
    } 
}; 

template< typename PType > 
class TDerived : public TBase< PType, TDerived<PType> > 
{ 
    friend class TBase< PType, TDerived<PType> > ; 
    //do stuff 
protected: 
    bool bar(void) 
    { 
    return (true); 
    } 
}; 

संपादित करें कॉल कर सकते हैं के रूप में व्युत्पन्न वर्ग निर्दिष्ट कर सकते हैं: अपने अंतिम क्या एक बार फिर, मैं नहीं यकीन लक्ष्य। यहां मुझे लगता है कि आप जो चाहते हैं उसके लिए एक समाधान है, या, कम से कम, कुछ संकेत जो आप अपने डिजाइन को लागू करने के लिए उपयोग कर सकते हैं। मैंने जो एकमात्र आवश्यकता है वह यह है कि TAddress और TPartner दोनों एक ही नाम से कार्य करते हैं। देखें कि क्या आपको इसकी आवश्यकता है। सिद्धांत रूप में, आप एक सहायक वर्ग बना सकते हैं और एक सूचक के माध्यम से सदस्य फ़ंक्शन तक पहुंचने के लिए सीआरटीपी का उपयोग कर सकते हैं, लेकिन मुझे नहीं लगता कि आपको वास्तव में इसकी आवश्यकता है।

template< typename PType1, typename PType2 > 
class TReference 
{ 
public: 
    int mFlag; 

    TReference() : 
    mFlag(0) 
    { 
    } 
    TReference(int fFlag) : 
    mFlag(fFlag) 
    { 
    std::cout << "Creating reference " << PType1::sName << " -> " << PType2::sName << "." << std::endl; 
    } 
    TReference< PType2, PType1 > AccessOpposite(void) 
    { 
    PType2 lTmp; 
    lTmp.Opposite(); 

    return TReference< PType2, PType1 > (-1); 
    } 
}; 

class TPartner; 

class TAddress 
{ 
public: 
    static const char* sName; 
    TReference< TAddress, TPartner > mRef; 

    void Opposite(void) 
    { 
    std::cout << sName << "::Opposite" << std::endl; 
    } 
}; 

class TPartner 
{ 
public: 
    static const char* sName; 
    TReference< TPartner, TAddress > mRef; 

    TReference< TAddress, TPartner > Opposite(void) 
    { 
    std::cout << sName << "::Opposite" << std::endl; 
    } 
}; 

const char* TAddress::sName = "TAddress"; 
const char* TPartner::sName = "TPartner"; 

int main(void) 
{ 
TAddress lAddress; 
TPartner lPartner; 

std::cout << lAddress.mRef.mFlag << " " << lPartner.mRef.mFlag << std::endl; 

lPartner.mRef = lAddress.mRef.AccessOpposite(); 

std::cout << lAddress.mRef.mFlag << " " << lPartner.mRef.mFlag << std::endl; 

return (0); 
}