It cannot work (even theoretically), because arrays are not pointers:

• int arr[10]:

  • Amount of memory used is sizeof(int)*10 bytes

  • The values of arr and &arr are necessarily identical

  • arr points to a valid memory address, but cannot be set to point to another memory address

• int* ptr = malloc(sizeof(int)*10):

  • Amount of memory used is sizeof(int*) + sizeof(int)*10 bytes

  • The values of ptr and &ptr are not necessarily identical (in fact, they are mostly different)

  • ptr can be set to point to both valid and invalid memory addresses, as many times as you will

First, recognize that you are passing addresses instead of integer values to printf_s. Take a look at the warning messages issued by the compiler. In particular, note the types of the arguments that the compiler is warning about. To determine the addresses passed to the function, the compiler is doing address arithmetic based on the type of the address. In calculating the address of &arr+1 the compiler starts by taking the address of the array. The compiler looks at the type of the argument and determines that size of the int (*)[5] type is 20. So it adds 20 to the starting address of the array.

Look at the difference in the warning messages and the result of using the following -

 printf_s("%u %u\n", arr + 1, (int*) &arr + 1);

In c you can't pass a variable by reference, the array variable that you assign inside the function contains initially the same address as the passed pointer, but it's a copy of it so modifying it will not alter the passed pointer.

You need to pass the address of the pointer in order to be able to alter it, like this

// Change the pointer of the array
void change(int **array, int length)
{
    *array = malloc(length * sizeof(int));
    if (*array == NULL)
        return;
    for (int i = 0 ; i < length ; i++)
        (*array)[i] = 1;
}

Then in main() you cannot assign to an array, doing so through this kind of function is surely undefined behavior. The array defined in main() is allocated on the stack and you cannot assign anything to an array since they are non-writeable lvalues so you cannot make it point to a heap memory location obtained with malloc(), you need to pass a pointer like this

int *array;
change(&array, length);
free(array);

If you want the function to replace the previous array, it will have to free() the malloc()ed data (note that passing NULL to free() is well defined), so

// Change the pointer of the array
void change(int **array, int length)
{
    free(*array);

    *array = malloc(length * sizeof(int));
    if (*array == NULL)
        return;
    for (int i = 0 ; i < length ; i++)
        (*array)[i] = 1;
}

then in main()

int *array;
array = NULL;
change(&array, length);
change(&array, length);
change(&array, length);
change(&array, length);
free(array);

will do what you apparently want.

arr is not a pointer, it's an array. When you use the word arr the compiler may convert it to a pointer for you - it does &arr[0] automatically, and gets the address of the first element, which is a pointer value, not a pointer variable. And you can't change values. You can't do (&some_variable)++;, you can't do 5++;, and you can't do (&arr[0])++; which is what arr++; would mean.

Because the array name decays into pointer to first element when its assigned or passed (assigned to a variable of first element's address type).

p = c;  // & is not needed, and not defined behavior 

printf("%p\n", (void *)&p);

Gives you the address

I have a char ** array that has 3 pointers

No, you don't. You have an array with three values. The values happen to be pointers. An array doesn't have pointers.

Suppose you allocate memory for this array (of pointers to char):

char **array = malloc( 3 * sizeof(char*)); // 3 values in the array

and then you allocate memory for each string:

array[0] = malloc(4 * sizeof(char) ); // 3 + 1 null terminator
array[1] = malloc(4 * sizeof(char) );
array[2] = 0;

finally you set the values for the strings themselves:

strcpy( array[0], "abc" );
strcpy( array[1], "def" );

Now you want to make a copy. A deep copy actually, because you not only allocate memory for a new array (of pointers to char) but you allocate memory for new strings as well. You do exactly the same allocation:

char **array2 = malloc( 3 * sizeof(char*));
array2[0] = malloc(4 * sizeof(char) );
array2[1] = malloc(4 * sizeof(char) );
array2[2] = 0;

Now you copy the actual strings:

strcpy( array2[0], array[0] );
strcpy( array2[1], array[1] );

If your code differs from the one above, edit your question with more details.

The tricky part is making array[0] hold the address which is in array2[0] (same for array[1] and array2[1]). The problem comes from the fact that memory you allocate via malloc needs to be freed via free.

So you can't just do

array[0] = array2[0];

Because you've lost all references to the first string you allocated. That memory is leaked.

Instead do this:

free(array[0]);
array[0] = array2[0];

This frees the memory used for the first string and copies the address of the copy.

Now you have the same pointer (value) in two variables. This is also tricky because (when you no longer need it) you still need to free the memory allocated for the copy:

free(array2[0])

The tricky part is that array[0] now holds a pointer to freed memory, which can't be used. Using it will lead to bugs.

It would probably be a good idea not to have multiple variables (in the same scope) that hold the same pointer to allocated memory. That may make it difficult to reason about the validity of the pointer.

Arrays are objects all on their own, and not pointers. Consider a simpler object:

int a = 0;

Would you expect to be able to change its address? Of course not. An object is a region of storage with a type. The region of storage is identified by its address, so you won't expect to change it. And arrays are objects too. When you declare

int b[8] = {0};

you declare an object, the size of eight integers, that will occupy some storage. You can't change its address any more than you can change the address of any single int.

You have probably been told that arrays are pointers. But they are not! They may be converted, even implicitly, to a pointer more often than not, but they are still object types. Pointers often stand in for arrays because the address of the first element is enough to reach any other element with pointer arithmetic, but the pointer is not the array object itself. The difference becomes apparent when you inspect their object properties. For instance:

sizeof(b) != sizeof(int*)

The object b is not the size of a pointer, indeed it is the size of 8 integers, likely larger than a pointer.