गैर-सदस्य रूपांतरण कार्य; विभिन्न प्रकार कास्टिंग, उदा। ओपनजीएल वेक्टर

Question

पर डायरेक्टएक्स वेक्टर वर्तमान में मैं एक गेम "इंजन" पर काम कर रहा हूं जिसे 3 डी इंजन, भौतिकी इंजन और एक स्क्रिप्टिंग भाषा के बीच मूल्यों को स्थानांतरित करने की आवश्यकता है। चूंकि मुझे भौतिकी इंजन से 3 डी ऑब्जेक्ट्स में वैक्टर लागू करने की आवश्यकता होती है और अक्सर 3 डी को नियंत्रित करने में सक्षम होना चाहते हैं, साथ ही भौतिकी स्क्रिप्टिंग सिस्टम के माध्यम से ऑब्जेक्ट्स को ऑब्जेक्ट करने की आवश्यकता है, मुझे एक प्रकार के वेक्टर को बदलने के लिए एक तंत्र की आवश्यकता है (उदाहरण के लिए vector3d<float>) दूसरे प्रकार के वेक्टर (उदाहरण के लिए btVector3)। दुर्भाग्य से मैं इस बात पर कोई धारणा नहीं कर सकता कि वर्ग/structs कैसे निर्धारित किए जाते हैं, इसलिए एक साधारण reinterpret_cast शायद नहीं करेगा।

तो सवाल यह है: अभी इस के बाद से कास्टिंग ऑपरेटरों सदस्य तरीकों की जरूरत है संकलन नहीं होगा

vector3d<float> operator vector3d<float>(btVector3 vector) { 
    // convert and return 
} 

btVector3 operator btVector3(vector3d<float> vector) { 
    // convert and return 
} 

: वहाँ मूल रूप से इस लक्ष्य को हासिल करने के लिए 'स्थिर'/गैर-सदस्य कास्टिंग विधि के कुछ प्रकार है । (error C2801: 'operator foo' must be a non-static member)

Answer 1

मैं उन्हें मुक्त कार्यों की एक जोड़ी के रूप में लिख रहा है (यानी उन्हें 'ऑपरेटरों' बनाने के बारे में चिंता मत करो) सुझाव है:

vector3d<float> vector3dFromBt(const btVector3& src) { 
    // convert and return 
} 

btVector3 btVectorFrom3d(const vector3d<float>& src) { 
    // convert and return 
} 

void f(void) 
{ 
    vector3d<float> one; 
// ...populate... 
    btVector3 two(btVectorFrom3d(one));  
// ... 
    vector3d<float> three(vector3dFromBt(two)); 
} 

Answer 2

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

// header: 
class ConvertibleVector3d; 

ConvertibleBtVector : public btVector3 
{ 
    operator ConvertibleVector3d() const; 
} 

ConvertibleVector3d : public vector3d<float> 
{ 
    operator ConvertibleBtVector() const; 
} 

//impl: 
ConvertibleBtVector::operator ConvertibleVector3d() const 
    { 
    ConvertibleVector3d retVal; 
// convert this into retVal... 
    return retVal; 
    } 

ConvertibleVector3d::operator ConvertibleBtVector() const; 
    { 
    ConvertibleBtVector retVal; 
// convert this into retVal... 
    return retVal; 
    } 

void f(void) 
{ 
    ConvertibleVector3d one; 
// ...populate... 
    ConvertibleBtVector two(one);  
// ... 
    ConvertibleVector3d three; 
    three = two; 
} 

नाम थोड़ा वर्बोज़ हैं, लेकिन उम्मीद है कि मंशा स्पष्ट है।

सार्वजनिक विरासत का अर्थ है कि आपको बेस क्लास के समान ही इन वर्गों के उदाहरणों का उपयोग करने में सक्षम होना चाहिए, सिवाय इसके कि वे एक-दूसरे से असाइन करने योग्य और रचनात्मक होंगे। बेशक यह दो वर्गों को जोड़ता है, लेकिन यह स्वीकार्य हो सकता है क्योंकि ऐसा लगता है कि आपका एप्लिकेशन वैसे भी करना चाहता है।

Answer 3

तुम भी तरह एक टेम्प्लेटेड आवरण वर्ग इस्तेमाल कर सकते हैं:

template<class V> 
class vector_cast {}; 

template<> 
class vector_cast<vector3d> { 
    const vector3d& v; 

public: 

    vector_cast(const vector3d& v) : v(v) {}; 

    operator vector3d() const { 
    return vector3d(v); 
    } 

    operator btVector3() const { 
    // convert and return 
    } 
}; 

template<> 
class vector_cast<btVector3> { 
    const btVector3& v; 

public: 

    vector_cast(const btVector3& v) : v(v) {}; 

    operator btVector3() const { 
    return btVector3(v); 
    } 

    operator vector3d() const { 
    // convert and return 
    } 
}; 

उपयोग:

void set_origin(btVector3 v); 

// in your code: 

vector3d v; 
// do some fancy computations 
set_origin(vector_cast(v)); 

// --- OR the other way round --- // 

void set_velocity(vector3d v); 

// in your code: 

btVector3 v; 
// do some other computations 
set_velocity(vector_cast(v));