Discussion :

[calito]

Bonjour,

Je suis tres motivé à apprendre le c++. Là, il y a des chose que je n'arrive pas a comprendre.

1. Je voudrais savoir quel est l'utilité de definir une fonction avec parametre par reference. Pouvez vous m'expliquer à partir de ce programme que j'ai fait, s'il vous plait. Il m'affiche bien les resultats.
2. ENsuite, pourquoi c'est necessaire de creer le prototype d'une fonction? Quel est l'avantage ?

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
 
#include <iostream>
using namespace std;
 
int addition(int &val_1, int &val_2);
 
 
int main(){
 
    int a,b;
    cout << "Entrer la premiere valeur : " << endl;
    cin >> a;
    cout << "Entrer la deuxieme valeur : " << endl;
    cin >> b;
 
    cout << "Le resultat est : " << addition(a,b);
 
    return 0;
}
 
 
int addition(int &val_1, int &val_2){
 
    int resultat;
    resultat = val_1 + val_2;
    return resultat;
 
}

Merci deja pour vos explications.

Cordialement

[Pyramidev]

Bonjour,

Réponse à la question 1 :

Dans ton exemple avec int addition(int &val_1, int &val_2), le passage par référence est inutile.

Par contre, regarde l'exemple donné dans la FAQ C++ :

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
// fonction qui échange i et j 
void swap(int& i, int& j) 
{ 
    int tmp = i; 
    i = j; 
    j = tmp; 
} 
 
int main() 
{ 
    int x = 1; 
    int y = 2; 
    swap( x, y ); 
    // x = 2, y = 1 
}

Lien : http://cpp.developpez.com/faq/cpp/?page=Les-references

Dans cet exemple, si on avait utilisé un passage par valeur, x et y auraient été inchangés :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void swapQuiNeMarchePas(int i, int j) 
{ 
    int tmp = i; 
    i = j;   // i n'est qu'une copie de x ; modifier i ne modifie pas x
    j = tmp; // j n'est qu'une copie de y ; modifier j ne modifie pas y
} 
 
int main() 
{ 
    int x = 1; 
    int y = 2; 
    swapQuiNeMarchePas( x, y ); 
    // x = 1, y = 2 
}

[foetus]

ENsuite, pourquoi c'est necessaire de creer le prototype d'une fonction? Quel est l'avantage ?

Ce n'est pas un prototype, mais une déclaration. ("forward declaration" en anglais)

Parce que la définition va être trouvée par le compilateur après un appel (ou plusieurs).

Regarde ton code. Si tu supprimes la déclaration, lorsque le compilateur va trouver l'appel dans la fonction main il ne connait pas cette fonction/ procédure.
Parce qu'elle est définie après la fonction main.

Donc soit:

• tu fais un couple .h/ .cpp, tu y codes ta fonction et tu fais un #include avant la fonction main
• tu déplaces la définition avant la fonction main
• tu places une déclaration avant la fonction main (si je ne dis pas de bêtises, une fonction/ procédure est toujours extern. Donc sa définition peut être n'importe où)

[calito]

Merci pyramidev.
Si je comprends bien, le fait d'utiliser l’opérateur d'adresse, la fonction change l'adresse de i en lui donnant celle de j et de j à i. C bien ça ?

[Pyramidev]

Si je comprends bien, le fait d'utiliser l’opérateur d'adresse, la fonction change l'adresse de i en lui donnant celle de j et de j à i. C bien ça ?

En fait, la fonction va faire en sorte que, quand tu manipules i (resp. j), c'est un peu comme si tu manipulais directement x (resp. y).

Si je remplace swap par son code, la fonction main devient :

Code :

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

1
2
3
4
5
6
7
8
9
10
int main() 
{ 
    int x = 1; 
    int y = 2;
    int& i = x; // i est un alias de x.
    int& j = y; // j est un alias de y.
    int tmp = i;
    i = j; 
    j = tmp;
}

...ce qui équivaut à :

Code :

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

1
2
3
4
5
6
7
8
9
10
int main() 
{ 
    int x = 1; 
    int y = 2;
    int& i = x; // i est un alias de x.
    int& j = y; // j est un alias de y.
    int tmp = x; 
    x = y; 
    y = tmp;
}

[calito]

Foetus, merci d'avoir repondu a la deuxieme question.
Pyramidev, A toi aussi merci.

Je vais pratiquer plus, je comprends un peu Pyramide par rapport a ta derniere reponse. Cool.


Bye

[foetus]

Je vais pratiquer plus, je comprends un peu Pyramide par rapport a ta derniere reponse.

En réalité Pyramidev tourne autour du pot les références/ alias ce sont des pointeurs non nuls mais que tu utilises comme une variable normale (sans déférencement).

Une des spécificités qu'il faut savoir, c'est qu'en C/ C++ le passage de paramètres se fait par valeur. D'où le recours aux pointeurs (C/ C++) ou aux références (C++)

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
// fonction qui échange i et j 
void swap(int* i, int* j) 
{
    if ((i == NULL) || (j == NULL)) { return; }
 
    int tmp = (*i); 
    (*i) = (*j); 
    (*j) = tmp; 
} 
 
int main() 
{ 
    int x = 1; 
    int y = 2; 
    swap(&x, &y); 
    // x = 2, y = 1 
}

[calito]

En réalité Pyramidev tourne autour du pot les références/ alias ce sont des pointeurs non nuls mais que tu utilises comme une variable normale (sans déférencement).

Une des spécificités qu'il faut savoir, c'est qu'en C/ C++ le passage de paramètres se fait par valeur. D'où le recours aux pointeurs (C/ C++) ou aux références (C++)

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
// fonction qui échange i et j 
void swap(int* i, int* j) 
{
    if ((i == NULL) || (j == NULL)) { return; }
 
    int tmp = (*i); 
    (*i) = (*j); 
    (*j) = tmp; 
} 
 
int main() 
{ 
    int x = 1; 
    int y = 2; 
    swap(&x, &y); 
    // x = 2, y = 1 
}

Ici c'est le passage par pointeurs !!
Le fait de passer (*i) = (*j), est-ce que ce n'est pas une copie de *j qui est donné a *i ?

[bacelar]

Ici c'est le passage par pointeurs !!

Un passage par référence, c'est un passage par pointeur "fiabilisé/simplifié".
Le pointeur ne peut pas être null et il y a vérification que les types pointés sont compatibles.

Le fait de passer (*i) = (*j), est-ce que ce n'est pas une copie de *j qui est donné a *i ?

Non, c'est un appel à l'opérateur d'affectation : operator=