program klasa/przeciążenie operatora działania na ułamkach

Witam serdecznie. Mam następującą prośbę: czy mógłby ktoś wskazać jakie robię błędy w następującym programie:(program ma dodawać dwa ułamki, dodawać liczbę całkowitą do ułamka i zamieniać ułamek zwykły na dzisieiętny a całość ma być zbudowana na następującym schemacie:

plik main.cpp

#include "ulamek.h"
#include <iostream>
using namespace std;

int main()
{
	ulamek z1,z2;
	int i;

	cout<<"Wprowadz dwa ulamki\n";
	cin>>z1>>z2;
	cout<<"Oba ulamki zapisane w postaciach dziesietnych:\n";
	cout<<"ulamek 1.="<<z1.dziesietny()<<"\nulamek 2.="<<z2.dziesietny();
	cout<<"\nWynik dodawania dwoch ulamkow; ";
	cout<<z1+z2;
	cout<<"\nPodaj liczbe calkowita: "<<endl;
	cin>>i;
	cout<<"\nWynik dodawania ulamka i liczby calkowitej:\n";
	cout<<z1+i;
}

plik ulamek.h

class ulamek
{
	int X,Y;
public:	
	int getX() {return X;)
	int getY() {return Y;)
	void setX(int x) {X=x};
	void setY(int y) {Y=y};
	double dziesietny(); 
	friend ulamek operator+(ulamek,ulamek);
	friend ulamek operator+(ulamek,int);
	
};
istream& operator>> (istream&, ulamek&)
ostream& operator<<(ostream&, ulamek&)

plik ulamek.cpp

#include "ulamek.h"
#include <iostream>

using namespace std;

double ulamek:: dziesietny()
{
	return a.X/a.Y;
}

ulamek operator+(ulamek a,ulamek b)
{
	a.X=a.X*b.Y+a.Y*b.X;
	a.Y=a.Y*b.Y;
	return a;
}

ulamek operator+(ulamek a,int b)
{
	a.X=a.X+a.Y*b;
	return a;
}

istream& operator>> (istream& in, ulamek& z)
{
	double x,y;
	in>>x;
	in>>y;
	z.setX(x);
	z.setT(y);
	return in;
}

ostream& operator<<(ostream& out, ulamek& z)
{
	out<<z.getX()<<"/"<<z.getY()<<endl;
	return out;
}

shameless napisał(a)

czy mógłby ktoś wskazać jakie robię błędy w następującym programie

Tak. Kompilator.

Pokaz mi swe błedy.

Może nie wszystko stracone...
Moze uda sie je jeszcze naprawic...

Pomimo kilku uchybień (źle postawione średnikki i nawiasy w pliku .h), niekonsekwencji (raz przekazujesz ułemek przez referencje, raz przez wartość) głównym problemem jest metoda dziesietny(). Jest to metoda klasy ulamek, żeby się odwołać do pola X nie musimy pisać cośtam.X tylko wystraczy samo X. Dodatkowo dzielenie nie może być całkowite, więc trzba rzutować X na typ double:

double ulamek::dziesietny()
{
        return (double)X / Y;
}

adf88 to rzutowanie często nic nie daje, bo kompilator widzi ze są dwa inty i dzieli je dzieleniem całkowitym.
Czasami trzeba dodać do którejś z liczb 0.0 i dopiero zacznie dzielić zmiennoprzecinkowo.

@down teraz nie, bo mam na lapku tylko code blocks, ale pamiętam ze małem kiedyś taki problem

Shalom napisał(a)

adf88 to rzutowanie często nic nie daje, bo kompilator widzi ze są dwa inty i dzieli je dzieleniem całkowitym.
Czasami trzeba dodać do którejś z liczb 0.0 i dopiero zacznie dzielić zmiennoprzecinkowo.
Kurde nie wiedziałe, a potrafisz przytoczyć jakie kompilatory tak nieładnie się zachowują ?

Hola hola wędrowcze... Rzutowanie ma wyższy priorytet niż dzielenie. Znaczy, że w wyrażeniu

result = (double)X / Y;

X zostanie zamieniony na double i kompilator to musi potraktować jako dzielenie double / int - czyli zmiennoprzecinkowe.

Uwaga byłaby bardzo ciekawa, gdyby była trafna...

dopisane @adf niżej:
a tak jakoś mi się wydawało, że wiesz, ale chciałem się popisać że ja też wiem, i czasem dział obserwuję :>

To to ja wiem, jakbym nie był pewien to bym napisał "((double)x)". Podobno jakiś kompilator tego nie respektuje, ciekawi mnie jaki.