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

**iDanz** · 26/07/2009, 23h52

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** · 27/07/2009, 00h11

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** · 27/07/2009, 00h32

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** · 27/07/2009, 00h37

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** · 27/07/2009, 00h42

Ok merci pour l'info

**koala01** · 27/07/2009, 09h33

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

**JolyLoic** · 27/07/2009, 10h44

Envoyé par 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.

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

**ram-0000** · 27/07/2009, 10h48

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.

**Goten** · 27/07/2009, 10h59

Non directement le constructeur par recopie dans le cas :

Code :

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

1
2
Cclass y;
Cclass x = y;

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

Code :

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

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

**koala01** · 27/07/2009, 11h27

Envoyé par Goten

Non directement le constructeur par recopie dans le cas :

Code :

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

1
2
Cclass y;
Cclass x = y;

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

Code :

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

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 :

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

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

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

Code :

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

Fraction f("35/8");

**Goten** · 27/07/2009, 11h35

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

Ma remarque reste valable toute fois pour :

Code :

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

Fraction f = 35/8;

**koala01** · 27/07/2009, 11h47

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 :

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

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 :

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

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 :

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

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

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

**Goten** · 27/07/2009, 11h57

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).

**Davidbrcz** · 27/07/2009, 12h33

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

**koala01** · 27/07/2009, 12h42

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

... je mérite le

)

**JolyLoic** · 27/07/2009, 18h54

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.

**ram-0000** · 27/07/2009, 18h57

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) ?

**Goten** · 27/07/2009, 18h58

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

**Jean-Marc.Bourguet** · 27/07/2009, 19h19

Code :

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

C c(exp);

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

Code :

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

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.

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

Langage C++

Discussions similaires

Partager

Partager