Konstruktoren

[mostwanted90]

Hi
Danke an alle.

Ich hab jetzt folgenden code:

#include "stdafx.h"
#include <iostream.h>
#include <conio.h>


class CBruch
{
private:
  int zaehler;
  int nenner;

public:

  CBruch ()
  {
    zaehler = 0;
    nenner = 1;
  }

  CBruch (int a, int b)
  {
    zaehler = a;
    if (b != 0) 
    {
      nenner = b;
    }
    else
    {
        cout<<"Der Nenner darf nicht NUll sein";
    }
  }
  int GroessterTeiler(int z1, int z2)
  {
    if(z1==0) return z2;
    else return GroessterTeiler(z2%z1,z1);
  }

  void kuerze()
  {
    int Groester=GroessterTeiler(zaehler,nenner);
    Groester=Groester*(-1);
    zaehler=zaehler/Groester;
    nenner=nenner/Groester;
  }
  void Ausgabe()
  {
    kuerze();
    cout <<zaehler <<"/" <<nenner << endl;
  }

  bool operator==(CBruch& Bruch2)
  {
    if(zaehler==Bruch2.zaehler&&nenner==Bruch2.nenner)
    {
      return true;
    }
    else
   {
     return false;
    }
  }

  bool operator !=(int x)
  {
    if (zaehler!=x)
    {
      return true;
    }
    else
    {
      return false;
    }
  }

  CBruch operator +(CBruch& rhs)
  {
     int gn = 1, gz = 1; 
     if(nenner == rhs.nenner) 
     { 
       gz = zaehler + rhs.zaehler; 
       gn = rhs.nenner; 
     } 
     else 
     { 
       gn = nenner * rhs.nenner; 
       gz=(zaehler * rhs.nenner)+(rhs.zaehler*nenner); 
     } 
     rhs.nenner = gn; 
     rhs.zaehler = gz; 
     return rhs; 
  } 

  CBruch CBruch::operator+(int summand)
  {
    int Z2=zaehler;
    int N2=nenner;
    CBruch Bruch2;
    CBruch Bruch;
    Bruch.nenner=N2;
    Bruch.zaehler=Z2;
    Bruch2.zaehler=summand;
    return Bruch + Bruch2;
  }

  CBruch operator-(int summand)
  {
    int Z2=zaehler;
    int N2=nenner;
    CBruch Bruch2;
    CBruch Bruch;
    Bruch.nenner=N2;
    Bruch.zaehler=Z2;
    Bruch2.zaehler=summand;
    return Bruch - Bruch2;
  }

  CBruch operator*(int summand)
  {
    int Z2=zaehler;
    int N2=nenner;
    CBruch Bruch2;
    CBruch Bruch;
    Bruch.nenner=N2;
    Bruch.zaehler=Z2;
    Bruch2.zaehler=summand;
    return Bruch * Bruch2;
  }

  CBruch operator/(int summand)
  {
    int Z2=zaehler;
    int N2=nenner;
    CBruch Bruch2;
    CBruch Bruch;
    Bruch.nenner=N2;
    Bruch.zaehler=Z2;
    Bruch2.zaehler=summand;
    return Bruch / Bruch2;
  }

  CBruch operator-(CBruch& Bruch3)
  {
    int gz=zaehler;
    int gn=nenner;
    gz =(zaehler * Bruch3.nenner) - (Bruch3.zaehler*nenner);
    gn=nenner*Bruch3.nenner;
    Bruch3.nenner=gn;
    Bruch3.zaehler=gz;
    return Bruch3;
  }

  CBruch operator*(CBruch& Bruch2)
  {
    int gz= (zaehler * Bruch2.zaehler);
    int gn= (nenner * Bruch2.nenner);
    Bruch2.nenner=gn;
    Bruch2.zaehler=gz;
    return Bruch2;
  }

  CBruch operator/(CBruch& Bruch2)
  {
    int gz=(zaehler * Bruch2.nenner);
    int gn=(nenner *Bruch2.zaehler);
    Bruch2.nenner=gn;
    Bruch2.zaehler=gz;
    return Bruch2;
  }

  CBruch  operator ++ (int)
  {
    int prev = nenner;
    prev = prev + 1;
    return CBruch(0,prev);
  }
   
  CBruch  operator -- ()
  {
    int Prev = nenner;
    nenner--;
    return CBruch(0,Prev);
  }

