Vous n'êtes pas identifié(e).
Puis l'idée est d'obtenir le même résultat
mais en utilisant une fonction.
J'ai d'abord voulu faire ceci qui ne fonctionne pas :
Puis par tâtonnement, j'ai trouvé ceci qui fonctionne mieux :
Voilà l'explication que je me fais :
il commence par le main et exécute le premier printf;
puis il lit "fonction 'inverser'" à appliquer sur a et b;
puis il écrit (deuxième printf) c'est-à-dire, les valeurs de a et de b, affectées à x et y, que le programme a conservé lors de sa "lecture de la fonction ;
Pour expliquer cette inversion des valeurs de a et b, est-ce que je peux me dire ceci :
à ce niveau :
c=x c'est-à-dire, x est affecté de la valeur du "int a" du main qui est 1
et
x=y c'est-à-dire, x est affecté de la valeur de y qui celle de b, qui a lui-même la valeur de "int b" du main, c'est-à-dire 2
et
y=c c'est-à-dire, y est affecté de la valeur de c qui est celle conservée par c=x qui est 1
C'est que ce qui est ( ) dans la fonction conserve les valeurs affectées au variables du "main", sans que les variables de la fonction doivent s'appeler du même nom que ceux donnés dans le main.
Sinon, comment l'appel de la fonction dans ce cas fonctionnerait-il ?
Merci d'avance.
Dernière modification par Hypathie (09-03-2014 13:29:45)
Hors ligne
Bon j'aurais besoin d'un aide pour comprendre ce qu'il se passe du point de vue "de la machine lorsqu'on appelle une fonction dans un main.
L'explication que je vais donner est aussi valide pour l'appel d'une fonction depuis n'importe quelle fonction.
Appelons ton premier programme « Inversion en ligne » :
Voici le déroulement en mémoire :
Trois cases sont créées contenant les valeurs de a, b et c :
[1] [2] [?]
Puis tu fais les affectations entre ces cases :
[1] [2] [1] (c?a)
[2] [2] [1] (a?b)
[2] [1] [1] (b?c)
Appelons ce second programme « Inversion dans la fonction » :
Ça commence pareil avec deux cases mémoire :
[1] [2]
Puis ça appelle la fonction inverser. À ce moment, tous les arguments sont copiés, donc on a en mémoire :
[1] [2] | [1] [2]
Ou les deux premières cases correspondent aux a et b de main et les deux suivantes à x et y.
Note que si tu avais appelé les deux variables de inverser a et b au lieu de x et y, ça n'aurait absolument rien changé. Les noms de variables sont locaux à une fonction, et c'est très bien comme ça (i.e. utiliser des variables globales est quasi tout le temps la pire solution).
Ensuite, tu fais l'inversion via une case supplémentaire stockant c :
[1] [2] | [1] [2] [?]
[1] [2] | [1] [2] [1] (c?x)
[1] [2] | [2] [2] [1] (x?y)
[1] [2] | [2] [1] [1] (y?c)
Puis la fonction se termine et avec elle est détruite toute la zone mémoire la concernant, on se retrouve donc avec :
[1] [2]
Toi, tu voudrais modifier la valeur des premières cases. Pour ce faire, il ne faut pas que tu transmettes leurs valeurs à la fonction inverser, mais leur adresse.
Appelons ce troisième programme « Inversion par la fonction » :
Cette fois-ci, que se passe-t-il ?
Ça commence de la même manière :
[1] [2]
Puis tu passes deux arguments qui sont les adresses :
[1] [2] | [&a@main] [&b@main]
Tu fais l'échange via une variable c qui va piocher à l'adresse (c'est le fait de la petite étoile) :
[1] [2] | [&a@main] [&b@main] [?]
[1] [2] | [&a@main] [&b@main] [1] (c?*x =a@main = 1)
[2] [2] | [&a@main] [&b@main] [1] (*x = a@main ? *y = b@main)
[2] [1] | [&a@main] [&b@main] [1] (*y = b@main ? c)
[2] [1]
Et hop
Note que l'écriture a@main / &a@main n'est que pour clarifier la chose, ça n'est pas du C, n'écris pas ça dans ton code
captnfab,
Association Debian-Facile, bépo.
TheDoctor: Your wish is my command… But be careful what you wish for.
Hors ligne
C'est à moitié faux, il renvoie en fait :
ce qui fonctionne c'est :
Pourquoi faut-il nommer les variables de la fonction a et b comme les variables du main, puisque c'est (en tout cas selon ce que j'en comprends) la valeur qui est appelée ; surtout s'il ne s'agit plus du même a et du même b dans la fonction et le main, puisque tout est effacé de la mémoire ?
Ce qui est ( ) dans la fonction, correspond bien au valeur des variables du main ?
Moi je m'expliquais les choses en me disant : le premier int (ligne deux dans la fonction) correspond au premier int du main (ligne 10) ; et le deuxième int de la fonction (même parenthèse, ligne deux) correspond à celui de la ligne 11).
Dans cette idée, on devrait bien appeler les variables de la fonction comme on veut, puisque niveau mémoire ce n'est plus les mêmes, mais qu'il y a dans la fonction des correspondances avec les valeurs des variables a et b du main ? Eh bien on dirait que non, et je ne comprends pas pourquoi
Comment lirais-tu le code ci-dessus s'il te plaît ?
Hors ligne
captnfab,
Association Debian-Facile, bépo.
TheDoctor: Your wish is my command… But be careful what you wish for.
Hors ligne
[1] [2]
> affichage de « a: 1 b: 2 »
[1] [2] | [1] [2]
[1] [2] | [1] [2] [?]
[1] [2] | [1] [2] [1]
[1] [2] | [2] [2] [1]
[1] [2] | [2] [1] [1]
> affichage de « a: 2 b: 1 »
[1] [2]
captnfab,
Association Debian-Facile, bépo.
TheDoctor: Your wish is my command… But be careful what you wish for.
Hors ligne
Hors ligne