Metoda dodająca ułamki w klasie, problem.

Witajcie nie wiem dlaczego źle dodaje mi wartości.

Kod:

#include<string>
#include<conio.h>
#include<stdio.h>
#include<iostream>

using namespace std;

class cUlamek
{

private:
	int l, m;

public: 

	

	
	//Metody
	void wypisz();
	void pobierz();
	void skroc();
	cUlamek dodawanie(cUlamek X, cUlamek Y);
	

	//cOsoba();
	~cUlamek();
	cUlamek();
	cUlamek(int l, int m);
	cUlamek(const cUlamek &abc);




};


void cUlamek::skroc()
{
	int l, m, pom;

	l = this->l;
	m = this->m;

	
	int max = l;
	int min = m;
	if (m > max) 
	{
		max = m; min = l;
	}

	do{
		pom = max % min;
		max = min;
		min = pom;
	} while(pom != 0);

	l = l / max;
	m = m / max;

	this->l = l;
	this->m = m;

	
	

	

	



}
cUlamek::cUlamek()
{
	this->l = 1;
	this->m = 2;

	cout << "\nKonstruktor zadzialal: \n\n";
}
cUlamek::cUlamek(const cUlamek &abc)
{
	this->l = l;
	this->m = m;
}

cUlamek cUlamek::dodawanie(cUlamek X, cUlamek Y)
{
	cUlamek Z(l,m);
	

	this->l = X.l+Y.l;
	this->m = X.m+Y.m;


	return Z;
}

void cUlamek :: pobierz()
{
	int l, m;

	cout << "Wprowadz licznik: ";
	cin >> l;

	cout << "Wprowadz mianownik: ";
	cin >> m;

	cout << "\n";

	this->l = l;
	this->m = m;
}



void cUlamek::wypisz()
{
	cout << l << "/" << m<<"\n";
}

cUlamek::~cUlamek()
{
	cout << "\n\n Destruktor zadzialal.       ";
	system("pause");
}

cUlamek::cUlamek(int l, int m)
{
	cout << "\nKonstruktor zadzialal: \n\n";
	this->l = l;
	this->m = m;
	
}




int main()
{

	int l=0, m=0;
	
	/*
	cout << "Wprowadz licznik: ";
	cin >> l;

	cout << "Wprowadz mianownik: ";
	cin >> m;

	

	cout << "\n";
	*/

	cUlamek pierwsza(l,m);
	pierwsza.pobierz();
	pierwsza.skroc();
	pierwsza.wypisz();
	
	
	cUlamek C(3,4);
	//C.skroc();
	

	cUlamek Z;
	Z=Z.dodawanie(C, C);
	Z.wypisz();


	
	


	_getch();
}

Wiecie może dlaczego?

No źle Ci dodaje, bo tak ułamków się nie dodaje:

 
this->l = X.l+Y.l;
this->m = X.m+Y.m;

Czas na przypomnienie sobie informacji o ułamkach...

@twonek

Co źle sprawdziłem?

cUlamek cUlamek::dodawanie(cUlamek X, cUlamek Y)

{
    cUlamek Z(4, 4);
    /*int pom = 0, mian=0;
    pom = X.m;

    X.l = X.l*Y.m;
    X.m = X.m*Y.m;

    Y.l = Y.l*pom;
    Y.m = Y.m*pom;

    mian = X.m;

    Z.l = X.l + Y.l;
    Z.m = mian;*/

  
    return Z;
}


//main



cUlamek C(3, 4);



cUlamek D;

    D=D.dodawanie(C, C);
    D.wypisz();

i wyświetla wartości tak jakby w ogóle nie były przypisane w pamięci

Jakoś tego nie widzę: http://ideone.com/sKXQCX

twonek napisał(a):

Jakoś tego nie widzę: http://ideone.com/sKXQCX

A ten kod powinien działać już prawidłowo?

cUlamek cUlamek::dodawanie(cUlamek X, cUlamek Y)
{
	cUlamek Z(l,m);
	int pom = 0, mian=0;
	pom = X.m;

	X.l = X.l*Y.m;
	X.m = X.m*Y.m;

	Y.l = Y.l*pom;
	Y.m = Y.m*pom;

	mian = X.m;

	Z.l = X.l + Y.l;
	Z.m = mian;

	Z.skroc();
	return Z;
}

Jak dla mnie dla danych wejściowych:

cUlamek C(1, 1);
	

	cUlamek Z;
	Z=Z.dodawanie(C, C);
	Z.wypisz();

Powinno wyjść: 1/1

A jest: 65005/201089652 - co znów zrobiłem źle xD?

@Edit

A dla takiego tylko kodu:

cUlamek cUlamek::dodawanie(cUlamek X, cUlamek Y)
{
cUlamek Z(l, m);
 
 
Z.l = X.l + Y.l;
Z.m = X.m + Y.m;
Z.skroc();
 
return Z;
}

int main()
{
cUlamek C(3, 4);
cUlamek D;
 
D=D.dodawanie(C, C);
D.wypisz();
}

Wywala takie coś: https://ideone.com/uKbfJD - co to są za cyrki? Nie powinno być po prostu 6/8 ? Co robię źle?

@Edit 2

Mój kod miał błąd w konstruktorze kopiującym, który podał sam ćwiczeniowiec(zauważył to @kaczus):

tj.:

cUlamek::cUlamek(const cUlamek &abc)
{
    this->l = l;
    this->m = m;
}

Teraz napisałem go tak:

cUlamek::cUlamek(const cUlamek &abc)
{
	l = abc.l;
	m = abc.m;

}

I mój kod:

cUlamek cUlamek::dodawanie(cUlamek X, cUlamek Y)
{
	cUlamek Z(l, m);
	int pom = 0, mian = 0;
	pom = X.m;

	X.l = X.l*Y.m;
	X.m = X.m*Y.m;

	Y.l = Y.l*pom;
	Y.m = Y.m*pom;

	mian = X.m;

	Z.l = X.l + Y.l;
	Z.m = mian;

	Z.skroc();
	return Z;
}

Działa już.

Dzięki za pomoc wszystkim.

Konstruktor kopiujący masz skopany