Discussion :

[Patr77]

Bonjour a tous !

Debutant, j'apprend le C++.

Je coince sur ces deux type de 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
 
 
#include <iostream>
 
   using namespace std;
   double carre(double x)
{
  double resultat;
  resultat = x*x;
  return resultat;
}
 
int main()
 
{
  double nombre, carreNombre;
  cout << "Entrez un nombre : ";
  cin >> nombre;
  carreNombre = carre(nombre); //On utilise la fonction
  cout << "Le carre de " << nombre << " est " << carreNombre << endl;
 
return 0;
}

et celui ci :

#

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
 
 #include <iostream>
 using namespace std;
 
  double carre(double x)
{
  double resultat;
  resultat = x*x;
  return resultat;
}
 
int main()
{
  for(int i(1); i<=20 ; i++)
{
  cout << "Le carre de " << i << " est : " << carre(i) << endl;
}
 
return 0;
}

D'apres le tutoriel, pour le 1 er code, la modification ne se fait uniquement que sur la variable carreNombre, et NON sur la variable nombre, (apres le resultat du return),
mais le code suivant, c'est la variable i qui est directement modifiée.

Or dans l'explication du tutoriel, je cite:
Ce n'est que lors du return que les variables de main() sont modifiées c'est-à-dire ici la variable carreNombre. La variable
nombre reste inchangée lors de l'appel à la fonction.
A lire cette explication, la variable i ne devrait pas etre modifiée, or c'est le cas...

L'explication n'est pas tres claire ou du moins incomplete, il devrait ajouter que lorsque il y a le symbole =
seule la variable situé a gauche de ce symbole est modifiée,
mais
s'il n'y a pas ce symbole = la variable i ( dans cet exemple), peut etre modifiée... Ai je bon ?

Merci pour vos retours.

[Bousk]

s'il n'y a pas ce symbole = la variable i ( dans cet exemple), peut etre modifiée... Ai je bon ?

Non.
i n'est pas modifié pas l'appel à carre.
Je vois pas comment tu peux prétendre qu'elle l'est vu que tu ne l'affiches pas après l'appel de toute façon.
Si i changeait, tu n'as aucune chance de faire une boucle de 1 à 20, parce que dès que i vaut 2... il devienrait ?!
Le paramètre de carre est une copie, et comme ce mot l'indique, ça fait une copie. Donc l'originale est inchangée.
Une variable change de valeur, quand tu y affectes une valeur. C'est tout.

[Patr77]

Merci d'avoir repondu !

Je me suis peut etre mal expliqué ou c'est moi qui n'ai pas compris.

Voici un autre code, que j'ai modifié.

La variable nombre d'origine ne change pas, d'accord,
mais la variable nombre placée dans les parenthese de la fonction carré, ( fonction main() ) est modifiée, puisqu'elle devient le resultat de la fonction carre,
j'en deduis
que lorsque la variable nombre est comprise dans les parenthese de la fonction carre, celle ci est modifiée, car elle devient le resultat de la fonction carré ...
La variable ( d'origine) nombre reste a 56, mais la variable nombre placée entre les parentheses ( qui ne modifie pas la variable d'origine au depart ) est modifiée.

Il y aurait donc deux possibilitées a minima, d'obtenir des resultats, voila ce que je comprend. Une methode lorsque on demande un chiffre, et ou on a besoin d'une autre variable et du symbole =
et l'autre methode ou on ne demande pas de chiffre et l'on place la variable nombre directement entre les parentheses de la fonction pour obtenir un resultat donné par la fonction carré, sans changer le chiffre 56 de base de la variable nombre.

Au fait,
les arguments sont compris dans les parentheses () de la fonction, mais les parametres ???
A certain endroit du tuto, les parametres sont aussi compris dans les meme parenthese de la fonction, d'apres ce que je comprend,
c'est pas tres clair.

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
 
#include <iostream>
using namespace std;
 
  double carre(double x)
{
  double resultat;
  resultat = x*x;
  return resultat;
}
 
int main()
{
  double nombre(56);
  carre(nombre); //On utilise la fonction
 
  cout << "Le carre du chiffre " << nombre << " est " << carre(nombre) << endl;
 
return 0;
}

[dalfab]

Bonjour,

