Designating a pointer to a 2D array

Question

If I declare a 2D array

int A[sz][sz];

How can I create a pointer to this object?

I ask because I want to return an array via pointer to a pointer, int**, from a function but I want to build the array without knowing the size beforehand. The size will be passed as an argument. I want to know if there is a way to do this without using dynamic allocation.

The problem is if I do something like int** A inside the function this gives A no information about the size I want.

How can I create the array and then assign a pointer to this array, if it's a 2D array.

I should be more clear. I want return a pointer to a pointer so it wouldn't be a pointer to the 2D array but a something like int**.

Answer 1

Your problem is, that a 2D array in the form int** requires an array of int* for the two step dereferencing, which simply does not exist when you declare an array with int A[sz][sz];.

You can build it yourself like this:

int* pointers[sz];
for(size_t i = sz; i--; ) pointers[i] = A[i];

This might seem absurd, but is rooted in the way C handles arrays: A[i] is of type int ()[sz], which is the subarray of row i. But when you use that array in the assignment, it decays to a pointer to the first element in that subarray, which is of type int*. After the loop, A and pointers are two very different things (the type of A is int ()[sz][sz])

Sidenote: You say that you want to return this from a function. If your array is allocated on the stack, you must not return a pointer to its data, it will disappear the moment your function returns. You can only return pointers/references to objects that have either static storage or are part of another existing object. If you fail to comply with this, you are likely to get stack corruption.

Edit:

A little known fact about C is, that you can actually pass around pointers to real C arrays, not just the pointer types that an array decays to. Here is a small program to demonstrate this:

#include <stddef.h>
#include <stdio.h>

int (*foo(int size, int (*bar)[size][size], int y))[] {
    return &(*bar)[y];
}

int main() {
    int mySize = 30;
    int baz[mySize][mySize];
    int (*result)[mySize];
    result = foo(mySize, &baz, 15);
    printf("%ld\n", (size_t)result - (size_t)baz);
}

The expected output of this example program is 1800. The important thing is that the actual size of the array must be known, either by being a compile time constant, or by being passed along with the array pointer (and if it's passed along with the array pointer, the size argument must appear before the array pointer does).

Answer 2

the responses to your question are weird. Just do this:

int A[2][2];
int**p =NULL;

*p = A[0];   // **p==A[0][0] , *(*p+1)==A[0][1]

Answer 3

Let me flesh out your question a little bit. You mention:

I ask because I want to return an array [...] from a function but I want to build the array without knowing the size beforehand. The size will be passed as an argument. I want to know if there is a way to do this without using dynamic allocation.

For the I want to return an array from a function [...] size passed as an argument, it seems reasonable to me that you can use std::vector everywhere, and call its .data() method when you need access to the underlying array (which is guaranteed to be contiguous). For example:

std:vector<double> myfun(size_t N) {
 std::vector<double> r(N);
 // fill r[0], r[1], ..., r[N-1]
 return r;
}

// later on:
r.data(); // gives you a pointer to the underlying double[N]

And for the I want to to do this without dynamic allocation, that is not possible unless you know the size at compile time. If that is the case, then do exactly as before but use std::array, which can implement optimizations based on known compile-time size:

std::array<double, N> myfun() {
 std::array<double, N> r;
 // fill r[0], r[1], ..., r[N-1]
 return r;
}

// later on:
r.data(); // gives you a pointer to the underlying double[N]

And to be generic, I would actually use a template function capable of working with arbitrary containers:

template<typename T>
void myfun(T& data) {
  for(int k=0; k<data.size(); k++) {
    // do stuff to data[k]
 }
}

// call as, for example:
std::vector<double> data(10);
myfun(data);

// or equally valid:
std::array<double, 10> data;
myfun(data);

Finally, if you are working with two-dimensional data, please remember that when you store the Matrix in row-major order that is:

Matrix [1, 2; 3 4] is stored as [1 2 3 4]

then you can refer to element (i, j) of the matrix by calling data[i * ncols + j]. For example: consider a three by four matrix:

a b c d
e f g h
i j k l

The element (2, 2) (that is: third row, third column because we assume zero-based C-type indexing) is calculated as: M[2][2] = M[2 * 4 + 2] = M[10] = k. This is the case because it was stored as:

 [a b c d e f g h i j  k  l]
 [0 1 2 3 4 5 6 7 8 9 10 11]

and k is the element with index 10.