Allerdings kriege ich es nicht ganz raus...

Bitte hilfe....und bitte einfach...lerne das ganz neu und hab da nich so das "Programmier-denken"

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

using namespace std;

class Bruch
      {private: int zaehler;
                int nenner;
       public:  Bruch(int, int);
                void addition(Bruch,Bruch);
      };

Bruch::Bruch(int z, int n)
{ zaehler = z;
  nenner = n;
}

void Bruch::addition(Bruch a,Bruch b,Bruch erg)
{   
erg.zaehler=a.zaehler*b.nenner + a.nenner + b.zaehler; 
erg.nenner=a.nenner*b.nenner;

cout<<"Bruch:"<<endl; 
cout<<erg.zaehler<<"/"<<erg.nenner<<endl;
}

int main()
{
Bruch eins(4,5);
Bruch zwei(2,10);
Bruch erg(1,1);

erg.addition();

getch();
}

void addition(Bruch,Bruch) != void Bruch::addition(Bruch a,Bruch b,Bruch erg)

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

using namespace std;

class Bruch
      {private: int zaehler;
                int nenner;
       public:  Bruch(int, int);
                void addition(Bruch,Bruch,Bruch);

      };

Bruch::Bruch(int z, int n)
{ zaehler = z;
  nenner = n;
}

void Bruch::addition(Bruch a,Bruch b,Bruch erg)
{   
erg.zaehler=(a.zaehler*b.nenner) + (a.nenner *b.zaehler); 
erg.nenner=a.nenner*b.nenner;

cout<<"Bruch:"<<endl; 
cout<<erg.zaehler<<"/"<<erg.nenner<<endl;
}

int main()
{
Bruch eins(4,5);
Bruch zwei(2,10);
Bruch erg(1,1);

erg.addition(eins,zwei,erg);

getch();
}

`void addition(Bruch,Bruch);

`
Zwei Parameter.

`void Bruch::addition(Bruch a,Bruch b,Bruch erg)

`
Drei Parameter.

`erg.addition();

`
Keine Parameter.

Wenn du mich fragst, solltest du das ganz anders machen: Eine Addition ist keine Eigenschaft eines Bruchs, sondern eine Funktion auf zwei Brüchen, die dir wieder einen dritten Bruch zurückgibt. Also: Keine Memberfunktion, sondern eine freie Funktion die zwei Parameter vom Typ Bruch entgegenimmt. Kein Rückgabetyp void , sondern Rückgabetyp Bruch . Also:
Bruch addition(Bruch erster, Bruch zweiter)

Und jetzt noch der Pro-Tipp: Nenn diese freie Funktion nicht addition , sondern nenn sie operator+ . Sieht zwar erstmal komisch aus, aber probier mal, was passiert.

Und jetzt noch der Pro-Tipp: Nenn diese freie Funktion nicht addition, sondern nenn sie operator+. Sieht zwar erstmal komisch aus, aber probier mal, was passiert.

Ich denke nicht, dass er schon so weit ist.

Seppj schrieb:

Und jetzt noch der Pro-Tipp: Nenn diese freie Funktion nicht addition, sondern nenn sie operator+. Sieht zwar erstmal komisch aus, aber probier mal, was passiert.

Ich denke nicht, dass er schon so weit ist.

Im Prinzip ist das ein ganz normaler Funktionsname. Alles verhält sich haargenau so als wenn er die Funktion "addition" nennen würde. Außer natürlich der einen Kleinigkeit auf die ich damit hinaus will, aber das muss er jetzt ja noch nicht wissen.

aber das mag der compiler nich xD

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

using namespace std;

class Bruch

{     private: int zaehler;
               int nenner;
      public:  Bruch (int, int);
               void operator+ (Bruch, Bruch, Bruch);
};

Bruch::Bruch(int z, int n)
{  zaehler = z;
   nenner = n;
};

void Bruch::operator+(Bruch eins, Bruch zwei, Bruch erg)
{
     erg.zaehler=eins.zaehler*zwei.nenner + zwei.zaehler*eins.nenner;
     erg.nenner=eins.nenner*zwei.nenner;
     cout<<"Das Ergebnis lautet: "<<erg.zaehler<<" / "<<erg.nenner;
}

int main()
{

Bruch eins(3,6);
Bruch zwei(2,5);
Bruch erg(1,1);

erg.operator+(eins,zwei,erg);

getch();
}

class Bruch

{     private: int zaehler;
               int nenner;
      public:  Bruch (int, int);
               Bruch operator+ (Bruch);    // Bruch wird übergeben & Bruch wird zurückgegeben
};

/*
 *
 */

Bruch Bruch::operator+(Bruch eins)
{
     Bruch erg;
     erg.zaehler=eins.zaehler*nenner + zaehler*eins.nenner;
     erg.nenner=eins.nenner*nenner;
     cout<<"Das Ergebnis lautet: "<<erg.zaehler<<" / "<<erg.nenner;
     return erg;
}

int main()
{
Bruch eins(3,6);
Bruch zwei(2,5);
Bruch erg(1,1);

erg = zwei.operator+(eins);    // oder:    erg = zwei + eins;

cin.get();
}

EDIT: hier müssten jetzt aber zaehler und nenner auch public sein.. this-Pointer zurückgeben ist besser (siehe unten).

...