une variable, ça peut être modifiée (d'où son nom). Ici tu compares 2 variables dans 2 contextes différents. Elle peuvent avoir le même nom ou pas, dans tous cas les elles auront leur vie propre. Celle dans la fonction est modifiée dans la fonction et disparaît quand la fonction se termine, celle dans main() c'est pareil elle vit sa vie dans main().

Maintenant qu'est-ce qui relie la fonction avec le monde extérieur. Une fonction reçoit des paramètres, ces paramètres sont pour elle des variables locales qui disparaîtront à la fin de la fonction. Les valeurs de ces paramètres viennent des arguments passées à la fonction. Donc à chaque argument (qui est une variable ou une expression de l'appelant) correspond un paramètre qui est une variable de l'appelé.

Code :

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

1
2
3
4
5
6
7
int produit( int a , int b ) { // les 2 paramètres sont a et b
    return  a * b;                // la valeur retournée est le résultat du calcul
}
int main() {
    int  a = 2;
    int  z = produit( a+1 , a );   // Les 2 arguments sont a+1 et a, la valeur récupérée est z
}

Dans l'exemple la fonction a reçu dans a la valeur 3 et dans b la valeur 2. Elle ne connait pas l'origine, par exemple le fait que b (de la fonction) est directement la copie de a (de main)

Pour le retour, c'est pareil dans l'autre sens. La valeur calculée de l'expression dans return est transmise à la variable de l'appelant.

Dans une fonction, on n'a à regarder que ce qui est écrit dans la fonction, on "oublie" l'extérieur, la fonction doit faire son boulot et retourner un résultat. Du côté de l'appelant, on lui passe ce dont elle a besoin et on récupère son résultat, ce qui se passe dans la fonction c'est son problème.

[foetus]

Tu confonds plusieurs choses

1) Lorsqu'on a 1 affectation a = b;, il y a 2 opérandes :

• celle de droite, qu'on va prendre sa valeur
• celle de gauche, qui va recevoir la valeur de l'opérande de droite

C'est comme en mathématiques : a <- 15;

2) L'opérande de droite pour 1 affectation peut être 1 variable, 1 valeur, ou 1 fonction (c'est + complexe, mais c'est 1 début)
Parce que 1 fonction produit 1 résultat qui est retourné.
C'est comme en mathématiques lorsque tu ajoutes a et 15 (par exemple, a + 15), on va le traduire par 1 appel add(a, 15)

• add, c'est le nom de la fonction
• cette fonction a 2 paramètres : a et 15
• cette fonction va retourner 1 résultat. Il faut regarder la déclaration/ définition pour savoir le type de retour.

Et donc, dans ton cas, ta fonction carre va retourner 1 valeur de type double.

Le mot clef est return : c'est lui qui dit quelle valeur va être retournée.

2 bis) Tu as des fonctions qui ne produisent pas de résultat (ce sont des procédures) : en C/ C++, elle retournent void.

3) Tu n'as pas besoin de stocker le résultat d'1 fonction.
Mais, par contre, tu peux transmettre ce retour en le passant en paramètre à 1 autre fonction.

Dans ton cas, ta fonction carre va calculer le carré et il va être transmis au flux de sortie (std::cout) pour être affiché :

Code :

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

    cout << "Le carre du chiffre " << nombre << " est " << carre(nombre) << endl;

est équivalent à

Code :

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

1
2
3
    double ret = carre(nombre);
 
    cout << "Le carre du chiffre " << nombre << " est " << ret << endl;

4) En C/ C++, on définit 1 bloc de code entre { et }.
Le corps d'1 fonction c'est 1 bloc.

Et toutes les variables créées dans 1 bloc, sont détruites à la fin du bloc : ce sont des variables locales.
En C++, contrairement au C, on n'est pas obligé de définir ces variables au début du bloc.

Et donc leur nom va avoir du sens que pour ce bloc.

4 bis) 1 paramètre est 1 variable locale qui va permettre d'échanger avec "l'extérieur"

Et donc, dans le code de @dalfab, mon V.D.D. (mon voisin du dessus), le paramètre a de la fonction produit est différent de la variable a du main.

5) Ton tutorial te prépare au passage de paramètres.
En algorithmie, il y a 3 types de passages : entrée (on va lire le paramètre), sortie (on va modifier le paramètre), entrée et sortie (on lire et modifier le paramètre)

