It's purely a type issue.

In most expression contexts the name of an array (such as var) decays to a pointer to the initial element of the array, not a pointer to the array. [Note that this doesn't imply that var is a pointer - it very much is not a pointer - it just behaves like a pointer to the first element of the array in most expressions.]

This means that in an expression var normally decays to a pointer to an int, not a pointer to an array of int.

As the operand of the address-of operator (&) is one context where this decay rule doesn't apply (the other one being as operand of the sizeof operator). In this case the type of &var is derived directly from the type of var so the type is pointer to array of 5 int.

Yes, the pointers have the same address value (the address of an arrays first element is the address of the array itself), but they have different types (int* vs int(*)[5]) so aren't compatible in the assignment.

ISO/IEC 9899:1999 6.3.2.1/4:

Except when it is the operand of the sizeof operator or the unary & operator, or is a string literal used to initialize an array, an expression that has type "array of type" is converted to an expression of type "pointer to type" that points to the initial element of the array object and is not an lvalue. ...

No, you cannot reassign an array as you do here:

int q[3];
q = *(int [3]) arrayReturn(z); 

If you want to copy the contents of z to q, you can do that with the memcpy library function:

memcpy( q, z, sizeof z );

but the = operator isn't defined to copy array contents.

Otherwise, the best you can do is declare q as a pointer and have it point to the first element of z:

int *q = z; // equivalent to &z[0]

Unless it is the operand of the sizeof or unary * operators, or is a string literal used to initialize a character array in a declaration, an expression of type "N-element array of T" will be converted, or "decay", to an expression of type "pointer to T" and the value of the expression will be the address of the first element of the array - that's why the above assignment works.

Arrays in C are simple sequences of elements - there's no metadata indicating their size or type, and there's no separate pointer to the first element. As declared, the arrays are

   +---+
z: | 1 | z[0]
   +---+
   | 2 | z[1]
   +---+
   | 3 | z[2]
   +---+
    ...
   +---+
q: | ? | q[0]
   +---+
   | ? | q[1]
   +---+
   | ? | q[2]
   +---+

There's no separate object q to assign to.

1. Bidimensional array:

int a[2][3]= { {1,2,3},{4,5,6}};

With this statement in memory you have 2x3 integers, all adjacent in memory.I suppose that you know how to access them, but in the case you don't I'll clarify it:

a[0][0] : 1
a[0][1] : 2
a[0][2] : 3
a[1][0] : 4
a[1][1] : 5
a[1][2] : 6

2. Pointer to array:

int (*ptr)[3] = &a[0];

ptr points to a int[3] block of memory.So you can assign it only to an int[3] type:

ptr= &a[0];
ptr= &a[1];

The difference is that this pointer does not have it's own memory, and you have to assign it to an int[3] variable or allocate it:

ptr= malloc (2*sizeof(int[3]);

This way you can use the memory pointed by ptr, if you initialize ptr this way:

for(int j=0; j<2; j++)
    for(int i=0; i<3;i++)
        ptr[j][i]=i+j*3+1;

This case you'll have the same memory representation of int a[2][3], except that this memory is in the heap and not in the stack.You can always choose to realloc/free the memory and this memory is not deleted once your function terminates.

If you have an array declared like

uint8_t str[] = "shutdown 1";

then a pointer to the first element of the array will look like

uint8_t *rcm = str;

If you want to declare a pointer that will point to the whole array as a single object then you can write

uint8_t ( *rcm )[11] = &str;

As for this record

uint8_t* (rcm)[];

then it is not a declaration of a pointer. It is a declaration of an array with unknown size and with the element type uint8_t *.

Examples:

Example 1: C program to understand difference between pointer to an integer and pointer to an array of integers.

#include<stdio.h> 

int main() 
{ 
    // Pointer to an integer 
    int *p; 

    // Pointer to an array of 5 integers 
    int (*ptr)[5]; 
    int arr[5]; 

    // Points to 0th element of the arr. 
    p = arr; 

    // Points to the whole array arr. 
    ptr = &arr; 

    printf("p = %p, ptr = %p\n", p, ptr); 

    p++; 
    ptr++; 

    printf("p = %p, ptr = %p\n", p, ptr); 

    return 0; 
} 

Example 2: C program to illustrate sizes of pointer of array

 #include<stdio.h> 

    int main() 
    { 
        int arr[] = { 3, 5, 6, 7, 9 }; 
        int *p = arr; 
        int (*ptr)[5] = &arr; 

        printf("p = %p, ptr = %p\n", p, ptr); 
        printf("*p = %d, *ptr = %p\n", *p, *ptr); 

        printf("sizeof(p) = %zu, sizeof(*p) = %zu\n", 
                            sizeof(p), sizeof(*p)); 
        printf("sizeof(ptr) = %zu, sizeof(*ptr) = %zu\n", 
                            sizeof(ptr), sizeof(*ptr)); 
        return 0; 
    } 

Example 3: C program to print the elements of 3-D array using pointer notation

#include<stdio.h> 
int main() 
{ 
int arr[2][3][2] = { 
                    { 
                        {5, 10}, 
                        {6, 11}, 
                        {7, 12}, 
                    }, 
                    { 
                        {20, 30}, 
                        {21, 31}, 
                        {22, 32}, 
                    } 
                    }; 
int i, j, k; 
for (i = 0; i < 2; i++) 
{ 
    for (j = 0; j < 3; j++) 
    { 
    for (k = 0; k < 2; k++) 
        printf("%d\t", *(*(*(arr + i) + j) +k)); 
    printf("\n"); 
    } 
} 

return 0; 
} 

Hope this can help you to understand.

ptr is a pointer to an int array(int[2]), but you malloc the wrong size, and then, leaking the memory by assigning to the same variable, thus overriding the malloc memory address. I assume you want to do that:

int (**ptr)[2];
ptr = malloc (2*sizeof(int(*)[2]));
ptr[0] = &a;
ptr[1] = &b;

int* b is just a pointer. The structure will have sufficient space to store a single pointer value in this field.

&array[0] is also just a pointer, and so will fit within the structure field.

The value you are assigning is the address of the start of the array. It is not the array. It may point to the array, but once the reference is taken, the compiler doesn't know this as you lose all information about the size of the memory that you are pointing to.

There is no overflow of memory.

As a side note, &array[0] is equivalent to just array. Both are a pointer to the same thing. The type pointer[size] simply allocates space of sizeof(type)*size, and then creates a variable called pointer which stores the address of it.

&array[1] would be equivalent to array + 1.

Arrays are non-assignable and non-copyable, so you'd have to copy each element by hand (in a loop), or using std::copy.