Könntest du dich vielleicht mal auf einheitliche Klammersetzung und Einrückung umstellen, macht das lesen ungemein leichter

Zum anderen wäre es schön, wenn du statt den Code-Tags die Cpp-Tags verwendest (wegen Syntaxhervorhebung).

Zudem:
1. "using namespace std" solltest du mit etwas Vorsicht verwenden, und niemals in einem Header.
2. Bitte gebe in der Deklaration immer die Parameternamen an, das macht das Lesen wesentlich einfacher. Zudem sollte die Deklaration für das Verständnis ausreichen, ein Blick in die Implementierung sollte man nicht aufzwingen.
3. Für Ergebnisse gibt es den Rückgabewert.
4. Nicht-Integrale Werte sollte man nicht als Kopien übergeben, sondern je nach Anforderungen als Referenz, Konstante Referenz oder Zeiger.

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

using namespace std;

class Bruch
{
  private:
    int zaehler;
    int nenner;

  public:
    Bruch(
      int zaehler,
      int nenner);

    // Wenn man operator+ verwendet, sollte man auch operator += unterstützen.
    Bruch & operator+=(
        const Bruch & rhs);
};

// Bei den Operatoren sollte man möglichst kompatibel zur herkömmlichen
// Zahlenarithmetik halten.
// Bei int-Werten ist z.B. eine Verkettung mehrerer "+" möglich. Dazu
// muss aber der Rückgabewert verwendet werden.
// Zudem werden die beiden Parameter (Linkes Argument und Rechtes Argument)
// nicht verändert, sollten daher als konstante Referenz übergeben werden.
Bruch const operator+(
  const Bruch & lhs,
  const Bruch & rhs);

Bruch::Bruch(
  int zaehler,
  int nenner)
: zaehler(zaehler), // Stichwort: Initialisierungsliste
  nenner(nenner)
{
}

Bruch const operator+(
  const Bruch & lhs,
  const Bruch & rhs)
{
  // Kann man mittels Kopierkonstruktor und operator += gelöst werden.
  Bruch ergebnis(lhs);
  ergebnis += rhs;
  return ergebnis;
}

// operator+= gibt eine Referenz des aktuellen Objektes zurück...
Bruch & Bruch::operator+(
  const Bruch rhs)
{
  zaehler = zaehler * rhs.nenner + rhs.zaehler * nenner;
  nenner  = nenner * rhs.nenner;
  return *this;
}

int main()
{
  Bruch eins(3,6);
  Bruch zwei(2,5);

  Bruch ergebnis1 = eins + zwei;
  Bruch ergebnis2 = eins + zwei + zwei; // Nun auch möglich
  ergebnis1 += ergebnis2; // oder dies

  getch();
}

Edit: Korrigiert

So müsste es gehen:

class Bruch

{     private: int zaehler;
               int nenner;
      public:  Bruch (int, int);
               Bruch operator+ (Bruch);    // Bruch wird übergeben & Bruch wird zurückgegeben
};

/*
 *
 */

Bruch Bruch::operator+(Bruch eins)
{
     Bruch erg;
     erg.zaehler=eins.zaehler*nenner + zaehler*eins.nenner;
     erg.nenner=eins.nenner*nenner;
     cout<<"Das Ergebnis lautet: "<<erg.zaehler<<" / "<<erg.nenner;
     return erg;
}

int main()
{
Bruch eins(3,6);
Bruch zwei(2,5);
Bruch erg(1,1);

erg = zwei.operator+(eins);    // oder:    erg = zwei + eins;

cin.get();
}

NEO.PIXEL schrieb:

Wieso soll er das noch nich wissen.. So schwer zu verstehen find ich das aber nicht..

class Bruch
{
  public:
    // Bei den Operatoren sollte man möglichst kompatibel zur herkömmlichen
    // Zahlenarithmetik halten.
    // Bei int-Werten ist z.B. eine Verkettung mehrerer "+" möglich. Dazu
    // muss aber der Rückgabewert verwendet werden.
    // Zudem werden die beiden Parameter (Linkes Argument und Rechtes Argument)
    // nicht verändert, sollten daher als konstante Referenz übergeben werden.
    Bruch operator+(
        const Bruch & lhs,
        const Bruch & rhs);

    // Wenn man operator+ verwendet, sollte man auch operator += unterstützen.
    Bruch & operator+(
        const Bruch & rhs);
};

operator+ sollte ne freie Funktion sein (mit deiner Signatur muss es sogar ne freie Funktion sein). Einen operator+= sehe ich bei dir nicht, auch nicht bei der Definition.

http://c-plusplus.net/forum/232010

operator+ sollte ne freie Funktion sein (mit deiner Signatur muss es sogar ne freie Funktion sein). Einen operator+= sehe ich bei dir nicht, auch nicht bei der Definition.

Hast recht, hatte das ganze leider nicht nochmal kontrolliert.

1. "using namespace std" solltest du mit etwas Vorsicht verwenden, und niemals in einem Header.

Ich merke immer mehr, dass uns in der Schule wohl unsinn beigebracht wird?

letztens erst habe ich hier erfahren, dass es

int main()

und nicht

main()

heißt....

und was hat es jetzt mit dem using namespace std auf sich?

wir müssen das machen, da sonst unser compiler ne reihe fehler ausspuckt

using namespace std;

string s;

↓

std::string s;