Je ne comprends pas cette façon de calculer le carré d'un nombre

J'ai trouvé une fonction qui calcule le carré d'un nombre:

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

Il renvoie la valeur n ² . La question est, comment fait-il cela? Après quelques tests, j'ai trouvé qu'entre (&a)[k]et (&a)[k+1]est sizeof(a)/ sizeof(int). Pourquoi donc?

Evidemment un hack ... mais une façon de quadriller un nombre sans utiliser l' *opérateur (c'était une exigence du concours de codage).

(&a)[n] 

équivaut à un pointeur vers un intemplacement

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

et donc l'expression entière est

  (&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

Pour comprendre ce hack, vous devez d'abord comprendre la différence de pointeur, c'est-à-dire que se passe-t-il lorsque deux pointeurs pointant vers des éléments du même tableau sont soustraits?

Lorsqu'un pointeur est soustrait d'un autre, le résultat est la distance (mesurée en éléments du tableau) entre les pointeurs. Donc, si ppointe vers a[i]et qpointe vers a[j], alors p - qest égal ài - j .

C11: 6.5.6 Opérateurs additifs (p9):

Lorsque deux pointeurs sont soustraits , les deux doivent pointer vers des éléments du même objet tableau, ou un après le dernier élément de l'objet tableau; le résultat est la différence des indices des deux éléments du tableau . [...].
En d'autres termes, si les expressions Pet Qpointent respectivement vers les i-ème et j-ème éléments d'un objet tableau, l'expression (P)-(Q)a la valeur ài−j condition que la valeur tienne dans un objet de type ptrdiff_t.

Maintenant, je m'attends à ce que vous soyez conscient de la conversion du nom du tableau en pointeur, aconvertit en pointeur vers le premier élément du tableau a. &aest l'adresse du bloc mémoire entier, c'est-à-dire que c'est une adresse de tableau a. La figure ci-dessous vous aidera à comprendre ( _{lisez cette réponse pour une explication détaillée} ):

Cela vous aidera à comprendre pourquoi aet &aa la même adresse et comment (&a)[i]est l'adresse du i ^ème tableau (de même taille que celle de a).

Donc, la déclaration

return (&a)[n] - a; 

est équivalent à

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

et cette différence donnera le nombre d'éléments entre les pointeurs (&a)[n]et (&a)[0], qui sont des ntableaux de chacun des n intéléments. Par conséquent, le total des éléments du tableau est n*n= n² .

REMARQUE:

C11: 6.5.6 Opérateurs additifs (p9):

Lorsque deux pointeurs sont soustraits, les deux doivent pointer vers des éléments du même objet tableau, ou un après le dernier élément de l'objet tableau ; le résultat est la différence des indices des deux éléments du tableau. La taille du résultat est définie par l'implémentation et son type (un type entier signé) est ptrdiff_tdéfini dans l'en- <stddef.h>tête. Si le résultat n'est pas représentable dans un objet de ce type, le comportement n'est pas défini.

Puisque (&a)[n]ni ne pointe vers des éléments du même objet de tableau ni un après le dernier élément de l'objet de tableau, (&a)[n] - ainvoquera un comportement indéfini .

Notez également que, mieux vaut changer le type de retour de la fonction pen ptrdiff_t.

a est un tableau (variable) de n int .

&a est un pointeur vers un tableau (variable) de n int .

(&a)[1]est un pointeur d' intun intaprès le dernier élément du tableau. Ce pointeur estn int éléments après &a[0].

(&a)[2]est un pointeur d' intun intaprès le dernier élément de tableau de deux tableaux. Ce pointeur est2 * n int éléments après &a[0].

(&a)[n]est un pointeur d' intun intaprès le dernier élément de tableau de ntableaux. Ce pointeur est les n * n intéléments après &a[0]. Soustrayez simplement &a[0]ou aet vous avez n.

Bien sûr, il s'agit d'un comportement techniquement indéfini même s'il fonctionne sur votre machine car (&a)[n]il ne pointe pas à l'intérieur du tableau ou au-delà du dernier élément du tableau (comme l'exigent les règles C d'arithmétique des pointeurs).

Si vous avez deux pointeurs qui pointent vers deux éléments du même tableau, sa différence donnera le nombre d'éléments entre ces pointeurs. Par exemple, cet extrait de code affichera 2.

int a[10];

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

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

Considérons maintenant l'expression

(&a)[n] - a;

Dans cette expression aa le typeint * et pointe vers son premier élément.

L'expression &aa un type int ( * )[n]et pointe vers la première ligne du tableau bidimensionnel imagé. Sa valeur correspond à la valeur de asi les types sont différents.

( &a )[n]

est le n-ième élément de ce tableau bidimensionnel imagé et a le type int[n]C'est-à-dire qu'il s'agit de la n-ième ligne du tableau imagé. Dans l'expression, (&a)[n] - ail est converti en l'adresse de son premier élément et a le type `int *.

Donc, entre (&a)[n]et ail y a n rangées de n éléments. La différence sera donc égale à 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

Donc,

1. type de pointeur (&a)[n]estint[n]
2. type de pointeur aestint

Maintenant, l'expression (&a)[n]-aeffectue une soustraction de pointeur:

  (&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