Double pointer arithmetic - c++

Question

I have a 2D matrix
matrix[m][n];
I know that matrix is a double pointer with type int**. I would like to obtain a double pointer pointing to a submatrix of the original matrix. For example, I want the submatrix to start for cell (1,1). How do I get such a double pointer from the original matrix[m][n]?

Answer 1

I know that matrix is a double pointer with type int**.
No, you don't. Arrays are not pointers. If you declared it as int matrix[m][n];, then the type of the expression matrix is int [m][n]; unless matrix is the operand of the sizeof or unary & operators, it will have its type converted ("decay") to int (*)[n] (pointer to n-element array of int).
The problem is that you can't create arbitrary submatrices by just declaring a pointer of the right type; C and C++ don't provide an easy way to "slice" arrays this way. You can certainly create a pointer of type int (*)[n-1] and assign the value of &matrix[1][1] to it (with an appropriate cast), but it won't do what you want.
EDIT
Now that I have a real keyboard in front of me I can expand on this a little bit.
Let's imagine a 3x3 matrix declared as follows:
int m[3][3] = {{0,1,2},{3,4,5},{6,7,8}};
We normally visualize such a matrix as
+---+---+---+
| 0 | 1 | 2 |
+---+---+---+
| 3 | 4 | 5 |
+---+---+---+
| 6 | 7 | 8 |
+---+---+---+
In C and C++, 2-dimensional arrays are laid out in row-major order1, 2, so the above matrix would be represented in memory as
+---+
m: | 0 | m[0][0]
+---+
| 1 | m[0][1]
+---+
| 2 | m[0][2]
+---+
| 3 | m[1][0]
+---+
| 4 | m[1][1]
+---+
| 5 | m[1][2]
+---+
| 6 | m[2][0]
+---+
| 7 | m[2][1]
+---+
| 8 | m[2][2]
+---+
So suppose you want the 2x2 submatrix starting at m[1][1]:
+---+---+---+
| 0 | 1 | 2 |
+---+---+---+
| 3 | +---+---+
+---+ | 4 | 5 |
| 6 | +---+---+
+---+ | 7 | 8 |
+---+---+
That corresponds to the following array elements:
+---+
m: | 0 | m[0][0]
+---+
| 1 | m[0][1]
+---+
| 2 | m[0][2]
+---+
| 3 | m[1][0]
+---+
+---+
| 4 | m[1][1]
+---+
| 5 | m[1][2]
+---+
+---+
| 6 | m[2][0]
+---+
+---+
| 7 | m[2][1]
+---+
| 8 | m[2][2]
+---+
That's not a contiguous subarray within m, so just declaring a pointer and setting it to &m[1][1] won't do what you really want. You'll need to create a separate matrix object and copy the elements you want to it:
int subm[2][2] = {{m[1][1], m[1][2]}, {m[2][1], m[2][2]}};
You can write a function to grab a 2x2 "slice" of your matrix like so:
void slice2x2( int (*mat)[3], int (*submat)[2], size_t startx, size_t starty )
{
for ( size_t i = 0; i < 2; i++ )
for ( size_t j = 0; j < 2; j++ )
submat[i][j] = mat[startx + i][starty + j];
}
int main( void )
{
int matrix[3][3] = {{0,1,2},{3,4,5},{6,7,8}};
int submat[2][2];
slice2x2( matrix, submat, 1, 1 );
// do something with submat
}
Pre-publication draft of the C 2011 standard, §6.2.5.1, ¶3.
Pre-publication draft of the C++ 2014 standard, §8.3.4, ¶9

Answer 2

A matrix defined as 2D array of constant size:
int matrix [m][n];
is stored as m contiguous blocks of n elements. You can therefore imagine this technically as a flat sequence of m*n elements in memory. You can use pointer arithmetic to find the start of a row, or to find a specific element. But you can't locate a submatrix int that way.
The "double" pointer:
int **pmatrix;
obeys a different logic: it is a pointer to a pointer and works as an array of m pointers pointing at lines of n consecutive elements. So your elements are not necessarily consecutive. You can use pointer arithmetic and indirection to locate the start of a row or a specific item. But again this can't address a submatrix.
Both matrix and pmatrix can be used with 1D or 2D indexing, but the compiler generates different code to address the elements.
For getting sub-matrices you have to make iterations to find the right elements, using vertical and horizontal offsets, but you can't imagine to pass somehow a pointer to the sub-matrix if you don't copy the right elements in a new matrix of target's size.