Ganz einfaches Class-Programm



  • Halli Hallo... geht um die Addition von 2 Brüchen mit Konstruktor....

    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();
    }
    


  • #include <iostream> 
    
    using namespace std; 
    
    class Bruch 
    {
    private:
    	int zaehler; 
    	int nenner; 
    
    public: 
    	Bruch(int z, int n): zaehler(z), nenner(n){};
    
    	void addition(const Bruch& a,const Bruch& b);
    	void show();
    }; 
    
    void Bruch::addition(const Bruch& a,const Bruch& b) 
    {   
    	zaehler = a.zaehler * b.nenner + a.nenner * b.zaehler;
    	nenner = a.nenner * b.nenner;
    } 
    
    void Bruch::show()
    {
    	cout << "Bruch: " << zaehler << "/" << nenner << endl; 
    }     
    
    int main() 
    { 
    	Bruch eins(4,5); 
    	Bruch zwei(2,10); 
    	Bruch erg(1,1); 
    
    	erg.addition(eins, zwei);
    	erg.show();
    
    	system("pause");
    	return 0;
    }
    


  • Deine Deklaration und deine Definition von void addition stimmen nicht überein:

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



  • Danke,aber habs jetzt so gelöst....

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

  • Mod

    Das ist...wirr.

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



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


  • Mod

    HighLigerBiMBam schrieb:

    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.



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



  • Hab jetzt mal ganz einfach addition mit operator+ ausgewechselt...

    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();
    }
    


  • Weil du gerade versuchst einen Operator innerhalb der Klasse mit mehr als einem Parameter zu erstellen.



  • 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();
    }
    

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



  • lululu schrieb:

    ...

    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



  • NEO.PIXEL schrieb:

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

    🙄



  • asc schrieb:

    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



  • Sorry mein Fehler.. Wollte auch mal meinen Senf dazu geben 😃



  • Michael E. schrieb:

    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



  • Du benutzt dann einfach statt using namespace std den Zugriffsoperator ::

    using namespace std;
    
    string s;
    

    std::string s;
    

Log in to reply