Matrix on stack to int**... How?

Code:

---

#include <iostream>
using namespace std;

int main() {
  int matrix [3][3];
  for (unsigned int i = 0; i < 3; ++i) {
    for (unsigned int j = 0; j < 3; ++j) {
      matrix [i][j] = 0;
    }
  }
  int** matrix_as_a_pointer = &(&(matrix[0][0]));
  return 0;
}

---

Why is it that I can't do this? What's the best way to have an int** for a matrix on the stack? Thank you in advance.

Code:

---

int** matrix_as_a_pointer = matrix;

---

If you want to get a pointer to a location somwhere within the array, it would be:

Code:

---

int** matrix_as_a_pointer = static_cast<int **>&matrix[y] [x];

---

or

Code:

---

int** matrix_as_a_pointer = &matrix[y] + x;

---

or slightly more complex:

Code:

---

int** matrix_as_a_pointer = matrix + y * 3 + x;

---

Code:

---

int** matrix_as_a_pointer = &(&(matrix[0][0]));

---

What is this??

Your rvalue is trying to get a pointer from a pointer to the first varible in the matrix.
If you want to get a pointer to the matrix just do like this:

Code:

---

int ***matrix_as_a_pointer = &matrix;

---

EDIT:
matsp - you posted while I was writing.

Don't do that. :D

Is that really supposed to work? I'm getting a segmentation fault on Ubuntu Linux by using:

Code:

---

int** matrix_a_as_a_pointer = (int**)matrix_a; //If I omit the cast, the compiler produces a warning
printf("%d\n, matrix_a_as_a_pointer[0][0]");

---

And yes, matrix_a[0][0] is properly initialized.

Yes, of course. The double pointer will need to point to a pointer, which in turn points to the array content.

What are you ACTUALLY trying to do? In a bigger picture, that is.

--
Mats

I wish I could post the whole code here, but this is part of an assignment. Some of my colleagues would definitely resort to copying and pasting my code and calling it their own.

I can tell you this much: I want to have a char* with one of the matrix's lines. I created a function that does that whose prototype is

Code:

---

char* getLine(int*** matrix, unsigned int line, unsigned int limit);

---

So, if I want to get the matrix's line 0, i'd do

Code:

---

getLine(&matrix, 0, 3);

---

That is, if "matrix" is an int**, and if it has 3 columns.

However, using gdb, I found out this was giving me a segmentation fault when I tried to do, for instance, (*matrix)[0][0] ("matrix" is now an int***, since it was passed to the function as such). I am unable to understand why. The matrix is properly initialized.

I'm sorry I can't provide more information. If this means you are unable to help me, then I understand I'm on my own. Nonetheless, thank you for your time.

No, I can help you, it's just that sometimes someone asks detailed questions, where the overall problem can be solved a differnet way.

So, essentially, you need to create another array:

Code:

---

int *matrix_rows[3];
int **matrix_ptr;
for(i = 0; i < 3; i++)
  matrix_rows[i] = &matrix[i][0];
matrix_ptr = matrix_rows;

---

The above is just a sketch, it may need some "fixing", but I think it shows you the principle.

--
Mats

Well, the whole point of my question was to avoid copying things (in your case, pointers) to other locations. However, I'll have to resort to that if I run out of options anyway.

You are not copying things when you call the function - but a pointer to pointer must point to a valid memory address when you use ptr[y][x], because it's the same as *(*(ptr + y) + x). As you can see, there are two pointer dereferences - one for the (ptr + y), and then another for that address plus x.

The other option is to make it a pointer to int, and reference it with

Code:

---

  matrix[x + y * hor_size];

---

