Kann nicht verstehen, wie man das Quadrat einer Zahl berechnet

Question 1

Ich habe eine Funktion gefunden, die das Quadrat einer Zahl berechnet:

int p(int n) {
    int a[n]; //works on C99 and above
    return (&a)[n] - a;
}

Es gibt den Wert von n zurück². Frage ist, wie macht es das? Nach ein wenig Testen fand ich das zwischen (&a)[k] und (&a)[k+1] ist sizeof(a)/sizeof(int). Warum ist das so?

Question 2

Offensichtlich ein Hack … aber eine Möglichkeit, eine Zahl zu quadrieren, ohne die zu verwenden * Betreiber (dies war eine Anforderung für einen Programmierwettbewerb).

(&a)[n]

ist äquivalent zu einem Zeiger auf int am Standort

(a + sizeof(a[n])*n)

und damit ist der gesamte Ausdruck

  (&a)[n] -a 

= (a + sizeof(a[n])*n -a) /sizeof(int)

= sizeof(a[n])*n / sizeof(int)
= sizeof(int) * n * n / sizeof(int)
= n * n

Question 3

Um diesen Hack zu verstehen, müssen Sie zuerst den Zeigerunterschied verstehen, dh was passiert, wenn zwei Zeiger auf Elemente von zeigen gleiche Anordnung werden abgezogen?

Wenn ein Zeiger von einem anderen subtrahiert wird, ist das Ergebnis der Abstand (gemessen in Array-Elementen) zwischen den Zeigern. Also, wenn p verweist auf a[i] und q verweist auf a[j]dann p - q ist gleich i - j.

C11: 6.5.6 Additive Operatoren (p9):

Wenn zwei Zeiger subtrahiert werdenmüssen beide auf Elemente desselben Array-Objekts zeigen oder eins nach dem letzten Element des Array-Objekts; das Ergebnis ist die Differenz der Indizes der beiden Array-Elemente. […].
Mit anderen Worten, wenn die Ausdrücke P und Q weisen jeweils auf die i-ten und j-ten Elemente eines Array-Objekts, der Ausdruck (P)-(Q) hat den Wert i−j vorausgesetzt, der Wert passt in ein Objekt des Typs ptrdiff_t.

Jetzt erwarte ich, dass Sie sich der Umwandlung von Array-Namen in Zeiger bewusst sind. a konvertiert in einen Zeiger auf das erste Element des Arrays a. &a ist die Adresse des gesamten Speicherblocks, dh es ist eine Adresse eines Arrays a. Die folgende Abbildung hilft Ihnen zu verstehen (_{Lesen Sie diese Antwort für eine detaillierte Erklärung}):

Dies wird Ihnen helfen, das Warum zu verstehen a und &a hat die gleiche Adresse und wie (&a)[i] ist die Adresse von i^th Array (von derselben Größe wie das von a).

Also die Aussage

return (&a)[n] - a;

ist äquivalent zu

return (&a)[n] - (&a)[0];

und dieser Unterschied ergibt die Anzahl der Elemente zwischen den Zeigern (&a)[n] und (&a)[0]welche sind n Arrays jeweils n int Elemente. Daher sind die gesamten Array-Elemente n*n = n².

HINWEIS:

C11: 6.5.6 Additive Operatoren (p9):

Wenn zwei Zeiger subtrahiert werden, beide müssen auf Elemente desselben Array-Objekts zeigen oder eins nach dem letzten Element des Array-Objekts; das Ergebnis ist die Differenz der Indizes der beiden Array-Elemente. Die Größe des Ergebnisses ist implementierungsdefiniertund sein Typ (ein vorzeichenbehafteter ganzzahliger Typ) ist ptrdiff_t definiert in der <stddef.h> Header. Wenn das Ergebnis in einem Objekt dieses Typs nicht darstellbar ist, ist das Verhalten undefiniert.

Seit (&a)[n] zeigt weder auf Elemente desselben Array-Objekts noch auf eines nach dem letzten Element des Array-Objekts, (&a)[n] - a wird aufrufen undefiniertes Verhalten.

Beachten Sie auch, dass es besser ist, den Rückgabetyp der Funktion zu ändern p zu ptrdiff_t.

Question 4

a ist ein (variables) Array von n int.

&a ist ein Zeiger auf ein (variables) Array von n int.

(&a)[1] ist ein Zeiger auf int eines int hinter dem letzten Array-Element. Dieser Zeiger ist n int Elemente nach &a[0].

(&a)[2] ist ein Zeiger auf int eines int hinter dem letzten Array-Element von zwei Arrays. Dieser Zeiger ist 2 * n int Elemente nach &a[0].

(&a)[n] ist ein Zeiger auf int eines int hinter dem letzten Array-Element von n Arrays. Dieser Zeiger ist n * n int Elemente nach &a[0]. Einfach subtrahieren &a[0] oder a und du hast n.

Natürlich ist dies ein technisch undefiniertes Verhalten, auch wenn es auf Ihrem Rechner so funktioniert (&a)[n] nicht innerhalb des Arrays oder nach dem letzten Array-Element zeigt (wie von den C-Regeln der Zeigerarithmetik gefordert).

Question 5

Wenn Sie zwei Zeiger haben, die auf zwei Elemente desselben Arrays zeigen, ergibt die Differenz die Anzahl der Elemente zwischen diesen Zeigern. Dieses Code-Snippet gibt beispielsweise 2 aus.

int a[10];

int *p1 = &a[1];
int *p2 = &a[3];

printf( "%d\n", p2 - p1 );

Betrachten wir nun den Ausdruck

(&a)[n] - a;

In diesem Ausdruck a Typ hat int * und zeigt auf sein erstes Element.

Ausdruck &a Typ hat int ( * )[n] und zeigt auf die erste Zeile des abgebildeten zweidimensionalen Arrays. Sein Wert entspricht dem Wert von a obwohl Typen unterschiedlich sind.

( &a )[n]

ist das n-te Element dieses abgebildeten zweidimensionalen Arrays und hat einen Typ int[n] Das heißt, es ist die n-te Zeile des abgebildeten Arrays. Im Ausdruck (&a)[n] - a es wird in die Adresse seines ersten Elements konvertiert und hat den Typ `int *.

Also dazwischen (&a)[n] und a Es gibt n Zeilen mit n Elementen. Der Unterschied wird also gleich sein n * n.

Question 6

Expression     | Value                | Explanation
a              | a                    | point to array of int elements
a[n]           | a + n*sizeof(int)    | refer to n-th element in array of int elements
-------------------------------------------------------------------------------------------------
&a             | a                    | point to array of (n int elements array)
(&a)[n]        | a + n*sizeof(int[n]) | refer to n-th element in array of (n int elements array)
-------------------------------------------------------------------------------------------------
sizeof(int[n]) | n * sizeof(int)      | int[n] is a type of n-int-element array

Daher,

Art der (&a)[n] ist int[n] Zeiger

Art der a ist int Zeiger

Jetzt der Ausdruck (&a)[n]-a führt eine Zeigersubtraktion durch:

  (&a)[n]-a
= ((a + n*sizeof(int[n])) - a) / sizeof(int)
= (n * sizeof(int[n])) / sizeof(int)
= (n * n * sizeof(int)) / sizeof(int)
= n * n