consiguiendo const en un método init

Question

Así que yo can't use initializers in my class constructor debido al uso de matrices, así que decidí usar un método init() en su lugar. Ahora tengo un problema diferente. Tengo una clase como esta:

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

donde tengo que poner en práctica init() inicializando regs = _regs; pero no puede debido a la const. ¿Hay alguna manera de forzar la asignación en mi método init? Me gustaría conservar la palabra clave const para no reasignarla accidentalmente a otra parte.

edición: tanto como me gustaría utilizar un constructor + inicializador, lo que resolvería este problema (mi código utilizado para hacer esto), no puedo porque tengo otra clase que tiene una matriz de objetos EPWM, y no puedo inicializar esos objetos porque C++ no admite los inicializadores para los miembros de la matriz. (De nuevo, ver the other question I asked a little while ago on this subject.)

Contexto para el uso de EPWM es algo como esto:

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

Usted podría considerar const_cast y punteros, pero es algo que utiliza mejor muy raramente. Algo así como ...

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

Answer 2

Utilice un constructor de esta manera:

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

Después, simplemente no tienen params en init:

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

En otras palabras, se puede inicializar todo en el constructor de clase - simplemente no matrices miembros.

Answer 3

¿Qué tal lo siguiente?

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

¿Le sirve algo así? Todavía puede violar intencionalmente la constness pero evita que la gente normal cometa errores tontos (no lo he compilado).

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

haciendo de abogado del diablo: además de la documentación intención obvia, ya que es un atributo privado, podría perfectamente no utilizar la palabra clave const y no modificarlo aparte del método init.

Su const_cast podría ser un comportamiento indefinido aquí, y ciertamente prefiero no correr en esas esquinas oscuras, cualesquiera que sean las soluciones.

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

Aunque, volver a su pregunta: mientras que una serie raw no puede ser construido default, puede escribir una clase de matriz que puede ser.

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... 

bien ... tal vez no sea tan eficiente como una matriz de verdad ... siempre se puede recurrir a la generación de preprocesador sin embargo:

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>