c – 如何访问和管理块存储数据

* cell_member1 [cell0] .. cell_member1 [cellN] … cell_memberM [cell0] .. cell_memberM [cellN] *

然后我需要有效地访问这些数据,如果可能的话,使用一个很好的语法.如果我能够轻松地定义要存储的数据,那将是很好的,即通过定义一个对象作为我想要存储的数据并将其传递给为我做一切的“魔术”.

动机：为什么我需要这样做？缓存垃圾.在一些内部循环中,仅访问对象的一些成员.使用未使用的内存浪费一半缓存行不是我的应用程序的选项.我可以在指向某个顺序内存区域的对象中存储指针.这会浪费内存并迫使我在这个区域使用不同的语法.

我目前是怎么做的：我有一个容器：

template<class T> struct Container {
  char* data;
  Container(const int n) {
    data = new char[n*T::spaceRequirements()]; //< Data stored "block-wise"
    new(data) typename T::Flags[n]; //< Flags stored "cell-wise"
  }
  /// Destructor ommited for briefness.
};

我存储了T类型的一些单元格的数据.我需要每个单元格一些标记,现在我使用std :: bitset来存储它们,这意味着我需要以单元格形式存储这些位集：

* cell_member1 [cell0] … cell_memberM [cell0] … cell_member1 [cellN] .. cell_memberM [cellN] *

我在描述每个单元需要在下面的类中存储多少数据,这也提供了对数据的访问：

template<int nd> struct CellAccessor {
  /// Cell flags are stored cell-wise:
  typedef std::bitset<64> Flags;
  enum { DELETE = 0,///< Cell marked for deletion
         REFINE = 1 ///< Cell marked for refinement
         //...
  }; ///< Enum for the flags.
  static inline Flags& flags(const int cellId) {
    return *reinterpret_cast<Flags*>(data + sizeof(Flags)*cellId); }
  template<int pId> static inline Flags::reference flags(const int cellId) {
    return flags(cellId)[pId]; } //< Cell-wise access to the properties

  /// The rest of the data is stored block-wise:
  static inline int& order(const int cellId) { ///< One int field.
    return *reinterpret_cast<int*>
        (data + maxNoCells*sizeof(Flags) + sizeof(int)*cellId);}

  /// Coordinate vector with nd components:
  static inline double& coordinates(const int cellId,const int i) {
    return *reinterpret_cast<double*>
        (data + maxNoCells*(sizeof(Flags)+sizeof(int))
         + maxNoCells*i*sizeof(double) + sizeof(double)*cellId); }
  template<int i> static inline double& coordinates(const int cellId) {
    return *reinterpret_cast<double*>
        (data +maxNoCells*(sizeof(Flags)+sizeof(int)+i*sizeof(double))
         + sizeof(double)*cellId); }

  /// Total amount of memory to allocate per cell: (used by Container)
  static inline int spaceRequirements() { return
        sizeof(Flags) // Flags
        + sizeof(int) // order
        + nd*sizeof(double) // coordinates
        ;}

  /// Constructor gets pointer to the beginning of the container 
  /// and the offset for the member variables:
  CellAccessor(char* d,int n){data = d; maxNoCells = n;}
 private:
  static char* data;  ///< Pointer to the beginning of the container.
  static int maxNoCells;  ///< Cell offset for the member variables.
};
template<int nd> char* CellAccessor<nd>::data = nullptr;
template<int nd> int CellAccessor<nd>::maxNoCells = 0;

我这样使用它：

int main() {
  int maxNoCells = 10000;   ///< Maximum number of cells (=cell offset).
  typedef CellAccessor<2> A;
  Container< A > cellData(maxNoCells);  ///< Allocate cell data.
  A cells(cellData.data,maxNoCells);  ///< Provides access to cell data.

  for(int i = 0; i < maxNoCells; ++i){
    cells.flags<A::DELETE>(i) = i%2==0 ? true : false;
    cells.flags<A::REFINE>(i) = i%2==0 ? false : true;
    cells.coordinates(i,0) = i;
    cells.coordinates<1>(i) = -((double)i);
    cells.order(i) = 2;
  }
}

优点：

>数据采用块状,这就是我所需要的.
>语法还可以.

问题：

>我的课程做得太多了：为用户提供数据访问权限,提供需要为容器存储多少数据,提供如何为我的数据结构(树木等)移动/复制/交换数据. .)…
>没有迭代器,我不能使用STL算法.我已经通过使迭代器存储单元索引并重新实现其中的CellAccessor类来实现迭代器(糟糕！干！).
> Bitset仍然以单元格形式存储.我可以为我的块方式数据结构重新实现bitset …
> data和maxNoCells是静态变量,但如果需要,我可以使它们成为正常的成员变量.

问题：是否有任何有效的方法以块方式存储“对象”(或我们在概念上通过对象理解的内容)并访问它们,就像它们存储在诸如vector之类的std容器中一样？