En C/ C++, le passage de paramètres est seulement "en entrée". C'est à dire que lorsqu'on passe 1 variable dans 1 appel de fonction, on va transmettre sa valeur.

Dans ton cas, lorsque tu appelles carre(nombre), on va transmettre à la fonction carre la valeur de nombre qu'elle va stocker dans le paramètre x de type double.

Évidement, en C/ C++ (et notamment en C++) , il y a possibilités de passer 1 variable à 1 fonction et de la modifier (passage entrée et entrée et sortie)

6) En C/ C++, 1 boucle for a 3 partie for(1;2;3) :

• 1 : l'initialisation de variables. En C++, on peut aussi définir des variables (que tu as d'ailleurs fait). C'est à ce moment qu'on va au moins initialiser le compteur de boucle.
• 2 : le test de sortie de boucle. La boucle va s'exécuter tant que le test est vrai. En C/ C++, les boucles for et while sont assez similaires. Il n'y a qu'en algorithmie que la distinction est forte
• 3 : on va dire à la boucle que faire à la fin d'1 tour. C'est à ce moment qu'on va au moins incrémenter/ décrémenter le compteur de boucle.

C'est 1 début, parce que c'est + complexe, avec les mots clefs continue et break, voire return.

Par que tu as oublié que ta variable i est 1 compteur de boucle.
Lorsque tu codes for(int i(1); i<=20 ; i++), tu dis que

• 1 : ta variable i commence à 1
• 2 : tant que ta variable i est inférieure ou égale à 20, on continue
• 3 : qu'à chaque tour de boucle on incrémente de 1 (i++)

Donc, non ce n'est pas la fonction qui modifie ta variable i mais ta boucle for

[Médinoc]

Le truc à assimiler, c'est qu'une valeur peut exister sans être dans une variable déclarée.
Avec un simple code comme ça:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
 
int addition(int nbr1, int nbr2) { return nbr1+nbr2; }
 
int main(void)
{
	int a;
	std::cout << "Entrer nombre: ";
	std::cin >> a;
	std::cout << a << " plus trois égale: " << addition(a, 3) << std::endl;
	return 0;
}

Si j'exécute ce programme et que je tape 5, il devrait m'afficher la valeur 8, pourtant je n'ai pas déclaré de variable destinée à la contenir. Du point de vue de ce code, le 8 existe uniquement dans des emplacements temporaires, connus seulement du compilateur.
La variable a n'a pas été modifiée.

[Patr77]

Bonjour,

une variable, ça peut être modifiée (d'où son nom). Ici tu compares 2 variables dans 2 contextes différents. Elle peuvent avoir le même nom ou pas, dans tous cas les elles auront leur vie propre. Celle dans la fonction est modifiée dans la fonction et disparaît quand la fonction se termine, celle dans main() c'est pareil elle vit sa vie dans main().

Bonjour,
oui, là je te suis, pas de probleme.

Maintenant qu'est-ce qui relie la fonction avec le monde extérieur. Une fonction reçoit des paramètres, ces paramètres sont pour elle des variables locales qui disparaîtront à la fin de la fonction. Les valeurs de ces paramètres viennent des arguments passées à la fonction. Donc à chaque argument (qui est une variable ou une expression de l'appelant) correspond un paramètre qui est une variable de l'appelé.

Merci pour la precision qui manquait quelque peu dans le tutoriel au sujet des parametres et des arguments, c'est plus clair,
quand aux variables locales, parametre dans la fonction ou les arguments dans le main, j'avais effectivement lu qu'elle ont leur propre vie, qu'elle aient le meme nom ou pas.

Code :

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

1
2
3
4
5
6
7
int produit( int a , int b ) { // les 2 paramètres sont a et b
    return  a * b;                // la valeur retournée est le résultat du calcul
}
int main() {
    int  a = 2;
    int  z = produit( a+1 , a );   // Les 2 arguments sont a+1 et a, la valeur récupérée est z
}

Dans l'exemple la fonction a reçu dans a la valeur 3 et dans b la valeur 2. Elle ne connait pas l'origine, par exemple le fait que b (de la fonction) est directement la copie de a (de main)

Pour le retour, c'est pareil dans l'autre sens. La valeur calculée de l'expression dans return est transmise à la variable de l'appelant.

