finden von Fehlern

Hallo,

ich bin ein C++ Neuling und habe eine Übungsaufgabe aus einem C++ Buch gelöst. Das Problem ist nun das keine Lösung zu diesem Programm existiert. Meine Lösung funktioniert soweit. Nun geht es noch darum eventuelle Fehler von mir zu finden. Es wäre nett wenn ihr nach folgenden Dingen schauen könntet.

- hab ich vielleicht irgendwo Speicher auf dem Heap benutzt den ich nicht wieder ordnungsgemäß freigebe

- hab ich das mit den tiefen bzw. flachen Kopien immer richtig gemacht

- hätte ich an manchen Stellen anstatt Speicher auf dem Heap auch Speicher auf dem Stack benutzen können

- ist mein Kopierkonstruktor bzw. mein überladener Zuweisungsoperator korrekt

- ist das mit der Fehlerbehandlung OK

- in der Übungsaufgabe wird behauptet das das Programm folgende Ausgabe liefert:

mp.flaeche() = 200
gp.flaeche() 198.5
mp und gp sind gleich schwer

nun wird gefragt was in der Klasse MetallPlatte zu ändern ist um die korrekte Ausgabe zu erhalten.

Bei mir ist es allerdings so das ich garnichts an Metallplatte ändern muss und trotzdem folgende Ausgabe bekomme:

mp.flaeche() = 200
gp.flaeche() = 200
mp und gp sind gleich schwer

Kann mir einer sagen warum ich die richtige Ausgabe bekomme bzw. wo der Fehler in der Klasse MetallPlatte liegen soll? (die Klasse MetallPlatte ist vorgegeben)

#include <iostream>
#include <stdexcept>
#include <math.h>
using namespace std;

class MetallPlatte
{
    private:
        double laenge, breite;

    public:
        MetallPlatte (double laenge, double breite)
        {
            this->laenge = laenge;
            this->breite = breite;
        }

        double getLaenge() const
        {
            return laenge;
        }

        double getBreite() const
        {
            return breite;
        }

        double flaeche()
        {
            return laenge * breite;
        }

        bool istSchwererAls(MetallPlatte mp)
        {
            return flaeche() > mp.flaeche();
        }    
};

class GelochtePlatte : public MetallPlatte
{
    private:
        int anzahlLoecher;
        int maxAnzahlLoecher;
        double lochLaenge;
        double lochBreite;
        MetallPlatte** loch;

    public:  
        GelochtePlatte(double laengePlatte, 
                       double breitePlatte, 
                       int   maxAnzahlLoecher):
        MetallPlatte(laengePlatte, breitePlatte)
        {
            anzahlLoecher = 0;
            this->maxAnzahlLoecher = maxAnzahlLoecher;
            loch = new MetallPlatte* [maxAnzahlLoecher];  

            for (int i=0; i < maxAnzahlLoecher; i++) 
            { 
                loch[i] = NULL; 
            } 

            lochBreite = 1/(2*maxAnzahlLoecher) * getBreite();
            lochLaenge = 1/(2*maxAnzahlLoecher) * getLaenge();
        } 

        GelochtePlatte(const GelochtePlatte& rhs): 
        MetallPlatte(rhs), 
        anzahlLoecher(rhs.anzahlLoecher), 
        maxAnzahlLoecher(rhs.maxAnzahlLoecher), 
        loch(new MetallPlatte* [rhs.maxAnzahlLoecher]),
        lochBreite(rhs.lochBreite), 
        lochLaenge(rhs.lochLaenge) 
        {  
            for (int i=0; i < maxAnzahlLoecher; i++) 
            { 
                loch[i] = new MetallPlatte(*(rhs.loch[i]));
            } 
        } 

