Surcharges d'opérateurs, constructeurs et passage de double en int

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 :

Citation:

---

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:

---

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:

---

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 :

Citation:

---

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

---

Cette fois-ci on doit donc pouvoir écrire :

Code:

---

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 :-°

Citation:

---

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:

---

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

il y'a au moins une erreur ici

Code:

---

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.

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 :D

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.

Ok merci pour l'info :)

Salut, et bienvenue sur le forum.

Fais déjà attention au fait que

Code:

---

Fraction f = 35/8;

---

est tout à fait différent de

Code:

---

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:

---

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 ;) */

---

Citation:

---

Envoyé par koala01

Salut, et bienvenue sur le forum.

Fais déjà attention au fait que

Code:

---

Fraction f = 35/8;

---

est tout à fait différent de

Code:

---

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.

---

Dans les deux cas, il s'agit d'un constructeur qui est appelé, pas de l'opérateur d'affectation.

Citation:

---

Envoyé par JolyLoic

Dans les deux cas, il s'agit d'un constructeur qui est appelé, pas de l'opérateur d'affectation.

---

Heu, les 2 ne sont pas appelés ? D'abord le constructeur pour créer un objet temporaire et l'opérateur d'affectation ensuite pour effectuer l'affectation justement.

Non directement le constructeur par recopie dans le cas :

Code:

---

1 2	Cclass y; Cclass x = y;

---

Ou le constructeur surchargé si on passe un argument comme il fait :

Code:

---

1 2 3

Fraction f = "4/38"; // revient à écrire : Fraction f("4/38");

---

Citation:

---

Envoyé par Goten

Non directement le constructeur par recopie dans le cas :

Code:

---

1 2	Cclass y; Cclass x = y;

---

Ou le constructeur surchargé si on passe un argument comme il fait :

Code:

---

1 2 3

Fraction f = "4/38"; // revient à écrire : Fraction f("4/38");

---

---

oui, si tu dispose d'un constructeur qui prend prend un ... char * comme argument...

Si ton constructeur prend une std::string (ce qui serait conseillé) en argument, tu devra, au mieux, utiliser le code

Code:

---

Fraction f=std::string("35/8");

---

l'idéal étant d'utiliser que le constructeur

Code:

---

Fraction f("35/8");

---

Exacte, me suis emmêlé les pinceaux entre les différentes versions. string vs int.

Ma remarque reste valable toute fois pour :

Code:

---

Fraction f = 35/8;

---

Citation:

---

Envoyé par Goten

Exacte, me suis emmêlé les pinceaux entre les différentes versions. string vs int.

Ma remarque reste valable toute fois pour :

Code:

---

Fraction f = 35/8;

---

---

Mais là, tu perd le numérateur et le dénominateur, ainsi que je l'ai signalé.

Ta fraction ne peut donc plus être considérée sous une forme proche de

Code:

---

1 2 3 4 5

struct Fraction { int numerateur; unsigned int denominateur; };

---

parce que, le calcul étant effectué trop tôt, 35/8 est évalué à 4.375.

Tu devra donc rajouter un constructeur prenant... un réel en argument (float ou double), et tu sera *naturellement* tenté d'initialiser ton dénominateur sur base décimale (1, 10, 100, 1000, ...)

Or, si pour une raison ou une autre, tu en viens à faire

Code:

---

1 2	Fraction f=35/8; /* mettons que l'un des constructeurs l'accepte */ f.numerateur+=1;

---

tu obtiendra 4376 /1000 au lieu de... 36 / 8, ce qui n'est absolument pas pareil :aie:

Or, mais je réfléchis peut être un peu trop sur base d'un "simple" exercice, si tu en viens à envisager la création d'une structure pour représenter une fraction, c'est a priori parce que tu souhaite manipuler la... fraction aussi longtemps que possible en étant sur du résultat obtenu suite aux différentes opérations tant sur le numérateur que sur le dénominateur ;)

Oh mais moi je souhaite rien du tout, n'étant pas le PO.
Et je suis tout à fait d'accord avec toi, si j'avais a écrire une telle structure un string me semblerait le plus approprié pour toute les raisons exposé.
La seule raison de mon intervention était le côté technique. (et du coup un peu hors sujet).

Citation:

---

35/8 est évalué à 4.375.

---

Petite remarque un peu HS.
Ce sont des entiers, le résultat c'est 4. Pour avoir la valeur exacte, il faut au moins un chiffre avec une virgule (35. ou 8.)

PS: le même topic existe (mot pout mot) sur le sdz, pas bien les multi topic :p

Citation:

---

Envoyé par Davidbrcz

Petite remarque un peu HS.
Ce sont des entiers, le résultat c'est 4. Pour avoir la valeur exacte, il faut au moins un chiffre avec une virgule (35. ou 8.)

PS: le même topic existe (mot pout mot) sur le sdz, pas bien les multi topic :p

---

Raison de plus ;) (comment ai-je pu passer à coté de ca :question::aie:... je mérite le :sm:)

Citation:

---

Envoyé par ram-0000

Heu, les 2 ne sont pas appelés ? D'abord le constructeur pour créer un objet temporaire et l'opérateur d'affectation ensuite pour effectuer l'affectation justement.

---

Il n'y a jamais d'opérateur d'affectation appelé lors d'une initialisation de variable, toujours un constructeur, éventuellement par recopie.

Citation:

---

Envoyé par JolyLoic

Il n'y a jamais d'opérateur d'affectation appelé lors d'une initialisation de variable, toujours un constructeur, éventuellement par recopie.

---

OK, je te crois. Mais alors quand est ce que est utilisé l'opérateur d'affectation, dans le cas d'une réaffectation (ce n'est plus une initialisation dans ce cas) ?

La réponse est dans ta question là! x)

Code:

---

C c(exp);

---

demande qu'il y ait un constructeur à partir de exp, éventuellement après conversion implicite.

Code:

---

C c = exp;

---

demande qu'il y ait un constructeur à partir de exp sans conversion implicite et un constructeur de copie accessible (même s'il peut être élidé, il doit être accessible).

Dans le cas présent, avoir un constructeur à partir de std::string sans avoir de constructeur à partir de char const* ferait que la première forme fonctionne et pas la seconde.