如何使用此特定容器在C ++中创建2D数组

Question

我正在尝试移植
int a[][]
从Java到C ++。 我将此类用作int的ArrayRef容器，因为它处理引用，并且项目广泛使用它。 在AbstractReader类中，我声明了

const ArrayRef<int> START_END_PATTERN_;
const ArrayRef<int> MIDDLE_PATTERN_;
const ArrayRef<ArrayRef<int> > L_PATTERNS_;
const ArrayRef<ArrayRef<int> > L_AND_G_PATTERNS_;

和

static int START_END_PATTERN[];
static int MIDDLE_PATTERN[];
static int L_PATTERNS[10][4];
static int L_AND_G_PATTERNS[20][4];
请注意在结尾的下划线以区分这两个变量。

我不确定如何初始化二维ArrayRef。 我在这里发布的内容会出现段错误，因为这些ArrayRef在堆栈中分配。 有人有聪明的办法吗？

我实际上设法使其正常工作的唯一方法是使用ArrayRef< Ref<ArrayRef<int> > > >>>，使ArrayRef继承自Counted，这基本上是一个允许在C ++中进行引用计数的类。 但是，为了访问元素，我必须做类似*（foo [i]）[j]的操作，它比foo [i] [j]稍微有点讨厌。

int AbstractReader::L\_AND\_G_PATTERNS[20][4] = {

 {3, 2, 1, 1}, // 0
 {2, 2, 2, 1}, // 1
 {2, 1, 2, 2}, // 2
 {1, 4, 1, 1}, // 3
 {1, 1, 3, 2}, // 4
 {1, 2, 3, 1}, // 5
 {1, 1, 1, 4}, // 6
 {1, 3, 1, 2}, // 7
 {1, 2, 1, 3}, // 8
 {3, 1, 1, 2},  // 9
 // G patterns

 {1, 1, 2, 3}, // 0
 {1, 2, 2, 2}, // 1
 {2, 2, 1, 2}, // 2
 {1, 1, 4, 1}, // 3
 {2, 3, 1, 1}, // 4
 {1, 3, 2, 1}, // 5
 {4, 1, 1, 1}, // 6
 {2, 1, 3, 1}, // 7
 {3, 1, 2, 1}, // 8
 {2, 1, 1, 3}  // 9
 };

 AbstractReader::AbstractReader() 
 : decodeRowStringBuffer_(ostringstream::app),
 START_END_PATTERN_(START_END_PATTERN, 3),
 MIDDLE_PATTERN_(MIDDLE_PATTERN, 5),
 L_PATTERNS_(10),
 L_AND_G_PATTERNS_(20) {

  for (int i = 0; i < 20; i++) {
   if (i < 10) {
    L_PATTERNS_[i] = ArrayRef<int> ((L_PATTERNS[i]), 4);
   }
   ArrayRef<int> lgpattern((L_AND_G_PATTERNS[i]), 4);
   L_AND_G_PATTERNS_[i] = lgpattern;
  }
 }

Answer 1

您所拥有的应该是安全的。 （分配了堆栈的） ArrayRef创建了分配堆的Array来支持它们，然后共享这些Array 。

编辑 ：感谢您发布Counted 。 做了一些工作，但我想我知道发生了什么事。

解决方案 ：不要将L_PATTERNS_或L_AND_G_PATTERNS_声明为const 。 或者， const_cast获得所需的operator[] 。 例如

const_cast<ArrayRef<ArrayRef<int> > &>(L_PATTERNS_)[i] = ArrayRef<int> ((L_PATTERNS[i]), 4);

原理 ：在AbstractReader ，您声明：

const ArrayRef<ArrayRef<int> > L_PATTERNS_;

然后，在其构造函数中，尝试进行分配：

AbstractReader::AbstractReader() :
{
    ...
    L_PATTERNS_[i] = ArrayRef<int> ((L_PATTERNS[i]), 4);
    ...
}

由于L_PATTERNS_是const ， L_PATTERNS_[i]从ArrayRef<ArrayRef<int> >调用方法：

T operator[](size_t i) const { return (*array_)[i]; }

这将返回L_PATTERNS_[i]的内容的全新副本。 然后进行分配（成为临时任务），保持原始状态不变。 当您稍后返回访问L_PATTERNS_[ xxx ] ，您正在查看的是未初始化的原始值（它是NULL引用/指针）。 因此是段错误。

令人惊讶的是ArrayRef甚至允许此分配。 当然，它打破了“最不惊奇的原则”。 人们会期望编译器发出错误。 为了确保将来对编译器更有用，我们需要给出ArrayRef的operator[] const （Array.h：121）的稍微不同的定义，例如：

const T operator[](size_t i) const { return (*array_)[i]; }

或（带有警告）：

const T& operator[](size_t i) const { return (*array_)[i]; }

进行任何更改后，编译器均不允许允许分配。 例如，GCC报告：

error: passing 'const common::ArrayRef<int>' as 'this' argument of 'common::ArrayRef<T>& common::ArrayRef<T>::operator=(const common::ArrayRef<T>&) [with T = int]' discards qualifiers

Answer 2

原因可能有几种。 例如，您没有在粘贴中包含“ Counted”类，在某些时候，将调用a-> retain（）（第130行）。 未显示此方法。