I>Ну тогда распишу полностью

1[&array]-&array[0] == &array[1] - &array[0] == &array[0] + 1 - &array[0] == 1

int array[146];
assert( (1[&array] - &array[0]) == 146 );

(typeof(array[0])*)1[&array]

1[array] == array[1], грубо говоря 
I>1 + *pointer == *pointer + 1

int f( int i)
{
    return 1[&i];
}

&array[1] != 1[&array]

&array[1] 
/*интерпретируется как */
&(array[1])

 1 + &array

1 + array

&array[1] != 1[&array]

int array[10];

int (*tmp1)[10] = &array + 1;
int *tmp2 = &array[0];

cout << ((int*)tmp1 - tmp2);

boost/std::extent< ArrayType >::value

template <typename T, std::size_t N>
  inline std::size_t countof( T (&arr)[N] ) { return N; }

The expression E1[E2] is identical (by definition) to *((E1)+(E2))

The unary * operator performs indirection: the expression to which it is applied shall be a pointer to an
object type, or a pointer to a function type and the result is an lvalue referring to the object or function
to which the expression points.

E>С другой стороны, просто интересно, насколько это UB реализуемо...

#include <type_traits>

int main()
{
    char array[1][11];

    static_assert(std::is_same<decltype((1[&array[0]])), decltype((array[1]))>::value, "");
    static_assert(&1[&array[0]] == &array[1], "");

    array[1]; // line #10
    array[1]-&array[0][0]; // line #11
    
    1[&array[0]]-&array[0][0]; // line #13
    1[&array[0]]-&array[0][0]; // line #14
}

clang++ -std=c++11 -O0 -Wall -Wno-unused-value -pedantic -pthread main.cpp && ./a.out

main.cpp:10:5: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds]
    array[1]; // line #10
    ^     ~

main.cpp:5:5: note: array 'array' declared here
    char array[1][11];
    ^

main.cpp:11:5: warning: array index 1 is past the end of the array (which contains 1 element) [-Warray-bounds]
    array[1]-&array[0][0]; // line #11
    ^     ~

main.cpp:5:5: note: array 'array' declared here
    char array[1][11];
    ^

2 warnings generated.

(typeof(array[0])*)1[&array]

cout << array;

6.5.2.1 Array subscripting
[...]
2 A postfix expression followed by an expression in square brackets [] is a subscripted designation of an element of an array object. The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))). [...]

6.5.3.2 Address and indirection operators
[...]
3. The unary & operator yields the address of its operand. If the operand has type ‘‘type’’, the result has type ‘‘pointer to type’’. If the operand is the result of a unary * operator, neither that operator nor the & operator is evaluated and the result is as if both were omitted, except that the constraints on the operators still apply and the result is not an lvalue. Similarly, if the operand is the result of a [] operator, neither the & operator nor the unary * that is implied by the [] is evaluated and the result is as if the & operator were removed and the [] operator were changed to a + operator. Otherwise, the result is a pointer to the object or function designated by its operand.
4. The unary * operator denotes indirection. If the operand points to a function, the result is a function designator; if it points to an object, the result is an lvalue designating the object. If the operand has type ‘‘pointer to type’’, the result has type ‘‘type’’. If an invalid value has been assigned to the pointer, the behavior of the unary * operator is undefined.84)
[...]
84) Thus, &*E is equivalent to E (even if E is a null pointer), and &(E1[E2]) to ((E1)+(E2)). It is always true that if E is a function designator or an lvalue that is a valid operand of the unary & operator, *&E is a function designator or an lvalue equal to E. If *P is an lvalue and T is the name of an object pointer type, *(T)P is an lvalue that has a type compatible with that to which T points.
Among the invalid values for dereferencing a pointer by the unary * operator are a null pointer, an address inappropriately aligned for the type of object pointed to, and the address of an object after the end of its lifetime.

int main()
{
    int x = 0;
    auto first = &x;
    auto last = first + 1; // legal?
    // use as range [first, last)
}

5.7 (Additive operators)
...
4. For the purposes of these operators, a pointer to a nonarray object behaves the same as a pointer to the
first element of an array of length one with the type of the object as its element type.

I>int array[10];

I>int (*tmp1)[10] = &array + 1;
I>int *tmp2 = &array[0];

I>cout << ((int*)tmp1 - tmp2);
I>

int* tmp1 = *(&array + 1);//1[&array]
int* tmp2 = *(&array);//&array[0]
cout << (tmp2 - tmp1);

1[array] == array[1], грубо говоря 
I>>1 + *pointer == *pointer + 1

int f( int i)
E>{
E>    return 1[&i];
E>}

int f( int i)
{
    return *(&i + 1);
}

int f( int i)
E>>{
E>>    return 1[&i];
E>>}

I>int f( int i)
I>{
I>    return *(&i + 1);
I>}
I>

*(1 + &i)

1[&i]

int f( int i)
E>>>{
E>>>    return 1[&i];
E>>>}

I>>int f( int i)
I>>{
I>>    return *(&i + 1);
I>>}
I>>

E>AFAIK, в С, и в С++, если не намудрить с перегрузкой операторов, выражения

*(1 + &i)

и

1[&i]

ЭКВИВАЛЕНТНЫ...

E>Тем не менее, всё нормуль, да?..

int inc( int* i )
{
   return 1[i];
}

int main(int argc, char* argv[])
{
   int arr[] = { 1, 2, 3 };
   cout << inc( &0[arr] ) << inc( &1[arr] ) << endl;
   return 0;
}