#include<iostream>
#include<stdlib.h>
#include<stdio.h>
#include <string>
using namespace std;

class Ratio 
{
private:
	int zaehler;
	int nenner;
	int Vorz;

public:

	void minus (const Ratio& r);
	void Multiplikation (const Ratio r);
	void Addition (const Ratio& r);
	void Subtraktion (const Ratio& r);
	void Kuerze (const Ratio& r);
	void Division (const Ratio& r);

	Ratio ();
	Ratio (int zaehler, int nenner=1);
	Ratio (const Ratio & bruch);				

	//~Ratio();			

	void Kehrwert ();
	void Eingabe ();
	void Ausgabe ();
};

int ggt (int zaehler,int nenner);

void main ()
{

Ratio a (34,45); // hier möchte ich Werte eingeben (Bruch 1)
Ratio b (45,78); // hier möchte ich Werte eingeben (Bruch 2)
cout<<"__________________________________________________"<<endl;
Ratio br1 (a);
Ratio br2 (b);
a.Multiplikation(b);
Ratio mult (a);

a.Addition(b);
Ratio add (a);

a.Subtraktion(b);
Ratio sub (a);

b.Kehrwert();
Ratio kehr (b);

a.Multiplikation(b);
Ratio div (a);

//*******Ausgaben****************//
cout<<"Bruch 1:	";  a.Ausgabe();
cout<<"Bruch 2:	";  b.Ausgabe();
cout<<"Bruch 1 (Kopie)	";  br1.Ausgabe();
cout<<"Bruch 2 (Kopie)";  br2.Ausgabe();
cout<<"Multiplikation:	";  mult.Ausgabe();
cout<<"Addition:	";  add.Ausgabe();
cout<<"Subtraktion:	";  sub.Ausgabe();
//cout<<"Kehrwert:	";  kehr.Ausgabe();
cout<<"Division:	";  div.Ausgabe();
cout<<"__________________________________________________"<<endl;

system ("pause");
}

//Methoden*******************************************************

	Ratio::Ratio ()
	{

	}
	Ratio::Ratio (int zaehler, int nenner)
	{	
		zaehler=45;
	nenner=34;
	}
	Ratio::Ratio (const Ratio & bruch)				

	{
		zaehler=bruch.zaehler;
		nenner=bruch.nenner;
	}
	////////////////////

void Ratio::Eingabe ()
{
	Ratio r;
	cin>>zaehler;
	cin>>nenner;
	if (nenner==0)
	{
		cerr<<"Nenner darf nicht 0 sein! Bitte korrigieren Sie Ihre Eingabe."<<endl; 
		Eingabe();
	}

}
void Ratio::Ausgabe ()
{
	Ratio r;
	if (nenner==0)
	{
		cerr<<"ERROR: Nenner=0"<<endl;
		return;
	}

	 if (zaehler !=0)
	 {

	minus(r);
	Kuerze(r); 
	switch(Vorz)
{
 case 1: zaehler=zaehler;
          break;

 case 2: zaehler=zaehler*-1;
          break;

 case 3: zaehler=zaehler*-1;
          break;

 case 4: zaehler=zaehler;
		}
	 }
	if (zaehler%nenner==0)
	{
	cout<<zaehler/nenner<<endl;
	}
	else
	{
	cout<<zaehler<<"/"<<nenner<<endl;
	}

}
void Ratio::Kehrwert()
{
	Ratio r;
	//cout<<"zaehler: "<<zaehler<<"/"<<"nenner:"<<nenner<<endl;
	r.zaehler=nenner;
	r.nenner=zaehler;
	zaehler=r.zaehler;
	nenner=r.nenner;

}
void Ratio::Multiplikation(Ratio r)
{
nenner=nenner*r.nenner;
zaehler=zaehler*r.zaehler;
}

void Ratio::Addition(const Ratio& r)
{

zaehler=(zaehler*r.nenner)+(nenner*r.zaehler);
nenner=nenner*r.nenner;
}
void Ratio::Kuerze(const Ratio& r)
{
	//cout<<"Kuerze"<<endl;
    int ggt_nz;
    do
    {
        ggt_nz = ggt(zaehler,nenner);
        nenner /= ggt_nz;
        zaehler /= ggt_nz;
    } while(ggt_nz != 1);

}
int ggt(int a, int b)
{
	//cout<<"ggT"<<endl;
while(a != b)
{
if (a>b)
a = a-b;
else
b = b-a;
}
return(a);
}
//////////////////////////////////////////////////////////////

