Bonjour tout le monde,

Je commence le cours de C++, j'en suis au chapitre des fonctions.

J'ai essayer de faire une calculatrice (en console). Tout se passe bien. Je demande le type d'opération (via une string mais c'est pas très grave pour le moment). Je demande alors 2 nombres (en "double").

Arrive la condition du carré, mais vu que je demande 2 nombres en conditions initiales, j'ai réussi à afficher les carrés des 2 nombres.

Mais le code me paraît bizarre, si quelqu'un pouvais y jeter un œil...

La fonction carré:

double carre(double a, double b) {
	double carrA;
	double carrB;
	carrA = a * a;
	carrB = b * b;
	return carrA, carrB;
}

et dans le main:

else if (type == "carre") {
		double resultatA;
		double resultatB;
		resultatA = carre(nombreUn, nombreUn);
		resultatB = carre(nombreDeux, nombreDeux);
		cout << "Le carre de " << nombreUn << " est " << resultatA <<endl << "Le carre de " << nombreDeux << " est " << resultatB << endl;;
	}

Pour le carré, on voit que j'utilise 2 fois le "nombreUn" ou "nombreDeux", vu que la fonction demande 2 nombres...

Il doit y avoir plus simple, mais comme je débute, je vois pas encore laquelle...

Merci d'avance si quelqu'un peut m'éclairer.

Il n'est malheureusement pas possible de faire retourner par une fonction deux valeurs par un return. Il faut donc trouver une autre solution.

Comme par exemple retourner une valeur par une variable passée par référence à la fonction.

Ah ok, merci pour ce détails !

Primo, le cours de C++ de ce site est une calamité, changez en plus vite, vers le cours de zeste de savoir, par exemple.

Secondo, on ne peut retourner qu'une valeur depuis une fonction, mais le type de la valeur peut très bien être une paire, ou tuple en général, ou encore un objet pouvant contenir un nombre arbitraire de champ, et un tableau, en C++, c'est un objet.

Tertio, l'opérateur carré est normalement un opérateur unaire simple, il prend un nombre réel (voir complexe) en entré et retour son carré, sous forme d'un nombre réel (ou complexe) en sortie étant le carré du nombre en entré.

Votre implémentation, elle est plutôt tombé en marche plutôt que correct. 

rouIoude a écrit:

Comme par exemple retourner une valeur par une variable passée par référence à la fonction.

La, en l'occurrence, ce n'est pas une bonne idée.

La fonction carré n'a a priori pas besoin de 2 paramètres. Tu fais 2 calculs indépendant. Corrige ta fonction pour n'avoir qu'un paramètre.

Hors sujet :

- inutile de déclarer tes variables en debut de fonction. Declare les quand tu les utilisent.

- utilise const quand tu peux

Merci pour ces détails, je vais essayer de modifier ça ! 

bacelar a écrit:

Primo, le cours de C++ de ce site est une calamité, changez en plus vite, vers le cours de zeste de savoir, par exemple.

Plus de précision par rapport à ce cours? Pourquoi une calamité?

Et on peut se tutoyer, moi je n'y voit aucun inconvénient.

gbdivers:

Pas si hors sujet que ça je crois, ça fait parti de l'apprentissage!

Je vais modifier mon code.... Merci

-
Edité par Sébastien_code_28 1 septembre 2021 à 23:58:23

> Plus de précision par rapport à ce cours? Pourquoi une calamité?

Réponse ici: https://openclassrooms.com/forum/sujet/mooc-c?page=7#message-86545267

Je ne sais pas comment tu fais en général, mais tes fonctions doivent être très simples.
Pour la fonction carre(), je ferais ceci:
double carre(double a) {
    return a*a;
}
Est-ce que tu demandes les nombres avant l'opérateur?
Si tu inversais, tu pourrais vérifier si c'est une opération unaire et ne demander qu'un seul nombre.
Si tu veux simuler une calculatrice, tu pourrais demander le premier nombre, puis l'opérateur, et le second nombre si requis.

PierrotLeFou a écrit:

Je ne sais pas comment tu fais en général, mais tes fonctions doivent être très simples.
Pour la fonction carre(), je ferais ceci:
double carre(double a) {
    return a*a;
}
Est-ce que tu demandes les nombres avant l'opérateur?
Si tu inversais, tu pourrais vérifier si c'est une opération unaire et ne demander qu'un seul nombre.
Si tu veux simuler une calculatrice, tu pourrais demander le premier nombre, puis l'opérateur, et le second nombre si requis.

Je déclare les fonctions avant la fonction main.

Pour l'exo, je me suis servi d'un if....else.

Sur le carré ça me permet de ne demander qu'un nombre en cin >>
Et ça me permet d'utiliser les conditions 

gbdivers a écrit:

rouIoude a écrit:

Comme par exemple retourner une valeur par une variable passée par référence à la fonction.

La, en l'occurrence, ce n'est pas une bonne idée.

On n'est bien d'accord qu'il n'y a pas besoin de deux paramètres, je voyais ça comme un exercice où l'on doit retourner deux valeur.

Dans ce cas tu retournerais une pair comme ceci :

#include <iostream>

auto carre(double a, double b)
{
    auto result = std::make_pair(a*a, b*b);

    return result;
}

int main()
{
        auto result = carre(3, 4);

        std::cout << "Le carre de " << 3 << " est " << result.first << std::endl ;
        std::cout << "Le carre de " << 4 << " est " << result.second << std::endl ;
}

ou plutôt un array vu que c'est le même type, ou autre chose ?
 

rouIoude a écrit:

Comme par exemple retourner une valeur par une variable passée par référence à la fonction.

C'est assez old school comme fonctionnement, et assez "asymétrique" (une valeur est retournée, l'autre modifiée en paramètre).
Tu peux effectivement renvoyer un std::pair (comme dans ton dernier message) ou créer une petite structure à deux champs et renvoyer un objet de ce type.

