एक इनिट विधि

Question

में चारों ओर घूम रहा है इसलिए मैं can't use initializers in my class constructor सरणी का उपयोग करने के कारण, इसलिए मैंने init() विधि का उपयोग करने का निर्णय लिया। अब मुझे एक अलग समस्या है। मैं इस तरह एक वर्ग है:

class EPWM { 
private: 
    volatile EPWM_REGS* const regs; 
public: 
    void init(volatile EPWM_REGS* _regs); 
}; 

जहाँ मैं regs = _regs; आरंभ से init() लागू करने की आवश्यकता है, लेकिन मैं const नहीं की वजह से कर सकते हैं। क्या मेरे init विधि में असाइनमेंट को मजबूर करने का कोई तरीका है? मैं const कीवर्ड रखना चाहता हूं इसलिए मुझे गलती से कहीं और पुन: असाइन नहीं किया गया है।

संपादित करें: के रूप में ज्यादा के रूप में मैं (मेरे कोड यह करने के लिए प्रयोग किया जाता) एक निर्माता + प्रारंभकर्ता उपयोग करने के लिए है, जो इस समस्या का समाधान होगा चाहते हैं, मैं नहीं कर सकता क्योंकि मैं किसी अन्य वर्ग जो EPWM वस्तुओं की एक सरणी है है, और मैं उन वस्तुओं को प्रारंभ नहीं कर सकता क्योंकि सी ++ सरणी सदस्यों के लिए प्रारंभकर्ताओं का समर्थन नहीं करता है। (फिर से, the other question I asked a little while ago on this subject. देखें)

प्रसंग के लिए EPWM का उपयोग कर कुछ इस तरह है:

class PwmGroup { 
private: 
    EPWM *epwm; 

    void init(EPWM *_epwm) { epwm = _epwm; } 
}; 

/* ... */ 
// main code: 

EPWM epwm[3]; 
PwmGroup pwmGroup; 

{ 
    // EPwm1Regs, EPwm2Regs, EPwm3Regs are structs 
    // defined by TI's include files for this processor 
    epwm[0].init(&EPwm1Regs); 
    epwm[1].init(&EPwm2Regs); 
    epwm[2].init(&EPwm3Regs); 
    pwmGroup.init(epwm); 
} 

Answer 1

आप const_cast और संकेत दिए गए विचार कर सकते हैं, लेकिन यह कुछ सबसे अच्छा शायद ही कभी इस्तेमाल बहुत है। कुछ की तरह ...

EPWM_REGS** regsPP = const_cast<EPWM_REGS**>(&regs); 
*regsPP = _regs; 

Answer 2

इस तरह एक निर्माता का उपयोग करें:

EPWM::EPWM(volatile EPWM_REGS* _regs) 
    : regs(_regs) 
{} 

तब बस अपने init में कोई पैरामीटर है:

void EPWM::init() 
{ 
    // do something with this->regs here... 
} 

दूसरे शब्दों में, आप में सब कुछ आरंभ कर सकते हैं वर्ग कन्स्ट्रक्टर - बस सदस्य सरणी नहीं।

Answer 3

निम्नलिखित के बारे में कैसे?

struct EPWM_array { 
    EPWM_array() { /* initialize array */ } 
    const EPWM *begin() const; 
    const EPWM *end() const; 

    EPWM array[ 10 ]; 
}; 

struct EPWMWrapper { 
    volatile EPWM_REGS* const regs; 
    EPWMWrapper(EPWM_array const& a) : regs(a.begin()) {} 
}; 

Answer 4

क्या यह कुछ मदद चाहिए? आप अभी भी जानबूझकर स्थिरता का उल्लंघन कर सकते हैं लेकिन यह सामान्य लोगों को मूर्खतापूर्ण गलतियों से रोकता है (मैंने इसे संकलित नहीं किया है)।

class EPWM { 
private: 
    volatile EPWM_REGS* regs_for_init_never_use; 
    volatile EPWM_REGS* const& regs; 
public: 
    EPWM() : regs(regs_for_init_never_use) 
    void init(volatile EPWM_REGS* _regs); 
}; 

Answer 5

डेविल्स एडवोकेट बजाना: स्पष्ट प्रलेखन के इरादे से अलग है, क्योंकि यह एक निजी विशेषता है, तो आप पूरी तरह से const कीवर्ड का उपयोग नहीं कर सकता है और init विधि से अलग इसे संशोधित नहीं।

आपका const_cast वास्तव में यहाँ व्यवहार अपरिभाषित हो सकता है, और मैं निश्चित रूप से उन अंधेरे कोनों, जो कुछ भी समाधान में चलाने के लिए नहीं पसंद करते हैं।

class EPWM { 
private: 
    volatile EPWM_REGS* regs; // normally const, but need to be inited :/ 
public: 
    void init(volatile EPWM_REGS* _regs); 
}; 

हालांकि, आपके सवाल फिर से मिलना: जबकि एक raw सरणी जा निर्माण नहीं कर सकती है आप एक सरणी वर्ग कि हो सकता है लिख सकते हैं।

namespace detail 
{ 
    template <class T, size_t N, size_t index> 
    struct At 
    { 
    static T& Do(Array<T,N>& array) 
    { 
     return At<T,N-1,index-1>::Do(array.tail()); 
    } 
    }; 

    template <class T, size_t N> 
    struct At<T,N,0> 
    { 
    static T& Do(Array<T,N>& array) { return array[0]; } 
    }; 

    template <class T, size_t index> 
    struct At<T,0,index> {}; 

    template <class T> 
    struct At<T,0,0> {}; 
} // namespace detail 


template <class T, size_t N> 
class array 
{ 
public: 
    typedef T value_type; 
    static const size_t Length = N; 

    array(): mHead(), mTail() {} 
    array(const array& rhs): mHead(rhs.mHead), mTail(rhs.mTail) {} 

    // Don't know whether it will be optimized or not 
    // Not sure I can use pointer arithmetic either :p 
    T& operator[](size_t index) { return index == 0 ? mHead : mTail[index-1]; } 

    // Compile time access 
    template <size_t index> 
    T& at() { return detail::At< T, N, index >::Do(*this); } 

private: 
    T mHead; 
    array<T, N-1> mTail; 
}; // class array<T,N> 

template <class T> 
class array<T,1> 
{ 
public: 
    typedef T value_type; 
    static const size_t Length = 1; 

    array(): mHead() {} 
    array(const array& rhs): mHead(rhs.mHead) {} 

    T& operator[](size_t index) { return mHead; } // or error handling ;) 

private: 
    T mHead; 
}; // class array<T,1> 

template <class T> class array<T,0> {}; // int[0] does not work (stack) so... 

ठीक है ... शायद के रूप में एक वास्तविक सरणी के रूप में कुशल नहीं है ... तुम हमेशा पीढ़ी Preprocessor हालांकि चालू कर सकते हैं:

template <class T> 
class Array4 
{ 
public: 
    Array4(): m0(), m1(), m2(), m3() {} 
    Array4(const Array4& rhs): m0(rhs.m0), m1(rhs.m1), m2(rhs.m2), m3(rhs.m3) {} 

    T& operator[](size_t index) { return *(&m0 + index); } 

private: 
    T m0; 
    T m1; 
    T m2; 
    T m3; 
}; // class Array4<T>