Discussion :

[Yekoo]

Bonjour à tous !
Je viens vers vous car je découvre en ce moment même le c++ et les références. Il y a quelque chose que je ne semble pas saisir...

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
 
#include <iostream>
 
using namespace std;
 
void echangeReferences(int& var1, int& var2)
{
    cout << "Dans la fonction echangeReferences : var1=" << var1 << " var2=" << var2 << endl; // affiche : var1=8 var2=5
    int tmp=var1;
    var1=var2;
    var2=tmp;
}
 
 
int main()
{
    int var1=5, var2=8;
    echangeReferences(var1,var2);
    cout << "var1=" << var1 << " var2=" << var2 << endl; // affiche : var1=5 var2=8
 
    return 0;
}

Je ne comprend pas pourquoi le "cout" à l'intérieur de la fonction "echangeReferences" indique que var1=8 et que var2=5 alors que dans le "main", j'ai initialisé var1 à 5 et var2 à 8 !

Pourriez vous m'éclairer ?
Merci à vous.

[Abbadon1988]

cout << "Dans la fonction echangeReferences : var1=" << var1 << " var2=" << var2 << endl; // affiche : var1=8 var2=5

Ceci n'est déjà pas logique car tu n'as pas fait ton échange encore .

Par contre je suis désolé mais je vois pas pourquoi, pour moi ca devrait être bon

D'ailleurs chez moi ton code donne le bon résultat

[Yekoo]

Salut Abbadon1988,
C'était juste pour le test le "cout" dans la fonction echangeReferences. ;-)

[3DArchi]

Salut,

J'obtiens bien :

Dans la fonction echangeReferences : var1=5 var2=8
var1=8 var2=5

Le passage par référence permet de passer non pas une copie de l'argument mais un lien vers cet argument. Toute modification dans la fonction modifie donc l'argument de l'appelant.
Si la fonction ne souhaite pas modifier l'argument, le passage par référence peut être utile si la copie est couteuse (gros objet, avec une ressource, etc.). En ce cas, on passe une référence constante :

Code :

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

TYPE_R fonction(TYPE1 const &rc_arg1);

Souvent on considère que les type natifs (int, bool, char, enum, pointeurs, etc.) se passent plutôt par valeur lorsqu'ils n'ont pas besoin d'être modifié et les classes par référence constante (ça reste une indication et pas une règle).

[koala01]

Salut,

Tu dois confondre...

En modifiant un tout petit peu ton programme sous la forme de

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
#include <iostream>
 
using namespace std;
 
void echangeReferences(int& var1, int& var2)
{
    cout << "Dans la fonction echangeReferences : var1=" << var1 << " var2=" << var2 << endl; // affiche : var1=8 var2=5
    int tmp=var1;
    var1=var2;
    var2=tmp;
}
 
 
int main()
{
    int var1=5, var2=8;
    cout<<"avant la fonction var1="<<var1 <<" var2="<<var2<<endl;
    echangeReferences(var1,var2);
    cout << "apres la fonction var1=" << var1 << " var2=" << var2 << endl; // affiche : var1=5 var2=8
 
    return 0;
}

l'exécution te donne

Code :

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

1
2
3
4
 
avant la fonction va1=5 var2=8
Dans la fonction echangeReferences  var1=5 var2=8
apres la fonction var1=8 var2=5

Et l'on remarque que tout se passe comme prévu:
Avant la fonction d'échange, les valeurs sont bel et bien celles que tu définis au départ
Dans la fonction, étant donné que l'affichage a lieu AVANT l'échange, les valeurs sont celles définies au départ
Après la fonction, l'échange a été fait, et, comme tu as transmis tes variables sous la forme de références, les modifications apportées au sein de la fonction sont répercutées dans la fonction appelante

Souvent on considère que les type natifs (int, bool, char, enum, pointeurs, etc.) se passent plutôt par valeur lorsqu'ils n'ont pas besoin d'être modifié et les classes par référence constante (ça reste une indication et pas une règle).

Je crois que le but de la manoeuvre est surtout de montrer que ce que l'on effectue dans une fonction appelée est répercuté sur les variables qui ont été transmises sous la forme de référence.

Tu as tout à fait raison, évidemment, sur le fait qu'il est préférable de passer les types primitifs par valeur et les autres par référence constante lorsqu'ils ne doivent pas être modifiés par la fonction, mais il ne semble pas que ce soit l'objectif de la démonstration actuelle

[Yekoo]

Bonjour à tous,
Je vous remercie pour vos explications, je comprend mieux maintenant ;-)