  CBruch operator +=(CBruch& Bruch)
  {
    int gz=Bruch.zaehler+Bruch.zaehler;
    int gn=Bruch.nenner;
    return Bruch;
  }
  
  CBruch operator -=(CBruch& Bruch)
  {
    int gz=Bruch.zaehler-Bruch.zaehler;
    int gn=Bruch.nenner;
     return Bruch;
  }
  
   CBruch operator *=(CBruch& Bruch)
   {
     int gn=Bruch.zaehler*Bruch.zaehler;
     int gz=Bruch.nenner*Bruch.nenner;
     return Bruch;
   }

    CBruch operator /=(CBruch& Bruch)
  {
    int gz=Bruch.zaehler*Bruch.nenner;
    int gn=Bruch.nenner=Bruch.nenner*Bruch.zaehler;
    return Bruch;
    
  }




}; 

CBruch operator+(int x,CBruch& Bruch)
{
  return Bruch+x;
}

CBruch operator-(int x,CBruch& Bruch)
{
  return Bruch-x;
}

CBruch operator*(int x,CBruch& Bruch)
{
  return Bruch-x;
}

CBruch operator/(int x,CBruch& Bruch)
{
  return Bruch-x;
}



int main(void)
{
 CBruch Ergebnis;

 CBruch a(1,2);
 CBruch b(1,3);
 CBruch c(2,7);
 CBruch d(7,3);
 CBruch f;

 bool bTest1 = (a==b);
 bool bTest2 = (a != 3);

 
 Ergebnis += a;
 Ergebnis -= a;
 Ergebnis *= a;
 Ergebnis /= a;
 
 
 Ergebnis = 2 + a;
 Ergebnis = a + 2;
 Ergebnis = 2 - b;
 Ergebnis = b - 2;
 Ergebnis = 2 * c;
 Ergebnis = c * 2;
 Ergebnis = 2 / c;
 Ergebnis = c / 2;
 
 f++;
 --f;
 Ergebnis =((a+b -1) * c) /2 - d;
 cout<<"Bruch:";
 Ergebnis.Ausgabe();
 return 0;
}

Das ist bestimmt nicht Perfekt. Außerdem hab ich mit den Zuweisungs operatoren eigentlich nichts gemacht...

Ich hab einfach das selbe was ich übergeben habe wieder zurückgegeben :suspekt:

Hab keine Ahnung wie ihr das meint mit den += -= *= /=

naja werd ich schon noch hinbekommen...

 

[jokey2]

Außerdem hab ich mit den Zuweisungs operatoren eigentlich nichts gemacht...
Ich hab einfach das selbe was ich übergeben habe wieder zurückgegeben

Das ist so leider nicht ganz richtig.
Der Operator ist eine Memberfunktion einer Klasse. Der Parameter, der übergeben wird, ist das, was auf der rechten Seite des Operators steht. Der Rückgabewert ist eine Referenz auf das eigene Objekt.
Nochmal anhand meines Beispiels:

CBruch & CBruch::operator +=(const CBruch& rhs)
{
 int iNeuZaehlerL = m_Zaehler * rhs.m_Nenner;
 int iNeuZaehlerR = rhs.m_Zaehler * m_Nenner;
 
 m_Zähler = iNeuZaehlerL + iNeuZaehlerR;
 m_Nenner *= rhs.m_Nenner;
 return *this;
}

Wenn also gerechnet wird:

CBruch a(1,2);
CBruch b(3,4);
a += b;

dann ist danach a gleich 10/8. Es werden also a und b addiert und das Ergebnis a zugewiesen. Das ist einfach eine Kurzschreibweise für a=a+b. (Das Ergebnis sollte eigentlich am Besten 5/4 sein, aber das muß man dann eben etwas geschickter programmieren)

Es wird der '+='-Operator von a aufgerufen und eine Referenz auf b wird ihm übergeben. Dann wird die Addtition berechnet und den Membervariablen von a zugewiesen. Zurückgegeben wird der Inhalt des this-Zeigers.

Ich hoffe, das macht das Ganze etwas klarer.

 

[mostwanted90]

ne irgendiwie is das nur Bahnhof :-D

in der aufgabenstellung steht das für Ergebnis -33/14 herauskommen soll. Wenn ich davor aber das Zeug mit += ... mache dann komt doch etwas ganz anderes heraus.
Kannst du vll. meinen Quellcode (z.b. +=) so umbauen wie du das meinst? Oder müsste man dazu das gesamte Programm umbasteln?