        GelochtePlatte& operator=(const GelochtePlatte& rhs)
        {
            if(this == &rhs)
                return *this;

            anzahlLoecher = rhs.anzahlLoecher;
            maxAnzahlLoecher = rhs.maxAnzahlLoecher;
            *loch = (*rhs.loch);

            for(int i=0; i<maxAnzahlLoecher; i++)
            {
               *loch[i] = *rhs.loch[i];
            }

            lochBreite = rhs.lochBreite;
            lochLaenge = rhs.lochLaenge;
        }

        ~GelochtePlatte()
        {
            for (int i=0; i < maxAnzahlLoecher; i++) 
            { 
                delete loch[i];
                loch[i] = NULL; 
            } 

            delete[] loch; 
            loch = NULL;  
        }

        void neuesLochStanzen()
        {
            MetallPlatte* neu = new MetallPlatte(lochLaenge, lochBreite);

            int i = 0; 

            while (i < maxAnzahlLoecher && loch[i] != NULL) 
              i++; 

            if (i < maxAnzahlLoecher) 
            {
              loch[i] = neu;
              anzahlLoecher++;
            }
            else
            {
              try
              {
                throw out_of_range("Fehler");
              }
              catch(const std::out_of_range& ex)
              {
                cout << "Fehler\n";
              }
            }
        }

        double flaeche()
        {
            return getLaenge() * getBreite() - 
                   anzahlLoecher * (pow(lochBreite, 2) * 3.14 / 4);
        }
};

GelochtePlatte lochen(const MetallPlatte mp, int maxAnzahl, int anzahlLoecher) 
{ 
    GelochtePlatte gp(mp.getLaenge() , mp.getBreite(), maxAnzahl); 

    for(int i = 0; i < anzahlLoecher; i++) 
        gp.neuesLochStanzen();

    return gp;
} 

int main()
{
    MetallPlatte mp(20,10);
    GelochtePlatte gp = lochen(mp, 10, 3);

    cout << "mp.flaeche() = " << mp.flaeche() << endl;
    cout << "gp.flaeche() = " << gp.flaeche() << endl;

    if(gp.istSchwererAls(mp))
        cout << "gp ist schwerer als mp." << endl;
    else if(mp.istSchwererAls(gp))
        cout << "mp ist schwerer als gp." << endl;
    else
        cout << "mp und gp sind gleich schwer." << endl;

    char dummy;
    cin >> dummy;    
    return 0;
}

Sovok

try 
{ 
  throw out_of_range("Fehler"); 
} 
catch(const std::out_of_range& ex) 
{ 
  cout << "Fehler\n"; 
}

wtf?

Werner Salomon

Hallo Watto,

Du schreibst im Konstruktor von 'GelochtePlatte'

GR_Watto schrieb:

lochBreite = 1/(2*maxAnzahlLoecher) * getBreite();
            lochLaenge = 1/(2*maxAnzahlLoecher) * getLaenge();

Die Variable 'maxAnzahlLoecher' ist ein int; und damit ist 1 / (2 * <ein int >) eine Integer-Division und in diesem Fall immer ==0. Da die Lochfläche aus der 'lochlaenge' berechnet wird, ist diese auch 0 und die beide Platten sind zwangsläufig gleich, da alle Löcher 0 sind.

Im Copy-Konstruktor von 'GelochtePlatte'

GR_Watto schrieb:

for (int i=0; i < maxAnzahlLoecher; i++)
            {
                loch[i] = new MetallPlatte(*(rhs.loch[i]));
            }

dereferenzierst Du mit dem Ausdruck '*(rhs.loch[i])' auch Löcher-Pointer, die noch NULL sind; nämlich alle im Intervall [anzahlLoecher .. maxAnzahlLoecher). Hier sollte Dein Programm crashen. Richtig wäre

for (int i=0; i < anzahlLoecher ; i++)

Im Übrigen wirst Du zwei Platte auf diese Art & Weise nie gleich bekommen. Dafür musst Du schon eine Toleranz einführen - wie im richtigen Leben auch.

Gruß
Werner