Dans une fonction, on n'a à regarder que ce qui est écrit dans la fonction, on "oublie" l'extérieur, la fonction doit faire son boulot et retourner un résultat. Du côté de l'appelant, on lui passe ce dont elle a besoin et on récupère son résultat, ce qui se passe dans la fonction c'est son problème.

Oui, c'est ainsi que je voyais aussi la chose.

Merci.

En C/ C++, le passage de paramètres est seulement "en entrée". C'est à dire que lorsqu'on passe 1 variable dans 1 appel de fonction, on va transmettre sa valeur.

Tu l'as beaucoup mieux expliqué que moi.

Par que tu as oublié que ta variable i est 1 compteur de boucle.
Lorsque tu codes for(int i(1); i<=20 ; i++), tu dis que

• 1 : ta variable i commence à 1
• 2 : tant que ta variable i est inférieure ou égale à 20, on continue
• 3 : qu'à chaque tour de boucle on incrémente de 1 (i++)

Donc, non ce n'est pas la fonction qui modifie ta variable i mais ta boucle for "

Tout ce qui se trouve dans la boucle est modifié uniquement par la boucle for, oui, je le comprenais ainsi,
Par contre,
quand la variable i se trouve dans l'appelant de la fonction ( merci pour ce terme precis) de la fonction main(), elle transmet sa valeur donné par la boucle for, que la fonction va recuperer dans son parametre ( merci pour la precision c'etait pas assez precisé dans le tuto),
et le return, apres calcul dans la fonction, renvois sa valeur dans la variable i contenu dans l'appel de la fonction carre de la fonction main(), qui va modifier la valeur de la variable i, de l'appelant uniquement, mais pas la variable i de la boucle for.
C'est comme ca que je voulais l'expliquer plus haut.



Pour resumer ( je reprend un exemple cité) les deux formes sont equivalente, mais dans l'un c'est la variable nombre dans l'appelant qui sera modifié par la valeur du return, et dans l'autre forme, lorsque l'operande = est presente, seule la variable ret reçoit la valeur retournée par la fonction, et non plus, la variable nombre dans l'appelant carre(nombre)
ai je bon ? :

Code :

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

   cout << "Le carre du chiffre " << nombre << " est " << carre(nombre) << endl;

est équivalent à

Code :

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

1
2
3
    double ret = carre(nombre);
 
    cout << "Le carre du chiffre " << nombre << " est " << ret << endl;

[foetus]

Tu pédales dans la semoule

renvois sa valeur dans la variable i contenu dans l'appel de la fonction carre de la fonction main(), qui va modifier la valeur de la variable i

c'est 1 passage par valeur (entrée). Donc tu passes la valeur de la variable i à l'appel de la fonction carre(i).

Mais comme tu ne stockes pas la valeur de retour (la carré de i avec i qui varie entre 1 et 20 inclus), aucune variable n'est modifiée et encore moins la variable i.
Tu peux faire à la rigueur i = carre(i) pour sauvegarder le carré de i dans la variable i, mais comme i est 1 compteur de boucle ta boucle va être infinie puisque la carré de 1 c'est 1

Ce qui modifie i, c'est la troisième partie de ta boucle i : ++i.

c'est la variable nombre dans l'appelant qui sera modifié par la valeur du return

c'est 1 passage par valeur (entrée). Donc tu passes la valeur de la variable nombre à l'appel de la fonction carre(nombre).

, et dans l'autre forme, lorsque l'operande = est presente, seule la variable ret reçoit la valeur retournée par la fonction

oui tu utilises l'affection (=) pour stocker la valeur retournée par la fonction carre dans la variable ret.

[Patr77]

Pour l'appel de la fonction, la variable incluse dans l'appel, on fait un passage par valeur vers le parametre de la fonction,
mais la valeur retournée par return, est ce aussi un passage par valeur ?

J'ai bien compris que la variable i de la boucle for n'est pas modifiée, au fil des resultat de la boucle par incrementation, qui elle ne change pas, mais pour le i placé dans l'appel de la fonction,
au moment du retour de la valeur retournée par la fonction, comment s'appelle cette etape ? Passage par valeur ?

J'avais lu que c'etait une copie, mais ca porte peut etre encore un autre nom ?

Desolé pour toutes ces questions.

[Médinoc]

On appelle ça passage par valeur ou passage par copie, c'est la même chose.