was mache ich falsch? (klasse, konstruktor)

[Sirius7]

hallo, ich möchte, dass die Werte im main mittels allg. konstruktor geladen werden.. doch das programm gibt immer wieder dasselbe raus, was mache ich falsch?

#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;
}

[Gast]

Fassen wir zusammen: Du gibst uns 235 Zeilen Code mit einem mickrigen Erklärungssatz als Fehlerbeschreibung? Reicht!

[Sirius7]

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

[Gast]

Sirius7 schrieb:

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

[Sirius7]

ich habe eigentlich erwartet, dass ich die Werte für brüche per allgemein Konstruktor in main fuktion eingeben kann.
ungefähr so:

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

[Incocnito]

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

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.

[Sirius7]

perfekt das funzt!)) vielen Dank!
hab solche code benutzt

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

[Incocnito]

Aber für solche Zuweisungen ist wirklich die Initialisierungsliste besser geeignet. Verwende die also und setzte dich kurz mit ihr auseinander.
So erkennt man nämlich sofort, wo was initialisiert und wo was anderes gemacht wird. Es wäre vollkommen unlogisch, sie nicht zu verwenden, da sie eben genau dafür gemacht wurde
Gewöhn dir also solche Zuweisungen im Konstruktor ab und benutz ne Initialierungsliste, wie das geht hab ich dir ja schon gezeigt.

[Sirius7]

alles klar, mache ich auf jeden Fall, sieht auch viel vernünftiger aus) vielen dank noch mal!

[Gast]

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.

[SeppJ]

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.

[Gast]

SeppJ schrieb:

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

[cooky451]

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

[Gast]

cooky451 schrieb:

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