How to pass a two-dimensional array created on the stack to a function that accepts an int **?

1. You cannot know exactly where tmp will be created, and where memory is allocated for its elements. The compiler can write something in registers, something in a heap, something in a stack, there are no guarantees.

   UPD: we are talking about the fact that the expression int tmp [3] [3] does not guarantee that the memory will be allocated on the stack.

2. Contrary to sensations, N-dimensional arrays, where N> 1 in C / C ++ are not equivalent to a pointer to a pointer (N times). This is due to the fact that tmp[3][3] is of type int tmp[][3] / int (*tmp)[3] and is actually in memory in one array, 9 int. Long.

   Those. int[3][3] in memory is like this: int[3] int[3] int[3] , and each of int[3] is in memory as an int int int

As a result, these are just different data types. And casting to int** , even through reinterpret_cast will lead to a fall, because in fact, there is no int** anywhere.

To make it work, you should change void print(int **mt, int lines, int columns) to void print(int mt[][3], int lines, int columns) . Or do "witchcraft" with typedefs, and in the end, anyway, change the function interface or the data storage option from tmp.

If you are sure that everything should be as it is, then you can make a crutch.

 int* newtmp = reinterpret_cast<int*>(tmp); void print(int* tmp, int rows, int cols) { for (unsigned x =0; x < rows; ++x) { for (unsigned y =0; y < cols; ++y) { cout << tmp[cols*x + y]; } } } 

But this is a crutch, because it lays on how some type of memory lies in memory (and we kind of know that tmp [N] [K] will lie in one array of length N * K) and pick it with direct memory calls - architectural evil for which they are expelled from Hogwarts :)

UPD: interface print function in any case does not make any sense when working with objects of type int tmp[X][Y]

@sys_dev , if you are sure that a function with such a prototype will work correctly with the matrix that you described, then you can call it, for example, like this:

  print((int **)&tmp[0][0], 3, 3); 

The code of correctly working print() with such (foolish for a given case) prototype can be, say, like this:

 void print(int **mt, int lines, int columns) { int *a = (int *)mt, i, j; // просто приведем тип к подходящему для доступа к последовательно расположенным в памяти элементам массива for (i = 0; i < lines; i++) for (j = 0; j < columns; j++) printf("%d%c", *a++, j == columns - 1 ? '\n' : ' '); } 

And what to do if the print function still works with data that actually corresponds to its prototype?

Then the function expects a matrix, actually constructed as an array of pointers to rows. This is often done when creating "dynamic" matrices (i.e., an array of previously unknown size on the heap).

Typically, the code that creates such a matrix is ​​something like

 int **create_matrix (int n_lines, int n_cols) { int **res = (int **)malloc(sizeof(*res) * n_lines * n_cols); if (res) { int i; for (i = 0; i < n_lines; i++) if (!(res[i] = (int *)malloc(sizeof(**res) * n_cols))) return 0; } return res; } 

And the function code print() will be, for example, like this:

 void print(int **mt, int lines, int columns) { for (int i = 0; i < lines; i++) for (int j = 0; j < columns; j++) printf("%d%c", mt[i][j], j == columns - 1 ? '\n' : ' '); } 

Then in the calling function you just need to make an array "adapter" (adapter), from pointers to tmp lines and pass it to print.

  int *pt[3] = {&tmp[0][0], &tmp[1][0], &tmp[2][0]}; print(pt, 3, 3); 

Naturally, this array can be filled dynamically (in a loop).

  for (i = 0; i < 3; i++) pt[i] = &tmp[i][0]; 

UPDATE

And so it is still possible to write (at least in gcc 4.8.2 ).

 #include <stdio.h> #include <stdlib.h> void print(int columns, int a[][columns], int lines) { int i, j; for (i = 0; i < lines; i++) { for (j = 0; j < columns; j++) printf("%d ", a[i][j]); puts(""); } } int main (int ac, char *av[]) { int t[3][4] = {{1,2,3,4}, {5,6,7,8}, {21,22,23,24}}; print(4, t, 3); return 0; } 

Pay attention to the description of the int a[][columns] parameter in the print() argument list and the dynamic (by the current value also of the int columns parameter) its size!

It is with such a record that the compiler has enough information to calculate the addresses a[i][j] .