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