passing int (&array)[] to a function C++

The difference is that the third form is more restrictive, while the first and second forms could benefit from a null check.

The first (and second) form can accept an argument that is not an array, as long as the argument converts to an int pointer.

void changeArray(int array[]) {
    array[0] = 1111;
}

int main() {
    changeArray(nullptr); // Causes a segmentation fault, but does compile.
}

The third form cannot.

void changeArray(int (&array)[]) {
    array[0] = 1111;
}

int main() {
    // changeArray(nullptr);
    // error: invalid initialization of non-const reference of type 'int (&)[]'
    //        from an rvalue of type 'std::nullptr_t'
}

An argument that is an array (of int) would be accepted by any of these functions.

I understood that 1 and 2 are practically the same, passing a pointer to the first element.

Not just practically the same. They are the same. Presumably, that is why you named the second function changeArrayByPointer instead of changeArray, since otherwise you'd get a function redefinition error. (If you want to test this out, try putting the declaration void changeArray(int array[]); before your main function and the definition void changeArray(int *array) { array[0] = 1111; } after. The definition links to the declaration, despite looking different.) See also Difference between passing array, fixed-sized array and base address of array as a function parameter.

In contrast, the first and third forms are distinct signatures, so they can overload the name changeArray. (However, if both overloads are in scope, trying to call one with an array argument is ambiguous.)

When would you use int (&array)[]?

void changeArray(int (&array)[]) is more restrictive in that it only accepts arrays by reference. You can pass as argument(by reference) an array of any size with elements of type int. This also prevents one from passing a null pointer.

This was allowed through p0388r4 and cwg393 that mentions the rationale. They mention:

Motivation and impact

As of core issue 393,CWG393 function parameters can be pointers or references to arrays of unknown bound. However, binding such a parameter to an array of known bound isn't permitted:

void f(int(&)[]);
int arr[1];

f(arr);          // Error
int(&r)[] = arr; // Error

This restriction is unjustified and should be removed. One consequence of our approach is the fact that *

(3) also passes a pointer internally (references are implemented as pointers on all platforms I know of).

But unlike (1) and (2), it only accepts arrays, not arbitrary pointers.

Like (1) and (2), it doesn't preserve the length information.

I'm not sure why would anybody want to use (3). It seems to be a strictly worse alternative to (1) and (2), because you no longer can pass subarrays, standard containers, etc.