Discussion :

[WhiteTigerZ]

Hola ,
la notion de la pile liberée n'est pas assez claire dans ma tête...
Bon prenant le fameux code d'échange de 2 variables

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
void echange ( int i ; int j) 
 { 
   int tampon;
   tampon=i ;
   i=j ;
   j=tampon ;

D'après ce que je sais
Lors d'un appel à cette fonction : echange(a,b) les contenus de i et j sont echangés puis la pile(ou se situe les variables locales) est liberée sans modifier a et b

Or lorsque on appelle la fonction par echange(&a,b&) tout se passe bien puisque on les a transmis leurs adresses
quelqu'un pourrait m'expliquer qu'est ce que ce passe au niveau de la memoire ainsi que la pile...(je veux aller en profondeur )
Merci d'avance pour vos réponses

[JulienDuSud]

Bon, je vais zapper ton problème de syntaxe, mais voilà comment ça se passe:

Imagine que tu as une variable nommé A et admettons qu'il se trouve à l'adresse 1.

Lorsque tu passes cette variable à une fonction, par valeur:

Le contenu de l'adresse 1 (c'est à dire la variable A) est copié dans la pile et le processeur travaille donc sur cette copie: les modifications sur cette copie ne sont donc pas répercutés sur le contenu de l'adresse 1.

Lorsque tu passes cette variable par référence:

Il n'y a pas de copie (en réalité, c'est l'adresse qui est copiée dans la pile), le processeur travaille directement sur l'adresse 1. Les modifications seront donc répercutés sur la variable A.

[Médinoc]

Partons d'un code simple:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void echange ( int *pi,  int *pj) 
{ 
	int tampon;
	tampon = *pi;
	*pi = *pj ;
	*pj = tampon;
}
 
int main(int argc, char *argv[])
{
	int a=1, b=2;
	/* On se moque des warnings "paramètre non-référencé" */
 
	echange(&a, &b);
	return 0;
}

Ici, quand on est dans la fonction, la pile doit contenir, dans l'ordre:

• argv
• argc
• Adresse de retour pour main() (retourne quelque part)
• Registres sauvegardés par main() (s'il y en a)
• a et b (l'ordre est au choix du compilateur)
• Adresse de b
• Adresse de a
• Adresse de retour depuis echange() (retourne dans main())
• Registres sauvegardés par echange() (s'il y en a)
• tampon

[WhiteTigerZ]

Merci pour vos réponses )

[Lavock]

C'est un peu plus compliqué... Il faut différencier pile et registre. Le mieux; si tu veux vraiment comprendre, c'est de regarder des cours d'assembleurs (évite les architecture compliqué comme x86, tourne toi plutôt vers de l'arm).

En gros, lors de l'appel de la fonction, tu vas empilé A et B et passez dans le registre leurs adresses, ainsi que le retour vers le main, et aller à ta fonction.

Ensuite, la fonction va faire tes opérations (chargé A et B depuis leur adresse et swapper les valeur) et retouner dans le main.

Celui-ci va dépiler les valeurs et OH ! Miracle, les valeur de A et B auront était changé.

[Médinoc]

Le passage de paramètres en C sur un x86 se fait traditionnellement par la pile (du moins, sous Windows, et il me semble que sous nux aussi). Le passage par registres est une optimisation.

Même en x86-64, où les 4 premiers paramètres sont passés par registre, on réserve la place pour eux sur la pile.

PS: Je ne qualifierais pas le x86 de "compliqué", surtout si on se limite aux registres du 8086: Le 8086 est une bonne machine à pile avec peu de registres, ce qui illustre bien le cas général du C.

[Lavock]

Même en x86-64, où les 4 premiers paramètres sont passés par registre, on réserve la place pour eux sur la pile.

Il me semblait que il était de même pour les x86-32.