Appel de fonctions/arguments

Version imprimable

25/09/2006, 10h57
GO

Appel de fonctions/arguments

Quelles différences entre ces 3 définitions d'une fonction qui permute les valeurs des deux variables ?

fct(int *, int *);

fct(int &, int &);

fct(int a, int b);

Merci 8-)
25/09/2006, 11h20
Matthieu Brucher

La première prend 2 pointeurs, la deuxième 2 références et la troisième 2 valeurs.
Seules les 2 premières fonctions peuvent échanger les valeurs de 2 entiers, mais franchement, là, on peut faire aussi beaucoup de bêtises avec simplement les prototypes, sans savoir ce que font chacune des fonctions !
25/09/2006, 11h26
GO
Donc on ne peut pas faire
Code:

1 2 3 4 5 6 void fct(int a, int b); { int c; c=a; a=b; b=c; }
comme en pascal ? ca donne quoi au juste ?
25/09/2006, 11h31
frenchi

Tu peux le faire, mais ca n'echangera pas les valeurs de a et b.

Lors de l'appel a la fonction a et b sont "copiés" et reprennent leur valeur d'origine lorsque l'appel se termine.
C'est pour cela que pour echanger deux valeurs, on passe deux pointeurs sur ces valeurs.
25/09/2006, 11h32
jobherzt

dans ce cas la, la valeur des variables que tu passes en parametres est copiée dans la fonction. donc tout ce qui se passe est interne a la fonction, et n'a pas de consequence sur le variables d'origine. donc ta fonction n'aura aucun effet.
25/09/2006, 11h36
homeostasie
Code:

fct(int *, int *);

On transmet par pointeurs, c'est à dire que les deux pointeurs pointe sur l'adresse des deux variables à permuter.
On peut donc modifier ces valeurs en usant de l'utilisation des pointeurs.

Code:

fct(int &, int &);

On transmet par référence. On ne pointe donc pas sur l'adresse des deux variables à permuter, mais ici la référence correspond à la variable elle même. Ceci implique aucune copie des variables lors de la transmission par référence des paramètres.

Code:

fct(int a, int b);

On recopie seulement les valeurs à permuter dans deux autres variables que l'on transmet en pramètre, d'ou le fait que modifier celles ci ne modifiera pas les variables désirées.
Citation:
Donc on ne peut pas faire

Code:

1 2 3 4 5 6 void fct(int a, int b); { int c; c=a; a=b; b=c; }
Après exécution de cette fonction, il n'y aura pas eu de permutations avec les valeurs que tu as fait passé dans ta fonction mais seulement avec celles utilisées dans ta fonction fct. ;)
25/09/2006, 11h37
GO
Mais que représente *a ? une valeur ou un pointeur ? et c ?
Code:

1 2 3 4 5 void fct (int * a, int * b) {int c; c=*a; *a=*b; *b=c;
???
25/09/2006, 11h40
homeostasie
Citation:

Mais que représente *a ?

*a correspond a la valeur qui se trouve à l'adresse pointée par ton pointeur a.
a possède l'adresse de ta variable pointée.

exemple:
Code:

1 2 3 4 5 int c = 5; int *a = &c; /*a pointe sur la variable c, elle possède son adresse et *a = 5 */ *a = 10; /*c vaut maintenant 10*/
;)
25/09/2006, 11h40
frenchi

a est donc un pointeur d'entier et c un entier.
25/09/2006, 11h42
Matthieu Brucher
Citation:
Envoyé par GO

Mais que représente *a ? une valeur ou un pointeur ? et c ?

Code:

1 2 3 4 5 void fct (int * a, int * b) {int c; c=*a; *a=*b; *b=c;

???
T'as déjà jeté un oeil sur un cours de C ou de C++ et dans la FAQ ?
25/09/2006, 11h47
GO

c juste histoire de me mettre au point...après des années de Delphi. :D

pas évident de revenir au source ! A+
25/09/2006, 11h54
homeostasie

Citation:

c juste histoire de me mettre au point...

Deux liens vers la FAQ C et C++ concernant les pointeurs:
http://c.developpez.com/faq/c/?page=pointeurs
http://c.developpez.com/faq/cpp/?pag...CE_utilisation
25/09/2006, 12h40
NewbiZ

Un réponse précédente sur le forum qui te donnera quelques exemples concrets :
http://www.developpez.net/forums/sho...94&postcount=9

En nommant les variables en conséquence:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//Avec des pointeurs, il est HAUTEMENT CONSEILLE
//d'indiquer "pointeur" dans le nom
void fct1(int * pa, int * pb)
{
	//Ici, les ADRESSES des entiers sont passées PAR VALEUR.
	int c;
	c = *pa;
	*pa = *pb;
	*pb = c;
}
 
//Pour les références, il y en a qui décorent les noms, 
//d'autres qui ne le font pas.
void fct2(int & ra, int &rb);
{
	//Ici, les ENTIERS sont passés PAR RÉFÉRENCE (comme en pascal)
	int c;
	c = ra; //Pas d'étoile ici: C'est implicite pour les références
	ra = rb;
	rb = c;
}
 
//Et la fonction qui n'échange rien:
void fct3(int a, int b);
{
	//Ici, les ENTIERS sont passés PAR VALEUR
	int c;
	c=a;
	a=b;
	b=c;
}

Et la façon de les appeler:

Code:

1
2
3
fct1(&entierA, &entierB); //Échange les contenus des entiers
fct2(entierA, entierB); //Échange les contenus des entiers
fct3(entierA, entierB); //N'échange rien ici.

25/09/2006, 22h46
Luc Hermitte
Citation:
Envoyé par GO

Donc on ne peut pas faire

Code:

1 2 3 4 5 6 void fct(int a, int b); { int c; c=a; a=b; b=c; }

comme en pascal ? ca donne quoi au juste ?
Mais ... c'est exactement comme en Pascal. On ne me la fait pas! :P

En Pascal tu disais explicitement au compilateur que tu désirais passer ton paramètre par référence (-> "var"), en C++ tu passes une référence (-> "&"), en C tu passes un pointeur par valeur (-> "*")(marche aussi en C++), en Ada tu déclares ton paramètre [in,out], idem pour Corba & COM, en Java tu ne fais pas avant l'auto-boxing du Java 1.5, ...

J'ai l'étrange impression que tout le monde a fait tes exos, alors que la réponse est en clair dans quantité de cours de C++ :?