Discussion :

[iDanz]

Bonsoir à toutes et à tous,
Il y a peu, je me suis décidé à faire un exercices qu'on peut trouver sur internet, un exercice qui nous proposait de créer une classe qui gérait les fonctions.
Je m'y suis alors attelé et, bien évidemment, je me suis heurté à quelques obstacles.
J'attends donc vos avis, conseils d'impatience

Mais sans plus attendre, les proooooooblèèèmeeees :-° .

Appel de constructeur

Tout d'abord, je cite Nanoc dans le cahier des charges de la fonction :

3) Construction à partir d'une chaine de caractère de la forme "35/8" (sans les "").

On doit donc être capable d'appeler un constructeur qui gère ce cas :

Code :

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

Fraction maFraction = 35/8;

Ma question porte donc sur le type du constructeur surchargé. Je me demande quel type doit-il prendre en compte. Un string ? Ce qui nous donnerait :

Code :

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

1
2
3
4
5
 
Fraction::Fraction(std::string fraction)
{
   // L'implémentation du constructeur
}

Ou un autre type ?

Si c'est bel est bien un string que le constructeur attends, alors il faudra sans doute réussir à séparer la chaîne en deux. Faudrait-il alors recréer une fonction qui sépare cette chaîne ?

Passage de double en int

Toujours pour citer ce cher Nanoc :

2) Construction à partir d'un nombre à virgule (double).

Cette fois-ci on doit donc pouvoir écrire :

Code :

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

Fraction maFraction = 2.38;

Et les deux attributs de ma classe (m_numerateur et m_denominateur) doivent être égaux respectivement à 238 et 100.
Le seul problème, c'est que je me doute qu'il faut multiplier par 10 jusqu'à avoir un nombre entier, le seul problème est de savoir QUAND a-t-on cet entier ? Quel test permet de le montrer ?

Surcharge d'opérateur ?

Finalement, et puisque j'aime bien les citations :-°

8) Proposer un moyen de connaître le dénominateur et le numérateur.

Faire ceci à l'air simple à première vue. On pourrait se contenter d'utiliser des accesseurs getNumerateur() et getDenominateur().
Mais j'ai des ambitions plus (trop ?) grande ^^
J'aimerais bien essayé de surcharger un opérateur, un peut comme [] pour les tableaux.
Ma question est donc, est-il possible de faire ça :

Code :

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

1
2
3
4
5
6
7
8
 
int Fraction::operator()(const int nombre)
{
   if (nombre = 0)
      return m_numerateur;
   else
      return m_denominateur;
}

Valal'

Merci de m'avoir lu ^^
iDanz

[jabbounet]

il y'a au moins une erreur ici

Code :

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

1
2
3
4
5
   if (nombre == 0)
      return m_numerateur;
   else
      return m_denominateur

sinon tu affecte nombre a zero et retourne toujours la même chose.

[Dalini71]

Salut,

Pour l'appel du constructeur, tu pourrais recevoir ton paramètre sous forme de String, et tu compares tous les éléments afin de différencier les chiffres et le reste (y compris le "/").

Pour le passage par double, moi je créerais une String pour y mettre ce double, tu y trouve le point, tu comptes le nombre de chiffres après, ensuite tu peux reprendre ton double car tu sauras tout ce qu'il faut.

Pour la surcharge de l'opérateur (), j'ai pas bien compris comment tu veux l'utiliser, mais ça ne me paraît pas super intuitif. De plus surcharger l'opérateur ()... Ça doit surement se faire, mais je ne l'ai jamais vu, doit bien y avoir une raison, mais j'ai pas trop confiance. Enfin test et reviens me dire, ça m'intéresse

[Goten]

Sisi la surcharge de l'opérateur () c'est commun. Ca permet que ton objet se comporte comme une fonction, ça s'appelle un foncteur. for_each() par exemple utilise se genre de chose.

[Dalini71]

Ok merci pour l'info

[koala01]

Salut, et bienvenue sur le forum.

Fais déjà attention au fait que

Code :

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

Fraction f = 35/8;

est tout à fait différent de

Code :

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

Fraction f = "35/8";

et que, quoi que l'on en dise, les deux possibilités font en réalité intervenir l'opérateur d'affectation, et non le constructeur.

En effet, la première possibilité va, de manière cachée, calculer 35/8 et va assigner le résultat (4.375) à ta variable f, ce qui te retire toute possibilité de retrouver la fraction d'origine ("naturellement" on pensera bien sans doute bien plus facilement à une fraction proche de 4375/1000 qu'à 35/8 )

La deuxième possibilité va utiliser une "chaine de caractères" (pour laquelle je te conseillerais d'utilliser std::string) et te donne "relativement facilement" la possibilité de récupérer la fraction de départ (en prenant respectivement ce qui se trouve à gauche et ce qui se trouve à droite du " / " )

Cette possibilité permettra sans doute bien plus de choses (pouvant, éventuellement, s'adapter à des flux "texte", tels que l'entrée standard ou la lecture de fichiers).

Pour ne faire appel qu'aux constructeurs, et dans les même limites, les possibilités envisageables seraient:

Code :

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

1
2
3
4
5
6
Fraction f; /*appel du constructeur par défaut */
/* appel d'un constructeur prenant un numérateur et un dénominateur */
Fraction f2(35, 8);
/* appel d'un constructeur prenant une chaine de caractères */ 
Fraction f3("35/8");
/* peut être d'autre possibilités particulières ;) */