#include <cstdlib>
#include <iostream>

using namespace std;

class Zeit
{
    private:
        int m_stunde;      
        int m_minute;      

    public:
        Zeit();                            
        Zeit(int stunde, int minute);     

        int getStunden();
        int getMinuten();
        void setStunden(int);
        void setMinuten(int);
        float getStundenDezimal();

        Zeit operator+=(Zeit);  
        Zeit operator-=(Zeit);  
        Zeit operator+(Zeit);   
        Zeit operator-(Zeit);   
        Zeit operator=(Zeit);   
        bool operator==(Zeit);  
        bool operator<(Zeit);   
        bool operator>(Zeit);     
};

Zeit::Zeit()    
{
    m_stunde = 0;
    m_minute = 0;
}

Zeit::Zeit(int stunde, int minute)      
    m_stunde = stunde;

    if(minute >= 60)                    
        m_stunde += (int) minute/60;    //Soll diese Zeile bedeuten:                  dass m_stunde= m_stunde +  minute/60 ist? 

     m_minute = minute%60;           
    }                                   
    else                                
    {                                   
        m_minute = minute;
    }
}

int Zeit::getStunden() 
{
    return m_stunde;
}

int Zeit::getMinuten()
{
    return m_minute;
}

void Zeit::setStunden(int h)
{
    m_stunde = h;
}

void Zeit::setMinuten(int min)
{
    m_minute = min;

    if(m_minute >= 60)
    {
        :warning:  m_stunde += (int) m_minute/60;   //soll diese Zeile bedeuten:                           m_stunde= m_stunde + m_minute/60?

        m_minute = m_minute % 60;
    }
}

float Zeit::getStundenDezimal()
{
    float zeitDezimal=0;

    zeitDezimal = m_stunde;

    :warning:  zeitDezimal += m_minute / 60;         // zeitDezima= zeitDezimal+m_minute/60? 

 :warning: Zeit Zeit::operator+=(Zeit a)      
{
    m_stunde += a.getStunden(); //        
    m_minute += a.getMinuten(); //Was sollen diese zeilen besagen? 

    if(m_minute >= 60)
    {
        m_stunde += (int) m_minute/60;
        m_minute = m_minute % 60;
    }

    return *this;      
}                      

// Weitere Operatoren zur Übung ------------------------

Zeit Zeit::operator-=(Zeit a)           
    m_stunde -= a.getStunden();
    m_minute -= a.getMinuten();

    if(m_minute <= -60)
    {
        m_stunde -= (int) m_minute/60;
        m_minute = m_minute % 60;
    }

    return *this;
}

Zeit Zeit::operator+(Zeit a)   // Additionsoperator
{
    Zeit tmp;

    tmp.setStunden(m_stunde + a.getStunden());
    tmp.setMinuten(m_minute + a.getMinuten());

    if(tmp.getMinuten() >= 60)
    {
        tmp.setStunden(tmp.getStunden() + (int) tmp.getMinuten()/60);
        tmp.setMinuten(tmp.getMinuten() % 60);
    }

    return tmp;
}

Zeit Zeit::operator-(Zeit a)   // Subtraktionsoperator
{
    Zeit tmp;

    tmp.setStunden(m_stunde - a.getStunden());
    tmp.setMinuten(m_minute - a.getMinuten());

    if(tmp.getMinuten() <= -60)
    {
        tmp.setStunden(tmp.getStunden() - (int) tmp.getMinuten()/60);
        tmp.setMinuten(tmp.getMinuten() % 60);
    }

    return tmp;
}

Zeit Zeit::operator=(Zeit a)   // Zuweisungsoperator
{
    m_stunde = a.getStunden();
    m_minute = a.getMinuten();

    return *this;
}

