Objektübergabe-Problem

hallo kann mir mal jemand hier helfen?

Das problem liegt bei der Funktion multiplizieren2()

die daten von objekt b1 und b2 sollen multipliziert werden da sklappt schonmal. und dann soll an b3 der bruch zurückgegebn werden.. nur irtgdnwie klappt da snicht so ganz, kann jemand helfen?

#include <iostream>
#include <stdlib.h>
#include <cmath>

class Bruch{
      private:
              int m_nenner;
              int m_zaehler;
      public:
             Bruch();
             Bruch(int z, int n);
             void ausgeben();
             Bruch multiplizieren2(Bruch be1, Bruch be2);
      };

using namespace std;

// MAIN
int main()
{
cout<<"Erzeugen Sie die Bruche b1=4/12, b2=4/3 und b3"<<endl;
    Bruch b1(4,12);
    Bruch b2(4,3);
    Bruch b3;    

cout<<"\nMultiplizieren Sie b1 mit b2 mit Hilfe der Mitgliedsfunktion multiplizieren2"<<endl;
    b1.multiplizieren2(b2, b3);
    b3.ausgeben();

    system("PAUSE");
    return 0;
}
// END MAIN
// KONSTRUKT
Bruch::Bruch(){
     m_zaehler=1;
     m_nenner=1;
}
Bruch::Bruch(int z, int n){
     m_zaehler=z;
     m_nenner=n;
     }

void Bruch::ausgeben(){
     cout<<"Ausgabe:\nDer Bruch lautet: ("<<m_zaehler<<"/"<<m_nenner<<")"<<endl;
     }

Bruch Bruch::multiplizieren2(Bruch be1, Bruch be2){
     be2.m_zaehler=m_zaehler*be1.m_zaehler;
     be2.m_nenner=m_nenner*be1.m_nenner;
     return be2;

Mizar

Ändere

cout<<"\nMultiplizieren Sie b1 mit b2 mit Hilfe der Mitgliedsfunktion multiplizieren2"<<endl;
    b1.multiplizieren2(b2, b3);
    b3.ausgeben();

in

cout<<"\nMultiplizieren Sie b1 mit b2 mit Hilfe der Mitgliedsfunktion multiplizieren2"<<endl;
    b3 = b1.multiplizieren2(b1, b2); // Ergebnis b3 zuweisen
    b3.ausgeben();

Noch ein paar kleine Anmerkungen:

#include <stdlib.h>

sollte

#include <cstdlib>

heißen, wobei du den Header gar nicht in deinem Code einbinden müsstest. Und Außerdem noch:

system("PAUSE");

Böse, böse ;). In der FAQ gibt es eine Erklärung wie man auch ohne system das Schließen des Konsolenfensters verhindern kann. Siehe folgenden Link:
http://c-plusplus.net/forum/viewtopic-var-t-is-111042.html
EDIT: Irgendwie stelle ich gerade fest, dass das Ergebnis dann nicht mehr ganz korrekt ist. Du solltest dir wohl noch die Berechnung von Bruch multiplizieren2(Bruch be1, Bruch be2); anschauen.
Edit die 2.te: Hah, so wird ein Schuh draus:

class Bruch{ 
      private: 
              int m_nenner; 
              int m_zaehler; 
      public: 
             Bruch(); 
             Bruch(int z, int n); 
             void ausgeben(); 
             void multiplizieren2(Bruch be1, Bruch be2); // Rückgabetyp geändert
      }; 
/* ... */
cout<<"\nMultiplizieren Sie b1 mit b2 mit Hilfe der Mitgliedsfunktion multiplizieren2"<<endl; 
    b3.multiplizieren2(b1, b2); 
    b3.ausgeben();
/* ... */
void Bruch::multiplizieren2(Bruch be1, Bruch be2){ 
     m_zaehler=be1.m_zaehler*be2.m_zaehler; 
     m_nenner=be1.m_nenner*be2.m_nenner; 
}

Rest wie oben von dir gepostet :).

hi, danke für die rasche antwort.

aber kann das stimemn mit dem void?

also hier nochmal die genaue aufgabenstellung, hab ich leider vergessen sry
..

multiplizieren2: multipliziert die beiden im Argument mitgelieferten Br¨ uche zusammen. Das Ergebnis wird einem
dritten Bruch gespeichert, der von der Funktion zur¨ uckgegeben wird. (statische Funktion, ¨ oﬀentlich zug¨ anglich)

und dann in main:

Multiplizieren Sie b1 mit b2 mit Hilfe der statischen Funktion multiplizieren2. Weisen das Ergebnis b3 zu. Geben
Sie das Ergebnis aus.

Mizar

Crisis10 schrieb:

