在C ++中动态分配指向数组的指针

Question

I have long used pointers to arrays in C programs of the form:

int (*myarray)[2] = (int (*)[2]) malloc(n*sizeof(int[2]));

However, how can I do this in C++ using new? Can I do this?

int (*myarray)[2] = (int (*)[2]) new int[n][2];

EDIT:

Looks like my original post was incomplete and confusing. Here is a code snippet that I compiled and tested which appears to do the right thing but I wanted to confirm from C++ experts that I was using an appropriate C++ construct.

#include <iostream>

int main() {

  int n=5;
  int (*A)[2] = new int[n][2];

  for (int i = 0; i < n; i++)
    for (int j = 0; j < 2; j++)
      A[i][j] = 2*i+j;

  for (int i = 0; i < n; i++)
    std::cout << A[i][0] << " " << A[i][1] << "\n";

  delete myarray;

}

Answer 1

The joys of using C++ and STL is you get a vector class that provides array like behaviour. This also makes it easier to manage and read...

std::vector< std::vector<int> > myarray(n);

If you don't want to use the STL then there is always...

typedef int intarray[2];
intarray* ints = new intarray[n];
ints[0][0] = 1;
...
ints[n-1][1] = 6;

I personally would write an extra line of code if it made the code easier to read.

Answer 2

I think the clearest way to do what you ask for is to use a typedef for the array:

typedef int array_t[2];
array_t* yourarray = new array_t[n];

Don't do that though, because it requires doing manual memory management and that tends to be tedious, error-prone and brittle, in particular with respect to exception safety. Instead, take a look at the std::array class template (new in C++11, but otherwise available via Boost) and at the std::vector class template.

To clarify the different between storing std::vector and std::array in a container, the latter is typically more efficient when there is a small and fixed number of elements involved. The reason is that the array class doesn't allocate things dynamically as the vector does. For that, vector needs three pointers (beginning, end of used storage and end of allocated storage) plus of course the storage for the data itself (plus maybe some overhead induced by the allocator) all of which need to be loaded into the CPU cache for use. Considering an LP64 system, that would require 32 bytes to store 8 bytes of data, compared to just 8 bytes using std::array .