Discussion :

[mayami]

Bonjour,
je suis une débutante, j'ai trouvé un exercice sur les pointeurs et j'avoue avoir beaucoup de mal à comprendre le principe .
quelqu'un peut-il me donner la correction de cet exercice? :

Code :

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

1
2
3
4
5
void main() {
int a=1;int b= -2; int c = 0;
ajouet(a,b,c);
cout <<"c=" << c << "/n";
}

1/
donner la sortie du programme dans les cas suivants :
void ajouter(int a,int b,int c) {c= a+b ;}
void ajouter(int a,int b,int *c) {*c= a+b ;}
void ajouter(int a,int b,int &c) {c= a+b ;}

Comment s'appelle ces 3 passages de paramètres?
Merci pour votre aide .

[salseropom]

Salut,

bienvenue sur ce forum. Quand tu passes un paramètre à une fonction, tu as 2 possibilités : passage par valeur (donc le paramètre n'est pas modifiable) et par référence (donc le paramètre est modifiable)

Code :

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

1
2
3
4
 
void ajouter(int a,int b,int c) {c= a+b ;}
void ajouter(int a,int b,int *c) {*c= a+b ;}
void ajouter(int a,int b,int &c) {c= a+b ;}

dans le 1e cas, c n'est pas modifié, dans les 2 autres cas c sera modifié.
Dans le 1e cas, c est passé par valeur, dans le 2e on a un pointeur sur c et dans le 3e on a une référence sur c

Je te laisse potasser un peu plus les pointeurs et les références. Ce sont des notions très importantes si tu veux faire du C++. Regarde aussi le mot-clé "const" qui est très utilisé avec les références.

Dernier point, ce n'est pas

Code :

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

1
2
3
4
5
 
void main()
{
 
}

mais

Code :

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

1
2
3
4
5
6
 
int main()
{
 
  return 0;
}

ou

Code :

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

1
2
3
4
5
6
 
int main(int nargin, char ** argc)
{
 
  return 0;
}

[koala01]

Salut, et bienvenue sur le forume

<snip>...
ou

Code :

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

1
2
3
4
5
6
 
int main(int nargin, char ** argc)
{
 
  return 0;
}

A vrai dire, bien que le nom des paramètres soit tout à fait libre, on utilise généralement

Code :

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

int main (int argc, char argv)

• argc étant l'abréviation de "argument count"
• argv etant l'abréviation de "argument values"

Ceci dit, pour compléter un peu la réponse de salseropom, je voudrais attirer ton attention sur le fait que, en C++, on préfère n'utiliser les pointeurs que lorsque l'on n'a vraiment pas le choix, car ils sont très fortement associés au phénomène de la gestion dynamique de la mémoire et à tous les problèmes que ce phénomène sous-entend.

Et, surtout, d'éviter le recours à l'opérateur "address of" afin de permettre le passage d'un pointeur à une fonction.

Les références ont en effet quelques avantages par rapport aux pointeurs, dont:

• la garantie de non nullité : un pointeur devant être nul, tu dois vérifier qu'il ne le soit pas avant d'essayer d'accéder à l'objet pointé... cette contrainte n'existe pas avec les références
• le respect de la syntaxe "classique": avec les pointeurs, tu dois utiliser la fleche "->" ou explicitement dire que tu veux accéder à "ce qui est pointé par" ton pointeur (*ptr).truc, alors qu'avec les références, tu utilise exactement la même syntaxe que celle que tu utiliserais si tu avais affaire à un objet et non à une référence ( ref.truc)

Tu comprendra donc assez facilement que

[screetch]

Et, surtout, d'éviter le recours à l'opérateur "address of" afin de permettre le passage d'un pointeur à une fonction.

ca se discute, l'opinion opposée etant que les références sont moins lisibles lors de l'appel de fonction.
Lorsque je tape "&variable" je vois bien que ma variable risque d'être modifiée. Lorsque je passe "variable" seulement, il faut aller voir la fonction.

[koala01]

ca se discute, l'opinion opposée etant que les références sont moins lisibles lors de l'appel de fonction.
Lorsque je tape "&variable" je vois bien que ma variable risque d'être modifiée. Lorsque je passe "variable" seulement, il faut aller voir la fonction.

Lorsque tu tape "&variable", tu sais qu'il est possible qu'elle soit modifiée, mais, si tu n'a pas accès au code de la fonction, tu n'a aucun moyen de t'en assurer...

Lorsque tu tape "variable", tu dois, effectivement, vérifier le prototype de la fonction, mais tu n'a pas besoin d'avoir accès à son code, parce que tu as trois solutions:

1. l'argument est passé par valeur, et les modifications ne sont pas répercutées
2. l'argument est passé par référence, et les modifications seront répercutées
3. l'arguemnt est passé par référence constante et les modifications sont impossibles

Evidemment, cela nécessite de respecter la "const correctness" tout au long de ton projet

[Lavock]

Hum, il y a aussi le mot const pour les pointeurs . L'avantage du passage par adresse c'est que tu es sur que ce n'est pas passer par valeur, même sans voir le prototype... Remarque, comment savoir qui faut le passer par adresse si on a pas vu le prototype oO !