Dans tous les cas, il y a un problème de conception : ça ne veut rien dire, une fonction carre() qui prend deux paramètres. On ne mélange pas tout. La fonction carre(), elle doit prendre un paramètre et renvoyer son carré (comme l'a écrit Pierrot). A toi ensuite de l'appeler sur tes deux valeurs.

cvanaret a écrit:

C'est assez old school comme fonctionnement, et assez "asymétrique" (une valeur est retournée, l'autre modifiée en paramètre).

Non seulement, ce serait "old school" comme pratique, mais, dans le cas présent, on peut carrément partir du principe que cela contreviendrait à un principe primordial de SOLID: le SRP (mis pour Single Responsability Principle ou, si tu préfère en francais: principe de la responsabilité unique).

Ce principe nous dit en effet que chaque "chose" (chaque donnée, chaque fonction, chaque type de donnée) ne doit servir qu'à une seule chose, mais doit s'en occuper correctement.

Une fonction qui devrait calculer deux résultats différents basés sur deux données différentes se retrouve en effet à avoir ... deux responsabilités, à devoir faire deux choses différentes.  Et ca, ca se met en contradiction avec le SRP

Si, encore, le retour de la fonction n'était utilisé que pour s'assurer de la réussite (ou de l'échec) de la fonction et qu'il n'y avait qu'une seule valeur transmise en paramètre et qui serait en plus susceptible d'être modifiée par la fonction, ca pourrait ** éventuellement ** passer, bien que le lancement d'une exception (vu que l'on est quand même en C++, n'est-ce pas ), mais ce n'est clairement pas le but recherché .

Et puis, le plus gros problème vient, effectivement, de l’asymétrie dont tu parle, car, cela impliquerait que nous aurions deux valeurs de départ (A et B), valant (par exemple) respectivement 3 et 5 avant l'appel de la fonction et que, après l'appel, A vaudrait toujours 3 alors que B vaudrait désormais ... 25.

La bonne question serait alors: que faire si l'on veut pouvoir disposer de la valeur d'origine de B après avoir appelé cette fonction ?  et surtout: comment faire pour savoir quelle donnée contient une valeur "modifiée"?

Bien sur, s'il n'y avait pas des solution, il n'y aurait pas de problème.  Mais n'est-il pas plus simple de faire en sorte qu'aucune des deux données fournissant les valeur de départ ne soit modifiée ?