multiplizieren2: [...] (statische Funktion, ¨ oﬀentlich zug¨ anglich)

Das Problem ist schonmal das die von dir gepostete multiplizieren2-Funktion nicht statisch ist. Das Zauberwort heißt in diesem Falle also static:

class Bruch{
/* ... */
public:
    static Bruch multiplizieren2(Bruch be1, Bruch be2); // Deklariert statische, öffentlich zugängliche Elementfunktion
};

Der Aufgabenstellung nach müsste diese so definiert werden:

Bruch Bruch::multiplizieren2(Bruch be1, Bruch be2){
	 Bruch ergebnis;
     ergebnis.m_zaehler = be1.m_zaehler * be2.m_zaehler; 
     ergebnis.m_nenner = be1.m_nenner * be2.m_nenner; 
	 return ergebnis;
}

Was man aber auch ein klein wenig kürzer schreiben könnte:

Bruch Bruch::multiplizieren2(Bruch be1, Bruch be2){ 
    return Bruch(be1.m_zaehler * be2.m_zaehler, be1.m_nenner * be2.m_nenner);
}

Tja, jetzt musst du nur noch die 2. Aufgabe lösen:

Crisis10 schrieb:

und dann in main:

Multiplizieren Sie b1 mit b2 mit Hilfe der statischen Funktion multiplizieren2. Weisen das Ergebnis b3 zu. Geben
Sie das Ergebnis aus.

2 Tipps:
Ein statisches Klassenelement kann entweder direkt über die Klasse mit Hilfe des Gültigkeitsoperators oder indirekt über ein Objekt (oder auch Referenz oder Zeiger auf ein Objekt) des Klassentyps aufgerufen werden. Zum Beispiel:

Klasse::statische_funktion(); // Direkter Aufruf einer statischen Funktion mittels des Gültigkeitsoperators '::'

Und der zweite Tipp bezieht sich auf den Zuweisungsoperator der einem Objekt einen Wert zuweist. Ein Beispiel:

int x(3);
int y(5);
x = y; // Der Zuweisungsoperator '=' weist x den Wert von y zu

So, damit solltest du jetzt die Aufgabe lösen können :).

Edit: Argh, hatte ein Semikolon im Code vergessen. Passiert mir ständig :D.

hi, ahjaa ok ich glaub ich habs fast gecheckt fehlt nurnoch die frage warum das jetzt hier nicht so klappt:

Also es sollte so sein da sich in main nur einen parameter übergen möchte/soll

b3 = b1.multiplizieren2(b2);
b3.ausgeben();

Bruch Bruch::multiplizieren2(Bruch be1){
     Bruch erg;
     erg.m_zaehler=m_zaehler*be1.m_zaehler;
     erg.m_nenner=m_nenner*be1.m_nenner;
     return erg;   
}

jetzt meckert er leider das ja m_nenner/zaehler nicht in den static bereich fallen. hab da grade nen denkfehler, aber könnte mand as vllt nochn bissl ändern auf die art die ich jetzt probiert habe udn halt auch so das nur ein argument übergen wird?

Mizar

Crisis10 schrieb:

Also es sollte so sein da sich in main nur einen parameter übergen möchte/soll

Der Aufgabe nach sollen aber 2 Brüche übergeben werden:

multiplizieren2: multipliziert die beiden im Argument mitgelieferten Br¨ uche zusammen. Das Ergebnis wird einem
dritten Bruch gespeichert, der von der Funktion zur¨ uckgegeben wird. (statische Funktion, ¨ oﬀentlich zug¨ anglich)

Crisis10 schrieb:

hab da grade nen denkfehler, aber könnte mand as vllt nochn bissl ändern auf die art die ich jetzt probiert habe udn halt auch so das nur ein argument übergen wird?

Mhmmm... ich verstehe ehrlich gesagt nicht genau warum, da die Aufgabe ja vorschreibt wie die multiplizieren2-Funktion auszusehen hat.

Crisis10 schrieb:

b3 = b1.multiplizieren2(b2);

Denk dran das man statische Funktion auch direkt per Klassenname gefolgt vom Gültigkeitsoperator aufrufen kann.

Bruch::multiplizieren2(b1, b2);

ok danke danke hab das echt nicht richtig gelsen peinlich peinlich ^^

soo jetz hab ich niochne frage nebenbei ,.,, wenn ich diese funktionen mehrmals aufrufe werden dauerdn ja die werte in zaehler und nenner reingeschrieben. gibt es einen aufruf irdgbnwie das diese werte wieder auf die standardwerte gesetzt werden können?
also so wie bei der deklaration:
Bruch b1(4,12);
Bruch b2(4,3);
Bruch b3;