Question

我需要一个2d字符数组用于垃圾API，绝对需要使用数组和非向量（非常强调这一点，因为我所有的搜索都有答案“使用向量”。我希望我能。） / p>

我认为这样做的方法是分配一个大小行*字符长度的外部数组，而不是：

(ida)

但是我不确定我需要使用什么方法来使它连续？我是否需要先分配一个海量的一维数组，然后将一维数组分配给二维数组？

Answer 1

正如其他答案所说：分配n * m个条目来创建连续数据，然后它可以用指针包装来创建一个二维数组。

...绝对需要使用数组而不是矢量......

我不确定vector是否是基于所使用的API或要求的约束 - 但值得注意的是vector 可以用于实现的内存管理 - 同时仍然使用原始数据（可以由&vec[0]或vec.data()访问，它返回指向数组的第一个元素，可以与接受原始指针的函数一起使用。）

由于这个问题是关于c ++的，因此一个选项是在n * m中将class数组包装成行为，就像二维数组一样，实际上是连续的。

一个简单的例子可能是：

class array_2d
{
public:

   array_2d( std::size_t rows, std::size_t columns )
     : m_rows(rows), m_cols(columns), m_array( new char[rows * columns] )
   {
   }

   ~array_2d()
   {
       delete [] m_array;
   }

   // row-major vs column-major is up to your implementation
   T& operator()( std::ptrdiff_t row, std::ptrdiff_t col )
   {
      // optional: do bounds checking, throw std::out_of_range first

      return m_array[row * m_cols + col];
      // alternatively:
      // return m_array[col * m_rows + row];
   }

   // get pointer to the array (for raw calls)
   char* data()
   {
     return m_array;
   }

private:

   char* m_array; 
   std::size_t m_rows;
   std::size_t m_cols;
};

（理想情况下char*为std::unique_ptr<char[]>或std::vector<char>以避免内存泄漏情况，但由于您说vector不可行，我写这篇文章最低限度）

此示例重载调用运算符（operator()） - 但这也可以是at(...)之类的命名函数;选择取决于你。这种类型的使用将是：

auto array = array_2d(5,5); // create 5x5 array
auto& i01 = array(0,1); // access row 0, column 1

可选地，如果[][]语法对于行为类似于2d数组（而不是(r,c)语法）很重要，则可以从调用返回代理类型到重载{{1} }（未经测试）：

operator []

这样可以让您拥有正常的＆＃39; 2d阵列语法，但仍然是连续的：

class array_2d_proxy
{
public:
   array_2d_proxy( char* p ) : m_entry(p){}

   char& operator[]( std::ptrdiff_t col ){ return m_entry[col]; }

private:

   char* m_entry;
};

class array_2d
{
  ...
  array_2d_proxy operator[]( std::ptrdiff_t row )
  {
    return array_2d_proxy( m_array + (row * m_cols) );
  }
  ...
};

Answer 2

这是一个很好的方法：

void array2d(int m, int n) {
    std::vector<char>  bytes(m * n);
    std::vector<char*> arrays;
    for (int i = 0; i != m * n; i += n) {
        arrays.push_back(bytes.data() + i);
    }
    char** array2d = arrays.data();
    // whatever
}

Answer 3

C ++中“具有可变列长度的连续2d数组”的主要问题是像myArray[r][c]这样的访问要求编译器在编译时知道myArray 类型的列大小时间（与C不同，C ++不支持可变长度数组（VLA））。

为了克服这个问题，你可以分配一个连续的字符块，并另外创建一个指针数组，其中每个指针指向一行的开头。通过这样的“视图”，您可以使用myArray[r][c] - 符号来间接地处理连续的内存块：

int main() {

    // variable nr of rows/columns:
    int rows = 2;
    int columns = 5;

    // allocate continuous block of memory
    char *contingousMemoryBlock = new char[rows*columns];

    // for demonstration purpose, fill in some content
    for (int i=0; i<rows*columns; i++) {
        contingousMemoryBlock[i] = '0' + i;
    }

    // make an array of pointers as a 2d-"view" of the memory block:
    char **arr2d= new char*[rows];
    for (int r=0; r<rows;r++) {
        arr2d[r] = contingousMemoryBlock + r*columns;
    }

    // access the continuous memory block as a 2d-array:
    for (int r=0; r<rows; r++) {
        for (int c=0; c<columns; c++) {
            cout << arr2d[r][c];
        }
        cout << endl;
    }
}

如何在C ++中动态分配连续的2D数组？

3 个答案: