Ich kann diese Methode zur Berechnung des Quadrats einer Zahl nicht verstehen

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 ^{2 zurück} . Die Frage ist, wie macht das das? Nach ein wenig Test fand ich das zwischen (&a)[k]und (&a)[k+1]ist sizeof(a)/ sizeof(int). Warum ist das so?

Offensichtlich ein Hack ... aber eine Möglichkeit, eine Zahl ohne Verwendung des *Operators zu quadrieren (dies war eine Anforderung für einen Codierungswettbewerb).

(&a)[n] 

entspricht einem Zeiger auf intat location

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

und somit 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

Um diesen Hack zu verstehen, müssen Sie zuerst den Zeigerunterschied verstehen, dh was passiert, wenn zwei Zeiger, die auf Elemente desselben Arrays zeigen, subtrahiert werden?

Wenn ein Zeiger von einem anderen subtrahiert wird, ist das Ergebnis der Abstand (gemessen in Array-Elementen) zwischen den Zeigern. Wenn also pauf a[i]und qzeigt auf a[j], dann p - qist gleichi - j .

C11: 6.5.6 Additive Operatoren (S. 9):

Wenn zwei Zeiger subtrahiert werden , zeigen beide auf Elemente desselben Array-Objekts oder auf einen 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 Pund Qauf das i-te bzw. das j-te Element eines Array-Objekts verweisen , hat der Ausdruck (P)-(Q)den Wert,i−j sofern der Wert in ein Objekt vom Typ passt ptrdiff_t.

Jetzt erwarte ich, dass Sie wissen, dass der Array-Name in einen Zeiger akonvertiert und in einen Zeiger auf das erste Element des Arrays konvertiert wird a. &aist die Adresse des gesamten Speicherblocks, dh es ist eine Adresse des Arrays a. Die folgende Abbildung hilft Ihnen beim Verständnis ( _{lesen Sie diese Antwort für eine detaillierte Erklärung} ):

Dies hilft Ihnen zu verstehen, warum aund &ahat die gleiche Adresse und wie (&a)[i]ist die Adresse des i- ^ten Arrays (von der gleichen Größe wie die von a).

Also die Aussage

return (&a)[n] - a; 

ist äquivalent zu

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

und dieser Unterschied gibt die Anzahl der Elemente zwischen den Zeigern (&a)[n]und an (&a)[0], die nArrays jedes n intElements sind. Daher sind die gesamten Array-Elemente n*n= n² .

HINWEIS:

C11: 6.5.6 Additive Operatoren (S. 9):

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

Da (&a)[n]weder auf Elemente desselben Array-Objekts noch auf Elemente hinter dem letzten Element des Array-Objekts verweist, (&a)[n] - awird undefiniertes Verhalten aufgerufen .

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

aist ein (variables) Array von n int.

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

(&a)[1]ist ein Zeiger von inteins intnach dem letzten Array-Element. Dieser Zeiger ist n intElemente nach &a[0].

(&a)[2]ist ein Zeiger von inteins intnach dem letzten Array-Element von zwei Arrays. Dieser Zeiger ist 2 * n intElemente nach &a[0].

(&a)[n]ist ein Zeiger von inteins intnach dem letzten Array-Element von nArrays. Dieser Zeiger ist n * n intElemente nach &a[0]. Einfach subtrahieren &a[0]oder aund du hast n.

Dies ist natürlich ein technisch undefiniertes Verhalten, selbst wenn es auf Ihrem Computer (&a)[n]funktioniert, da es nicht innerhalb des Arrays oder nach dem letzten Array-Element zeigt (wie in den C-Regeln der Zeigerarithmetik vorgeschrieben).

Wenn Sie zwei Zeiger haben, die auf zwei Elemente desselben Arrays zeigen, ergibt die Differenz die Anzahl der Elemente zwischen diesen Zeigern. Zum Beispiel gibt dieses Code-Snippet 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 ahat Typ int *und zeigt auf sein erstes Element.

Der Ausdruck &ahat Typ int ( * )[n]und zeigt auf die erste Zeile des abgebildeten zweidimensionalen Arrays. Sein Wert entspricht dem Wert, aobwohl die Typen unterschiedlich sind.

( &a )[n]

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

Also zwischen (&a)[n]und aes gibt n Reihen von n Elementen. Der Unterschied wird also gleich sein n * n.

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

So,

1. Typ (&a)[n]ist int[n]Zeiger
2. Typ aist intZeiger

Jetzt führt der Ausdruck (&a)[n]-aeine 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