bool Zeit::operator==(Zeit a)  // Vergleichsoperator
{
    if( (m_stunde == a.getStunden()) && (m_minute == a.getMinuten()) )
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool Zeit::operator<(Zeit a)   
{
    if( m_stunde < a.getStunden())
    {
        if( m_minute < a.getMinuten())
        {
            return true;
        }
    }

    return false;
}

bool Zeit::operator>(Zeit a)
{
    if( m_stunde > a.getStunden())
    {
        return true;
    }
    else
    {
        if( m_stunde == a.getStunden() )
        {
            if( m_minute > a.getMinuten() )
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
}

// ------ MAIN -----------------------------------------------------------------------------------------------------------

int main(int argc, char *argv[])
{
    Zeit t1(3,30);  // Hier bei der Erstellung werden die entsprechenden Konstruktoren aufgerufen,
    Zeit t2(1,40);  // in diesen Fällen mit 2 Parameter
    Zeit t3(6,30);

    Zeit tmp();     // und Hier der Konstruktor ohne Parameter

    printf("Probe 1: ------------------------------ \n\n");

    printf("%d h %d min\n", t1.getStunden(), t1.getMinuten());
    printf("+\n");
    printf("%d h %d min\n", t2.getStunden(), t2.getMinuten());
    printf("=\n");

    t1 += t2;      // Hier wird der += Operator aufgerufen -> Andere Schreibweise zur besseren Vorstellung
                   // wäre:    operator+=(t2)  .... Betrifft nun die Methode operator+= des Objektes t1 mit
                   // übergabeparameter t2

    printf("%d h %d min\n\n", t1.getStunden(), t1.getMinuten());

    printf("Probe 2: ------------------------------ \n\n");

    printf("%d h %d min\n", t1.getStunden(), t1.getMinuten());
    printf("-\n");
    printf("%d h %d min\n", t3.getStunden(), t3.getMinuten());
    printf("=\n");

    t1 -= t3;   // Hier dasselbe wie beim += operator

    printf("%d h %d min\n\n", t1.getStunden(), t1.getMinuten());

    printf("Probe 3: ------------------------------ \n\n");

    t2-=t1;
    t1=t3;
    printf("t1 = t3\n");
    printf("t1: %d h %d min\n", t1.getStunden(), t1.getMinuten());
    printf("t3: %d h %d min\n\n", t3.getStunden(), t3.getMinuten());

    printf("Probe 4: ------------------------------ \n\n");

    printf("t1 > t2\n");
    printf("t1: %d h %d min\n", t1.getStunden(), t1.getMinuten());
    printf("t2: %d h %d min\n", t2.getStunden(), t2.getMinuten());

    if(t1 > t2)
    {
        printf("Wahr\n\n");
    }
    else
    {
        printf("Falsch\n\n");
    }

    system("PAUSE");
    return EXIT_SUCCESS;
}

/edit pumuckl: [cpp]-Tags dazu. nächstemal bitte selber machen!

macht das ganze leserlicher...

Zu deiner Frage:

Ja, der += -Operator ist das gleiche wie x = x + y .
Das selbe gilt für -= , *= , /= usw.

Außerdem hat deine Klasse Zeit diesen Operator für sich überladen, damit man auch sowas machen kann:

Zeit a( 10, 15 );
Zeit b( 3, 50 );

a += b;

// a ist jetzt Zeit( 14, 5 )

/edit pumuckl: [cpp]-Tags dazu. nächstemal bitte selber machen!

Nächstes Mal bitte richtig machen!

zwutz schrieb:

Außerdem hat deine Klasse Zeit diesen Operator für sich überladen, damit man auch sowas machen kann:

Zeit a( 10, 15 );
Zeit b( 3, 50 );

a += b;

// a ist jetzt Zeit( 14, 5 )

Zeit Zeit::operator+=(Zeit a) //Zeile 1
{
m_stunde += a.getStunden();   // Zeile 2
m_minute += a.getMinuten();  // Zeile 3

Ich muss ehrlich sagen, zeile 1 verstehe ich überhaupt nicht. Ich kann mir nichts darunter vorstellen. zeit is ja die klasse, aber den rest ...
könntst es vielleicht genauer erklären, wenn möglich? danke

mfg

Zeit Zeit::operator+=(Zeit a) ====> Zeit= Zeit+ Zeit a?

/edit pumuckl: [cpp]-Tags dazu. nächstemal bitte selber machen!

Nächstes Mal bitte richtig machen!

Done

@N5803: schau dir im Buch/Tutorial deiner Wahl einfach mal an was der operator+= für die eingebauten Datentypen macht. Das Verhalten dürfte (bzw. sollte) hier ähnlich sein.
Dann sollte im gleichen Buch/Tutorial stehen wie man Operatoren überlädt.
Im Magazin gibts zu dem Thema auch einen Artikel.

lg

soll es etwa heissen:

Zeit Zeit::operator+=(Zeit a) ====> Zeit= Zeit+ Zeit a?

genau

die Operatoren sind nur Funktionen, nichts anderes.

hast du also wie in meinem Beispiel zwei Zeit-Objekte a und b und führst folgende Operation aus:

a += b;

ist das für den Compiler das gleiche, als würdest du das schreiben:

a.operator+=(b)

damit dürfte die Sache klarer werden

nochmal an Zeile 1:

Zeit Zeit::operator+=(Zeit a)

eigentlich sollte sie so aussehen:

Zeit& Zeit::operator+=(const Zeit& a)

es geht zwar beides, aber letzteres erspart ein wenig Zeit, da die Objekte nicht kopiert werden müssen.

Die Funktion liefert eine Referenz auf ein Zeit-Objekt zurück. Üblicherweise wird dazu return *this; verwendet (wie in deinem Beispiel auch). Also das aufgerufene Objekt gibt sich selbst zurück.
Damit ist dann auch sowas möglich:

Zeit a,b,c;

a += b += c;

ausführlich also das gleich wie das:

b = b + c;
a = a + b;

ansonsten siehe Rotschopf, äh, Pumuckl

glg

Hier ist der Code, wäre sehr dankbar für jede Hilfe.

#include <cstdlib>
#include <iostream>

class Rational 
{
   int m_zaehler;
   int m_nenner;

   void kuerzen(float);

public:    

    int getZaehler();
    int getNenner();
    void setZaehler(int);
    void setNenner(int);

     Rational();

      Rational operator+(Rational);
    Rational operator-(Rational);
    Rational operator*(Rational);
    Rational operator/(Rational);

    void print();

};

void Rational::setZaehler(int z)
{
  m_zaehler=z;  
}

void Rational::setNenner(int n)
{
 m_nenner=n;   
}

int Rational::getNenner()
{
    return m_nenner;   
}

int Rational::getZaehler()
{
    return m_zaehler;   
}

//HIER KÜRZEN FUNKTION

Rational Rational::operator+(Rational p)
{
     Rational tmp;

     tmp.setNenner(m_nenner * p.getZaehler() + m_zaehler * p.getNenner());
     tmp.setZaehler(m_nenner * p.getNenner());

     return tmp;
}

Rational Rational::operator-(Rational p)
{
    Rational tmp;

    tmp.setZaehler(m_nenner * p.getZaehler() - m_zaehler * p.getNenner());     
    tmp.setNenner(m_nenner * p.getNenner());

    return tmp;
}

Rational Rational::operator*(Rational p)
{
         Rational tmp;

         tmp.setZaehler(m_zaehler * p.getZaehler());
         tmp.setNenner(m_nenner * p.getNenner());

         return tmp;
}

Rational Rational::operator/(Rational p)
{
 Rational tmp;

 if(p.getNenner()==0)
 {
  printf("Nur Chuck Norris kann durch 0 dividieren \n");
  //cout<<"Nur Chuck Norris kann durch 0 dividieren \n"<<endl;
  return *this;
  }
  else
  {
 tmp.setZaehler(m_nenner * p.getZaehler());
 tmp.setNenner(m_zaehler * p.getNenner());
 return tmp; 
 }       

}

void Rational::print()
{
      if(m_nenner != 1)
      {
                  printf("%d  \n",m_zaehler); 
                  //cout<<"  \n"<<m_zaehler;
                  printf("--\n");
                  //cout<<"--\n"<<endl;
                  //cout<<"  \n"<<m_nenner;
                  printf("%d  \n", m_nenner);
      }           
      else
      {
          printf("%d  \n",m_zaehler);
        // cout<<"  \n"<<m_zaehler;    
      }

}  

using namespace std;

int main(int argc, char *argv[])
{

    Rational r1, r2, r3, r4;
    //Rational erg1, erg2, erg3, erg4;

    r1.setZaehler(3);
    r1.setNenner(4);

    r2.setZaehler(2);
    r2.setNenner(8);

    r3.setZaehler(1);
    r3.setNenner(2);

    r4.setZaehler(7);
    r4.setNenner(1);

    r1.print();
    r2.print();
    r3.print();
    r4.print();

    system("PAUSE");
    return EXIT_SUCCESS;
}

mfg

Eine Frage: Wann brauch ich einen Constructor und wann nicht und wie kann ich (in meinem bsp z.b.) den constructor anwenden.

lg

hallöle, hab in 10 min info prüfung. könnte mir jmd vielleicht etwas behilflich sein? wäre echt super danke.

Ich drück dir die Daumen
Viel mehr kann man da nicht helfen

N5803 schrieb:

hallöle, hab in 10 min info prüfung. könnte mir jmd vielleicht etwas behilflich sein? wäre echt super danke.

Ich drück dir die Daumen
Viel mehr kann man da nicht helfen

hmmmm vielleicht etwas fachliche hilfe noch dazu?

pumuckl schrieb:

Viel mehr kann man da nicht helfen

hmmmm vielleicht etwas fachliche hilfe noch dazu?

Das Forum soll dir beim Lernen helfen, nicht beim Bescheißen. Wir machen keine Hausaufgaben, es gibt keine Komplettlösungen - und Klausurhilfe daher schonmal garnicht.