un petit dessin

Ça c'est de la mémoire, avec une valeur c quelque part

|_|_|_|_|_|_|c|_|_|_|...
 0 1 2 3 4 5 6 7 8 9

À l'adresse 3, je vais mettre un pointeur sur c :

|_|_|_|6|_|_|c|_|_|_|...
 0 1 2 3 4 5 6 7 8 9

Si j'appelle la fonction add avec add(2,4,6);, add va calculer 2 + 4 et écrire le résultat à l'adresse désignée par son dernier argument, à savoir 6.

Voir le code assembleur aide à comprendre :

int add1(int a, int b){
 return a + b;
}
void add2(int a, int b, int * c){
 *c = a+b;
}

En assembleur x86, les opération binaire sont toutes de la forme a+=b, en assembleur addl b,a
Et ce qu'on écrit f[45] en c s'écrit 45(f) en assembleur (f) est équivalent à *f

add1:
 pushl %ebp // sauver le contexte (pas important ici)
 movl %esp, %ebp // idem
 movl 12(%ebp), %eax // copier second paramètre dans le registre eax
 movl 8(%ebp), %edx // copier le premier paramètre dans edx
 addl %edx, %eax // eax = eax + edx
 popl %ebp //restaurer le contexte
 ret // retourner (le résultat est alors dans eax)
add2:
 pushl %ebp
 movl %esp, %ebp
 movl 12(%ebp), %eax
 movl 8(%ebp), %edx // comme add1...
 addl %eax, %edx // mais là a+b se retrouve dans edx
 movl 16(%ebp), %eax // on copie le troisième paramètre dans eax
 movl %edx, (%eax) // et on copie le contenu de edx à l'adresse dans eax
 popl %ebp // on restaure le contexte
 ret // la fonction ne retourne rien, il y a n'importe quoi dans eax

Please do not feed the trolls