la fonction getDecimal retourne 0. Je sais pas pourquoi.

Bonjour,

Je suis un débutant en c++. Je travaille avec c++ depuis 1 mois à l'aide de poo. Il y a un problème dans ma fonction(getDecimal) parce que ça retourne toujours 0.

fraction.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef FRACTION_H
#define FRACTION_H
#include <iostream>
#include <string>
using namespace std;
 
class fraction
{
private:
	int m_numerateur;
	int m_denominateur;
 
public:
	fraction(int arg1 = 0,int arg2 = 1);
	int getDenominateur() const;
	int getNumerateur() const;
	void setDenominateur(int x);
	void setNumerateur(int x);
	void getFraction() const;
	double getDecimal() const;
};
#endif

head.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#include <iostream>
#include "fraction.h"
using namespace std;
 
fraction::fraction(int arg1,int arg2)
{
	m_numerateur = arg1;
	m_denominateur = arg2;
}
 
int fraction::getDenominateur() const
{
	return m_denominateur;
}
 
int fraction::getNumerateur() const
{
	return m_numerateur;
}
 
void fraction::setNumerateur(int x)
{
	m_numerateur = x;
}
 
void fraction::setDenominateur(int x)
{
	m_denominateur = x;
}
 
void fraction::getFraction() const
{
	cout << m_numerateur << "/" << m_denominateur;
}
 
void calculer(fraction &arg1,string arg2,fraction &arg3)
{
	fraction resultat;
	int dc;
	int n1;
	int n2;
	int d2;
	int nt;
	if(arg2 == "+")
	{
		if(arg1.getDenominateur() != arg3.getDenominateur())
		{
			dc = arg1.getDenominateur() * arg3.getDenominateur();
			n1 =  arg1.getNumerateur() * arg3.getDenominateur();
			n2 =  arg3.getNumerateur() * arg1.getDenominateur();
			nt = n1 + n2;
			resultat.setNumerateur(nt);
			resultat.setDenominateur(dc);
			resultat.getFraction();
		}
		else
		{
			nt = arg1.getNumerateur() + arg3.getNumerateur();
			resultat.setNumerateur(nt);
			resultat.setDenominateur(arg1.getDenominateur());
			resultat.getFraction();
		}
	}
		if(arg2 == "-")
	{
		if(arg1.getDenominateur() != arg3.getDenominateur())
		{
			dc = arg1.getDenominateur() * arg3.getDenominateur();
			n1 =  arg1.getNumerateur() * arg3.getDenominateur();
			n2 =  arg3.getNumerateur() * arg1.getDenominateur();
			nt = n1 - n2;
			resultat.setNumerateur(nt);
			resultat.setDenominateur(dc);
			resultat.getFraction();
		}
		else
		{
			nt = arg1.getNumerateur() - arg3.getNumerateur();
			resultat.setNumerateur(nt);
			resultat.setDenominateur(arg1.getDenominateur());
			resultat.getFraction();
		}
	}
	if(arg2 == "*")
	{
		nt = arg1.getNumerateur() * arg3.getNumerateur();
		dc = arg1.getDenominateur() * arg3.getDenominateur();
		resultat.setNumerateur(nt);
		resultat.setDenominateur(dc);
		resultat.getFraction();
	}
	if(arg2 == "/")
	{
		n2 = arg3.getDenominateur();
		d2 = arg3.getNumerateur();
		nt = arg1.getNumerateur() * n2;
		dc = arg1.getDenominateur() * d2;
		resultat.setNumerateur(nt);
		resultat.setDenominateur(dc);
		resultat.getFraction();
	}
}
 
double fraction::getDecimal() const
{
	return m_numerateur / m_denominateur;
}

training.cpp

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include "head.h"
using namespace std;
 
int main()
{
	fraction a(2,5);
	fraction b(3,4);
	cout << a.getDecimal();
	cout << endl;
	if(a.getDecimal() > b.getDecimal())
	{
		a.getFraction(); 
		cout << " est plus grand que ";
		b.getDecimal(); 
		cout << endl;
	}
	else if(a.getDecimal() < b.getDecimal())
	{
		b.getFraction(); 
		cout << " est plus grand que ";
		a.getDecimal(); 
		cout << endl;
	}
	system("pause");
	return 0;
}

Bonjour

PilloBuenaGente t'a déjà signalé ce problème. Relis les anciennes discussions

Merci. Je n'avais pas vu. Je suis vraiment désolé.:oops:

Salut,

De plus, une fonction "get" qui ne renvoie rien est, a priori, suspecte.

On pourrait, déjà, pinailler sur le choix de placer des mutateurs sur une fraction, car ca semble en contradiction avec la sémantique de valeur (par contre, des opérateurs mathématiques comme +, -, *, et / pourraient être intéressant), mais, forcer le fait que getFraction renvoie, sommes toutes, une chaine de caractères sur la sortie standard ne me semble vraiment pas opportun:

Il semble dommage de te limiter au seul flux vers la sortie standard
Tu places une dépendance qui t'interdira de faire évoluer ton application en rajoutant une interface graphique par la suite
Personnellement, j'envisagerais plutôt la surcharge de l'opérateur de flux "<<", en veillant à ce qu'il puisse s'adapter à "n'importe quel flux envisageable".

Il faut, en effet, savoir que tous les flux de sorties (qu'il s'agisse de fichier, de flux de conversion ou de la sortie standard) héritent de std::ostream et qu'il serait donc tout à fait possible de faire en sorte que le comportement soit similaire, avec un code proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class fraction { private: int m_numerateur; int m_denominateur; public: std::ostream & operator << (std::ostream & os) const { os<<m_numerateur <<" / " <<n_denominateur; return os; } /* tout le reste sauf getFraction ;) */ };