指向2或3维子数组/子矩阵的指针

Question

say you have a matrix of dimensions x per y (per z) defined like:

int** tab = new int*[x];
for(int i=0; i<x; ++i) tab[i] = new int[y];

or

int*** tab = new int**[x];
for(int i=0; i<x; ++i) {
  tab[i] = new int*[y];
  for(int j=0; j<y; ++y) tab[i][j] = new int[z];
}

is there any smart way to access sub-matrix (get int**(*) without data copying, plain C++) which will have top-left(-front) corner [a,b(,c)] and size of [A, B(,C)]?

Here are (better or worse) graphical examples of the problem.

Answer 1

You are using what is called a jagged array. It is an array of arrays, where nothing besides runtime enforces that the sub arrays are the same size. Hence jagged, because you could have the subarrays vary in size.

In order to have a submatrix that is also a jagged array, you need for there to exist a jagged array of pointers pointing at the subarrays of the submatrix. These don't exist in general, so no, you cannot do this "without copying" at least some arrays of pointers to subarrays.

Had your matrix been not jagged array based, but instead single array with stride , then views of subarrays could be created without allocating new subarray pointer arrays. Also it would be more cache friendly.

To write the non-jagged matrix, start by writing an array view or span class that handles one dimension.

For two dimensions, you augment the span class to store a tuple of dimension sizes or strides. [] instead of returning a reference to the calculated element, creates a one-dimension-lower span instance pointing at the calculated position, until the dimension 0 case where you return a reference.

This will be highly efficient, permit efficient subarrays, but requires a few dozen or 100 lines of code to get right.