Discussion :

[smag]

Bonjour � tous,
j'essaie de faire un mini prog (sans classe ni rien) qui permettra de changer la valeur de deux entiers entre eux, d'abord en utilisant les pointeurs et ensuite en utilisant les r�f�rences.
Mais j'ai d�j� un pb de compile lors de la d�claration de f et g!!!Pourquoi ne puis je pas impl�menter ma fonction?

Voici mon code:

Code :

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
17
18
19
20
21
22
23
24
25
26
27
 
#include <iostream>
#include <windows.h>
int main()
{
   int a = 2;
    int b = 4;
    int*p1 = &a;
    int* p2 = &b;
    int& r1 = a;
    int& r2 = b;
 
   void f(int* x, int*y)
    {
 
     };
    void g(int& i,int& j)
    {
 
     }; 
 
 
 
 
system("PAUSE");    
return 0;
}

D'autre part pour appeler avec un pointeur, on fait p1->f mais avec deux c (p1,p2)->f?

[bigboomshakala]

bonsoir,

enl�ve moi les fonctions f et g du corps de la fonction main. place les avant le main, �a ira d�j� mieux.

ensuite j'ai rien compris � ce que tu demandes en ce qui concerne les pointeurs, mais ce que tu dis n'existe pas (p1,p2)->f

EDIT : ah! je pense avoir compris ce que tu veux dire. c'est pas comme �a qu'on appelle une fonction, mais comme �a

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

f(p1,p2)

que ce soit avec un pointeur, une r�f�rence ou une variable (� condition que la fonction prenne comme param�tres un pointeur, une r�f�rence ou une variable).

[smag]

Alors voici ce que �a donne:

Code :

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <iostream>
#include <windows.h>
 
int * f(int* x, int*y)
  {
   int* z = y;
   y =x;
   x= z;
   std::cout << *x << *y;      
   return (x,y);         }
   void g(int& x,int& y)
   {
     int& z = y;
   y =x;
   x= z;
   std::cout << x << y;  
 
        }
int main()
{
   int a = 2;
    int b = 4;
    int*p1 = &a;
    int* p2 = &b;
    int& r1 = a;
    int& r2 = b;
   std::cout << a << b;  
   f(p1,p2);
   std::cout << *p1 << *p2;
 
   g(r1,r2);
   std::cout << a << b;
 
system("PAUSE");      
 
return 0;
}

Dans la fonction f, les valeurs de *x et *y sont invers�es mais quand je reviens dans main, *p1 et *p2 ont � nouveua leur valeur d'origine!!!
Au retour de g, les deux r�f contiennent 2!!

Au secours!!!
Pour moi un pointeur pointe sur un objet.en fait, il contient l'adresse de cette objet.

Une r�f�rence est la copie d'un objet? SI on change la valeur de la r�f�rence, la valuer de l'objet change t elle?

Dans quels cas utilise ton un pointeur au lieu d'une r�f�rence et vice versa?

[Balises [code] ajout�es par Aur�lien, merci d'y penser]

[Ti-R]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
 
void f(int* x, int*y) 
{ 
   int z = *y; 
   *y =*x; 
   *x= z; 
   std::cout << *x << *y;
}

Pas besoin de retour si tu veux modifier les valeurs.
De m�me il faut placer * devant une variable seulement pour r�cup�rer le contenu de la variable et le modifier. Sinon tu manipules les pointeurs de la variable et pas le contenu.

[Aurelien.Regat-Barrel]

Pour moi un pointeur pointe sur un objet.en fait, il contient l'adresse de cette objet.

En fait c'est une variable comme une autre, imagine que ce soit des int qui d�signent des emplacements dans un tableau.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
 
char tableau[ 100 ];
int a = 0;
int b = 1;

a �tant l'emplacement 0 de tableau, b le 1, ...

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
void f(int* x, int*y) 
{ 
   int* z = y; 
   y =x; 
   x= z; 
}

si on traduit ton code avec les cases dans un tableau:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
void f(int x, inty) 
{ 
   int z = y; 
   y =x; 
   x= z; 
}

donc, si x d�signait l'emplacement 0 et y le 1, apr�s l'appel de la fonction x vaut 1 et y 0, � l'int�rieur de la fonction. Mais les cases, elles, n'ont pas boug�e. La case 0 et la case 1 n'ont pas �t� modifi�es. Il aurait fallu faire cela:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
void f(int x, inty) 
{ 
   char z = tableau[ y ]; 
   tableau[ y ] = tableau[ x ]; 
   tableau[ x ]= z; 
}

pour que les cases soient modifi�es. Car x et y sont des adresses, oui, mais toi tu modifies les adresses point�es, au lieu de modifier ce qui est point�.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
void f(int* x, int*y) 
{ 
   int z = *y; 
   *y = *x; 
   *x= z; 
}

Une r�f�rence est la copie d'un objet?

justement non, une r�f�rence, c'est "comme si" c'�tait l'objet lui m�me. Genre:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
 
int a;
 
void test( int & b )
{
    b = 10;
}
 
test( a );

c'est comme si tu avais �crit:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
 
int a;
 
void test()
{
    a = 10;
}
 
test();

Le C ne sait passer des arguments que par copie. Les pointeurs x et y que tu donnes, ils sont copi�s. Les pointeur originaux pass�s lors de l'appel ne sont pas modifi�s suite � l'appel alors que tu as modifi� x et y dans ta fonction.
C++ introduit les r�f�rences, et donc le passage par r�f�rence. Avec une r�f�rence, ce n'est plus une copie de l'objet qui est pass�, mais l'objet lui m�me.

Dans quels cas utilise ton un pointeur au lieu d'une r�f�rence et vice versa?

En C, on utilise les pointeurs pour modifier l'objet pass� car on a pas le choix. En C++, les r�f�rences nous donnent le choix. Donc quand on peut utiliser une r�f�rence, il est pr�f�rable de le faire. Comme dans ton exemple o� r�f�rence ou pointeur on y arrive, mais on pr�f�rera les r�f�rences parce que c'est plus simple et naturel (pas besoin de passer l'adresse des objets, et pas besoin de v�rifier que le pointeur n'est pas nul).
On utilise aussi les r�f�rences pour rendre le code plus performant. Une r�f�rence �vite de faire uen copie, donc avec de gros objets c'est du temps gagn� lors de l'appel. Alors on utilise une r�f�rence constante pour faire comme si c'�tait une copie (constante = ne pas modifier l'objet pass�) mais avec de meilleures performances (passage sans recopie).

[bigboomshakala]

+1 , le return dans la fonction f n'a pas lieu d'�tre (en plus �a ne veux rien dire (x,y)).

une r�f�rence n'est pas une copie de l'objet, c'est un alias de la variable. tout comme certaines personnes ont 2 ou 2 pr�noms et sont pourtant une seule et m�me personne, une r�f�rence permet d'avoir un autre nom pour d�signer la m�me variable.

[smag]

Merci c super clair!!!
Enfin disons que j'en ai un peu plus compris