This is what the compiler does anyways, but it gets complicated when the indexes are complex (e.g matrix[y*2+3][x-5] is much easier to read than matrix[x-5 + (y*2+3) * hor_size];

--
Mats

Quote:

---

Originally Posted by Mr_Miguel

However, using gdb, I found out this was giving me a segmentation fault when I tried to do, for instance, (*matrix)[0][0] ("matrix" is now an int***, since it was passed to the function as such). I am unable to understand why. The matrix is properly initialized.

---

A 2D (or more) stack array has a unique type that cannot be properly converted to a pointer type. As a result you cannot return a 2D stack array. Essentially the problem is that 2D stack arrays are handled as a 1D array, and the pointers to the beginning of each row are never stored, but rather are computed as needed.

The solutions are:
Return a 2d heap array (via pointer). This can be a problem because of memory management, in particular you should avoid having a function return a memory address it allocated.

Pass the 2d array as a parameter. Arrays are implicitly passed by reference. You can also create array references in your function body.

Return a vector of vectors of your type. This is usually the best way.

There are libraries that provide multidimensional array containers that are better than nested vectors because each row is required to be of the same length. You can use them. I believe boost has such a container.

Quote:

---

Originally Posted by King Mir

A 2D (or more) stack array has a unique type that cannot be properly converted to a pointer type. As a result you cannot return a 2D stack array. Essentially the problem is that 2D stack arrays are handled as a 1D array, and the pointers to the beginning of each row are never stored, but rather are computed as needed.

The solutions are:
Return a 2d heap array (via pointer). This can be a problem because of memory management, in particular you should avoid having a function return a memory address it allocated.

Pass the 2d array as a parameter. Arrays are implicitly passed by reference. You can also create array references in your function body.

Return a vector of vectors of your type. This is usually the best way.

There are libraries that provide multidimensional array containers that are better than nested vectors because each row is required to be of the same length. You can use them. I believe boost has such a container.

---

Well, technicaly, you can pass a stack array around using this method:

Code:

---

func(int arr2d[][20], ...) ...

---

The problem with any multidimensional arrays is that you do need to know the size of all dimensions besides the left-most one, because all C arrays are essentially 1D arrays, with a suitable calculation to achieve the location of the dimensions. The same applies when you allocate on the heap or if you create a global variable -it is only chunk of linear memory in every case.

--
Mats

I think I got it, guys. I think I have the cause of my problem. See the attachment.

Is it correct to conclude that A + 1 (i. e. ponteiro_matriz_a + 1) points to [0][1], when what I actually would want would be for it to point to [1][0]?

EDIT: Never mind. I get it now. My int** has the first element's address. ponteiro_matriz_a[0][0] is equal to **ponteiro_matriz_a. Therefore, I dereference that pointer twice. The first time I dereference it, I get the matrix's first value, as an int*. On my case, that value is 1, or, in hexadecimal, 0x1. When I dereference it again, I attempt to access whatever it is at the address 0x1. But there's nothing there. That's why it's giving me a segmentation fault.

Note to self: never convert an integer 2D array to an int**.

Quote:

---

Originally Posted by matsp

Well, technicaly, you can pass a stack array around using this method:

Code:

---

func(int arr2d[][20], ...) ...

---

The problem with any multidimensional arrays is that you do need to know the size of all dimensions besides the left-most one, because all C arrays are essentially 1D arrays, with a suitable calculation to achieve the location of the dimensions. The same applies when you allocate on the heap or if you create a global variable -it is only chunk of linear memory in every case.

--
Mats

---

Yeah, that's what I meant by Pass the 2d array as a parameter. You can also do this to force the first parameter to be the same:

Code:

---

void func(int (&arr2d)[10][20]);

---

This also has the effect of making sizeof(array) be the actual size of the array.

Quote:

---

Originally Posted by King Mir

Code:

---

void func(int (&arr2d)[10][20]);

---

---

TO make the parameter a pointer to an array[10][20] of ints, it should be:

Code:

---

void func(int (*arr2d)[10][20]);

---

Of course, functions defined like this will only work for that particular size array (which, I think, will not help whatever it is that the Original Poster is trying to accomplish).

D.

Quote:

---

TO make the parameter a pointer to an array[10][20] of ints, it should be:

---

King Mir wanted to demonstrate how to pass an array such that it does not decay to a pointer to its first element. It probably is not very useful since one needs to know the size of the array in order to write the function in the first place, in which case one could use the array size in the function directly.

I think that your example offers no advantage over King Mir's example, but is more complex. Either way, the array size can be directly used in the function, whether by hardcoding or through a constant since it is specific to the function and its array parameter.

It would be more flexible to pass the array such that it decays to a pointer to its first element, and then just provide the array size as another argument. Better yet, one could use a standard container such as std::vector.

Quote:

---

Originally Posted by Dave Evans

TO make the parameter a pointer to an array[10][20] of ints, it should be:

Code:

---

void func(int (*arr2d)[10][20]);

---

Of course, functions defined like this will only work for that particular size array (which, I think, will not help whatever it is that the Original Poster is trying to accomplish).

D.

---

That the same (essentially) as this:

Code:

---

void func(int arr2d[][10][20]);

---

Passing an 2d array by reference like that makes sense, because if you have a required 2nd detention, chances are you have a required first detention. That syntax provides a way to force that requirement.

Also, you can alternatively make it a template like this. Beware that this will not allow heap arrays to be passed as arguments:

Code:

---

template <typename T, int I>
void func(T (&array)[I]);

---

Note: that I in brackets should be capital. For some reason the forum prevents that.

Quote:

---

Originally Posted by laserlight

I think that your example offers no advantage over King Mir's example

---

It isn't my example; I was just correcting what I thought was a (typographical) syntax error from the previous post.

[edit]I was mistaken about the intent of the previous post. I regret my error.[/edit]

In fact, in my experience, functions that deal with 2-D matrices almost always use pointers or pointers-to-pointers except for very specialized applications that have fixed-size matrices.

Even fixed-size matrix functions (3x3 graphics manipulations, for example) might be more efficient with pointers, since element access is just a couple of indirect address operations instead of using the 2-D matrix calculations involving an addition and a multiplication.

D.

Quote:

---

Originally Posted by Dave Evans

It isn't my example; I was just correcting the (typographical) syntax error from the previous post.

In fact, in my experience, functions that deal with 2-D matrices almost always use pointers or pointers-to-pointers except for very specialized applications that have fixed-size matrices.

Even fixed-size matrix functions (3x3 graphics manipulations, for example) might be more efficient with pointers, since element access is just a couple of indirect address operations instead of using the 2-D matrix calculations involving an addition and a multiplication.

D.

---

It may be worthwhile to pass a 2d stack by creating pointers to each row, and passing that as an array. that would mean doing something like this:

Code:

---

void func(int **array); //same as int *array[]
...
int main(){
    int array2d[3][10];
    int array2dasPtr={array2d[0],array2d[1],array2d[2]}
    func(array2dasPtr);
}

---

But that is not either of our codes were doing.
To use your prototype you must do this:

Code:

---

void func(int (*arr2d)[3][10]);
...
int main(){
    int array2d[3][10];
    int array3d[5][3][10]
    func(&array2d);
    func(array3d);
}

---

To use my prototype you must do this:

Code:

---

void func(int (&arr2d)[3][10]);
...
int main(){
    int array2d[3][10];
    int array3d[5][3][10]
    func(array2d);
    func(array3d[0]);
}

---

Quote:

---

Originally Posted by King Mir

That the same (essentially) as this:

---

Of course: you are correct; I misunderstood.

D.