Is there a way of casting a pointer to an array type?

Question

C arrays are somewhat difficult to understand syntactically in C++ and can take some getting used to. Although a 1D array decays to a pointer:

void fn1(int x[2]) {}
void fn2(int*x) {}

fn1() and fn2() have the same function signature.

An array actually does have a type that includes how many elements are in the array. As in:

void fn(int (&)[2]) {}

fn() will only accept a 2 element int array.

Thing is, I can only see that the array of a fixed number of elements can only be generated by stack, file scope or struct/class allocation with that signature:

int twoElementArray[2];

If I were to dynamically allocate it on the heap, I can't seem to get the same signature. I thought that I might be able to cast it, but without success:

int (&array)[2] = reinterpret_cast<int(&)[2]>(new int[2]); // FAIL!

Any ideas as to how this might be accomplished if at all?

 

---

EDIT: Although I selected an answer, it actually doesn't actually cast anything, but uses a definitely better method then casting (better not to cast if not required IMO). However, it technically doesn't answer the question since the question asked if there's "a way of casting a pointer to an array type?" The answer is yes.

int (&array)[2] = *reinterpret_cast<int(*)[2]>(new int[2]); // SUCCESS!

Note that I don't necessarily recommend doing this, but it does answer the question. If I needed to convert a pointer to an array type though, that would be how to do it. Read the picked answer for a better solution when using operator new[].

Answer 1

If I understand your problem correctly, you'd want to do something like this:

// allocate an array of one int[2] dynamically
// and store a pointer to it
int(*p)[2] = new int[1][2];

// now initialize a reference to it
int(&array)[2] = *p;

// delete the array once you no longer need it
delete[] p;

Answer 2

I think this is what you are looking for. For the heap, a two-dimensional array int[M][N] decays to int(*)[N]. To pass it by reference, dereference it (see m below):

#include <iostream>
using namespace std;

void func(int (&x)[2])
{
    cout << x[0] << ' ' << x[1] << endl;
}

int main()
{
    // on the heap
    auto m = new int[1][2];
    m[0][0] = 1; m[0][1] = 2;
    auto n = new int[1][3];
    n[0][0] = 4; n[0][1] = 5; n[0][2] = 6;

    // on the stack
    int o[2] = {7,8};
    int p[3] = {9,10};

    func(*m);
    //func(*n); // doesn't compile, wrong size
    func(o);
    //func(p); // doesn't compile, wrong size
}

Output:

1 2
7 8