void Ratio::minus (const Ratio& r)
{
if (nenner<0 && zaehler<0)
	{
		//cout<<"Vorzeichen aenderung! (0)"<<endl;
		nenner=nenner*(-1);
		zaehler=zaehler*(-1);
		//cout<<"1"<<endl;
		Vorz=1;
		return;
	}
if (nenner>0 && zaehler<0)
	{
		//cout<<"Vorzeichen aenderung! (0)"<<endl;

		zaehler=zaehler*(-1);
		//cout<<"2"<<endl;
		Vorz=2;
		return;
	}
if (nenner<0 && zaehler>0)
	{
		//cout<<"Vorzeichen aenderung! (1)"<<endl;
		nenner=nenner*(-1);
		//cout<<"3"<<endl;
		Vorz=3;
		return;
	}
if (nenner>0 && zaehler>0)
	{
		//cout<<"4"<<endl;
		Vorz=4;
		return;
	}

}
void Ratio::Subtraktion(const Ratio& r)
{
	zaehler=(zaehler*r.nenner)-(r.zaehler*nenner);
	nenner=nenner*r.nenner;
}

welche Zeilen sollen relevant sein? ich kann noch editieren und die unwichtigen rausnehmen. es geht nur um wertezuweisung mittels allgemein konstruktor

Kannst du vielleicht mal erklären, was genau du erwartet hast und was nicht mit deinen Erwartungen übereinstimmt? Wenn ich so den Code sehe, erkenne ich nicht wo dein Problem liegt...

Ratio a (34,45); // hier möchte ich Werte eingeben (Bruch 1) 
Ratio b (45,78); // hier möchte ich Werte eingeben (Bruch 2)

doch bei der ausgabe werden irgendwelche komische werte mit -348984334 oder so angezeigt. Kann mein Fehler nicht finden, und hab daher auch das ganze prog. einfach gepostet

Dabei werden den beiden Parametern diese Werte zugewiesen, weil die genauso heißen wie die Member. Abhilfe schafft this->

Ratio::Ratio (int zaehler, int nenner)
    {   
        this->zaehler=45; //was soll das eigentlich? meintest wohl zaehler = zaehler? dann wäre dir der fehler wohl auch aufgefallen
    this->nenner=34;
    }

Noch besser wäre aber das initialisieren mit einer Initialisierungsliste:

Ratio::Ratio(int n, int z) : nenner(n), zaehler(z) {}

Wenn du nicht wießt, was das ist, google es einfach mal.

Ratio::Ratio (int zaehler, int nenner) 
    {   
        this->zaehler=zaehler; 
	this->nenner=nenner; 
    }

Aber für solche Zuweisungen ist wirklich die Initialisierungsliste besser geeignet.

Hier macht es absolut keinen Unterschied. Initialisierungslisten sind sinnvoll für Klassen, Konstanten (wo es ein muss ist) o.ä. im Allgemeinen sollte man sich nicht immer gleich für eine Initialisierungsliste Entscheiden, manchmal sind auch einfache Funktionen besser (wenn du z.B. mehr als 10 Objekte initialisieren musst), die das Objekt dann auch gleich konfigurieren.

Incocnito schrieb:

Aber für solche Zuweisungen ist wirklich die Initialisierungsliste besser geeignet.

Hier macht es absolut keinen Unterschied. Initialisierungslisten sind sinnvoll für Klassen, Konstanten (wo es ein muss ist) o.ä. im Allgemeinen sollte man sich nicht immer gleich für eine Initialisierungsliste Entscheiden, manchmal sind auch einfache Funktionen besser (wenn du z.B. mehr als 10 Objekte initialisieren musst), die das Objekt dann auch gleich konfigurieren.

Warum? Die Initialisierungsliste ist niemals die schlechtere Wahl.

Hacker schrieb:

Incocnito schrieb:

Aber für solche Zuweisungen ist wirklich die Initialisierungsliste besser geeignet.

Hier macht es absolut keinen Unterschied. Initialisierungslisten sind sinnvoll für Klassen, Konstanten (wo es ein muss ist) o.ä. im Allgemeinen sollte man sich nicht immer gleich für eine Initialisierungsliste Entscheiden, manchmal sind auch einfache Funktionen besser (wenn du z.B. mehr als 10 Objekte initialisieren musst), die das Objekt dann auch gleich konfigurieren.

Warum? Die Initialisierungsliste ist niemals die schlechtere Wahl.

Was ich meinte war, dass man nicht penibel auf das benutzen von Initialisierungslisten achten sollte, an Stellen wo es sowieso keinen Unterschied macht, so wie hier. Und das mit dem niemals: du meinst, dass man jeden Member mit der Initialisierungsliste initialisieren sollte (das wäre nähmlich manchmal hässlich, außer vielleicht eine Default-Initialisierung)?

Natürlich sollte man darauf achten. Wenn man initialisieren will, nimmt man die Initialisierungsliste.

-.-. Gut gut, habt schon Recht. Jetzt wo ich es bemerke, meinte ich etwas eigentlich eher zusammenhangloses...