3. Klasse Bruch

Klasse Bruch

  • E

    Hallo!
    Ich habe mit folgendem Code ein Problem:

    //Bruchneu.h

#ifndef Bruchneu_h___
#define Bruchneu_h___

#include <iostream>

class Bruch
{
      long zaehler_;
      long nenner_;
public:
       Bruch(long z=0, long n=1);
       Bruch(const Bruch & a);
       ~Bruch();

       long getZaehler() const{return zaehler_;}
       long getNenner() const{return nenner_;}

       Bruch operator +(const Bruch & a) const;
       friend std:: ostream & operator <<(std::ostream & os, const Bruch & a);
};

#endif

    //Bruchneu.cpp

#include <iostream>
#include "Bruchneu.h"
#include "kgV_ggt.h"

using namespace std;

int main()
{
    long z, n;
    cout << "erste Bruch: " << endl;
    cin >>z; //zaehler
    cin >>n; //nenner
    Bruch myBruch(z,n);
    cout <<myBruch<< endl;

    cout << "zweiter Bruch: " << endl;
    cin >>z;
    cin >>n;
    Bruch myBruch2(z,n);
    cout <<myBruch2<< endl;
    cout <<"Das Ergebnis ist: " <<endl;

    cout <<myBruch+myBruch2<<endl;
}

/==============================================================================

Bruch::Bruch (long z, long n)
{
    if(n==0)
    {
        cout << "Nenner=0 ungueltig" << endl;
        n>1;
        //throw 1;
    }
    if (z==0) //Zaehler=0
    {
        zaehler_=0;
        nenner_=1;
    }
    else
    {
        long t=ggT(z,n);
        zaehler_= z/t;
        nenner_= n/t;
        if (nenner_<0)
        {
            zaehler_= -zaehler_;
            nenner_= -nenner_;
        }
    }
}
//==============================================================================

Bruch::Bruch(const Bruch & a): zaehler_ (a.zaehler_), nenner_(a.nenner_)
{
}

//==============================================================================

Bruch Bruch::operator+(const Bruch & a) const
{
    long n=kgV(nenner_, a.nenner_);
    long z= (n/nenner_)*zaehler_+(n/a.nenner_)*a.zaehler_;
    return Bruch(z,n);
}

//==============================================================================

std::ostream & operator <<(std::ostream & os, const Bruch & a)
{
    os << a.zaehler_;
    if (a.nenner_!= 1)
        os << '/' << a.nenner_;
    return os;
}

    Leider bekomme ich dann eine Fehlermeldung:

    [Linker error] undefined reference to 'Bruch::~Bruch()'
    more undefined references to 'Bruch::~Bruch()' follow
    ld returned 1 exit status
    Build Error][Bruchneu.exe]Error 1

    Ich weiß irgendwie nicht mehr weiter und habe keine Ahnung wo der Fehler liegen könnte. Das Programm stimmt bis auf die main-Funktion direkt mit dem überein, was wir in der Vorlesung durchgenommen haben.

    Ich danke euch schon mal im Voraus für eure Bemühungen.
    lg

    0
  • Mod

    Du sagst in Zeile 15 (erste Datei), dass du einen eigenen Destruktor definieren möchtest (wozu überhaupt? Cargo-Cult?), daher generiert der Compiler in Zeile 26 (zweite Datei), wo er den Destruktor braucht, keinen eigenen Destruktor. Da du diesen eigenen Destruktor nirgends definierst, wird er dann am Ende vom Linker vergeblich gesucht.

    0
  • E

    Habe jetzt den Destruktor gelöscht und es funktioniert.

    Ich habe den Destruktor nicht in Frage gestellt, weil wir dieses Programm auf der Uni genau mit diesem Destruktor durchgeführt haben. Da war es aber anscheinend kein Problem.

    Aber immerhin klappt es jetzt. 🙂 Vielen Dank!

    0
  • ?

    e.kerstin91 schrieb:

    Ich habe den Destruktor nicht in Frage gestellt, weil wir dieses Programm auf der Uni genau mit diesem Destruktor durchgeführt haben. Da war es aber anscheinend kein Problem.

    Hmmm, AFAIK IB. Wenn du in bei manchen Compilern nicht definierst, wird er zum default.

    0
  • Mod

    Hacker schrieb:

    Hmmm, AFAIK IB. Wenn du in bei manchen Compilern nicht definierst, wird er zum default.

    Nein, total definiertes Verhalten. Wenn du selber einen Destruktor definierst kann und darf ein Compiler keinen eigenen erzeugen. Wenn du keinen definierst und es wird einer gebraucht, dann muss ein Compiler einen eigenen nach genau vorgegebenen Regeln erzeugen.

    0
  • ?

    SeppJ schrieb:

    Wenn du selber einen Destruktor definierst kann und darf ein Compiler keinen eigenen erzeugen.

    Es gibt übrigens einen Unterschied zwischen deklarieren und definieren. Ich meine, wenn man ihn deklariert. Aber ich weiß, dass du auch so Recht hast 😃

    0
  • Mod

    Hacker schrieb:

    SeppJ schrieb:

    Wenn du selber einen Destruktor definierst kann und darf ein Compiler keinen eigenen erzeugen.

    Es gibt übrigens einen Unterschied zwischen deklarieren und definieren. Ich meine, wenn man ihn deklariert. Aber ich weiß, dass du auch so Recht hast 😃

    Wenn du ihn definierst, dann musst du ihn vorher deklarieren. Wenn du ihn deklarierst, dann wird davon ausgegangen, dass du ihn auch definierst. Genau das ist hier nicht geschehen, daher der Fehler.

    0
Anmelden zum Antworten