在 init 方法中绕过 const

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 对象，我无法初始化这些对象，因为 C++ 不支持数组成员的初始化程序。 （再次，请参阅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

这样的东西会有帮助吗？您仍然可以故意违反 constness，但它可以防止普通人犯愚蠢的错误（我还没有编译过）。

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

好吧...可能不如真正的数组高效...不过，您总是可以使用预处理器生成：

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>