wenn man im Debugger bei einer Funktion rausfliegt, wo nur ein Wert zurückggegeben wird, mit der Meldung "ungültige Gleitkommaoperation", aber man führt gar keine Gleitkommaoperation durch (jedenfalls nicht in dieser Funktion), woran kann das liegen?

(Klasse DS erbt indirekt von Klasse S)

class S {
   protected:
   double c;

   public:
   double getC();
}

double S::getC() {
     return c;
}

class CI {
	DS* ds;
}

class A {
   CI* ci[xsize][ysize];

}

void A::calculate() {

     for (int x=0; x<xsize; x++) {
         for (int y=0; y<ysize; y++) {
             if (ci[x][y]->ds!=0)
                double test=ci[x][y]->ds->getC();
         }
     }
}

Und wenn ich dann in der Methode calculate() bin und mich so durchsteppe, fliege ich immer in S::getC() raus mit der Meldung "ungültige Gleitkommaoperation". Dabei rechne ich da ja gar nicht (erst in der (hier nicht dargestellten) nächsten Zeile von calculate, die ich aber nie erreiche).
Ich hoffe, ich hab alles wesentliche vom Programm angegeben.

Würde mich sehr freuen über Hilfe!
Und schöne Weihnachten noch :xmas1:

bb

hm, da hab ich jetzt geschaut, mir ist nichts aufgefallen. Es ist auch ein bißchen blöd im Debugger nachzuvollziehen, da der Fehler nicht in jeder Array-komponente von ci auftritt (neben der Tatsache, daß in ci in manchen Fällen ds nicht gesetzt ist, passiert es aber auch nicht in jedem Fall, wo ds gesetzt ist).

Ich hab jetzt mal den Code aufgesplittet:

double S::getC() {
     double test=c;
     return c;
}

aber damit hab ich auch nicht mehr rausgefunden.
Ich bin jetzt am überlegen, ob ich mir den Assembler angucken soll, aber es ist Lichtjahre her, daß ich mich mit Assembler beschäftigt habe und wie das dann alles im BCB dargestellt wird, muß ich dann auch erstmal rausfinden. Nur langsam hab ich keine Ideen mehr. Mist!

Also, wenn jemand ne Idee hat, was es sein könnte, wäre ich superfroh!

Mir ist hier zu viel unklar, um wirklich etwas sagen zu können. (Was ist DS? Wo kommt der Speicher her usw. )

class S {
      protected:
      //Instanzvariablen:
      double  itsC;

      public:
      int     itsX, itsY;

      public:
      //Konstruktoren und Destruktoren
      S();
      S(double c, int x, int y);
      virtual ~S();

      //set- und get-methoden
      void setC(double c);
      double getC(); 
};

class W : public S {

      public:
      //Konstruktoren und Destruktoren:
      W();
      W(double c, int x, int y);
      virtual ~W()
};

class DS : public W {

      public:
      //Konstruktoren und Destruktoren:
      DS();
      DS(double c, int x, int y);
      virtual ~DS();

};

S::S(){}

S::S(double c, int x, int y){
     itsC=c;
     itsX=x;
     itsY=y;
}

S::~S(){
}

void S::setC(double c) {
     itsC=c;
}

double S::getC() {
     double test=itsC;
     return itsC;
}

W::W(){}

W::W(double c, int x, int y)
     :S(c, x, y) {
}

W::~W(){}

DS:: DS(){}  //das Leerzeichen ist nur drin, weil hier sonst ein Smilie erscheint

DS:: DS(double c, int x, int y)
     :W(c, x, y) {
}

DS::~DS(){}

Klassen In, De, Sh erben auch indirekt von S (dürfte aber hier nichts zur Sache tun)

class CI {
      //Instanzvariablen:
      private:
      int     itsX, itsY;

      Shr* shr;
      DShr* dShr;
      Dec* dec;
      Inc* inc;

      //Methoden:
      CI(int x, int y);
      ~CI();
};

class A {

      //Instanzvariable:
      public:
      CI* ci[xsize][ysize];

      //Methoden:
      A();
      void initA(double sh, double dS, double de, double in);

      void calculate(); 

};

CI::CI(int x, int y) {
   itsX=x;
   itsY=y;

   shr=0;
   dShr=0;
   dec=0;
   inc=0;

}

CI::~CI() {
}

A::A(){

     c_shr=0.0;
     c_dShr=0.0;
     c_dec=0.0;
     c_inc=0.0;
     n_shr=0;
     n_dShr=0;
     n_dec=0;
     n_inc=0;

     double initSh=0.18325, initDShr=0.065, initDec=0.105, initInc=0.015; 

     initA(initShr, initDShr, initDec, initInc);
}

void A::initA(double sh, double dS, double de, double in) {
     double shr_c=sh/0.8;  
     double nonshr_c =1-shr_c;
     double z;
     for (int x=0; x<xsize; x++) {
         for (int y=0; y<ysize; y++) {
             ci[x][y]= new CI(x,y);
             z=z01();
             if (z< sh_c) ci[x][y]->shr= new Sh(0.8, x,y);
             else 
             {
                if (dS>0) ci[x][y]->dShr= new DS(dS/(nonshr_c/3), x,y);
                if (in>0) ci[x][y]->inc= new In(in/(nonshr_c/3), x,y);
                if (de>0) ci[x][y]->dec= new De(de/(nonshr_c/3), x,y);
             }
         }
     }
}

void A::calculate() {

     c_shr=0.0;
     c_dShr=0.0;
     c_dec=0.0;
     c_inc=0.0;

     n_shr=0;
     n_dShr=0;
     n_dec=0;
     n_inc=0;

     for (int x=0; x<xsize; x++) {
         for (int y=0; y<ysize; y++) {

             if (ci[x][y]->shr!=0)   { c_shr+=ci[x][y]->shr->getC();         n_shr++;}
             if (ci[x][y]->dShr!=0) { double test=ci[x][y]->dShr->getC();                c_dShr+=test; n_dShr++;}
             if (ci[x][y]->inc!=0)   { c_inc+=ci[x][y]->inc->getC();      n_inc++;}
             if (ci[x][y]->dec!=0)   { c_dec+=ci[x][y]->dec->getC();      n_dec++;}

         } //end for y
     } //end for x

     c_shr/=(xsize*ysize);
     c_dShr/=(xsize*ysize);
     c_dec/=(xsize*ysize);
     c_inc/=(xsize*ysize);

}

in aufrufender Funktion:

a=new A();
a->calculate();

Der Fehler tritt also in der Methode calculate auf, wo jetzt das mit dem test steht (Zeile 99 unten) bzw. in dem entsprechenden getC (Zeile 57 oben).

#include <stdlib.h>

const int xsize=30;
const int ysize=30;

inline double z01() {return rand()/(double) RAND_MAX;}

/********************************************************
* Klasse S und Unterklassen W, Shr, DShr, Dec und Inc   *
*********************************************************/

class S {
      protected:
      //Instanzvariablen:
      double  itsC;

      public:
      int     itsX, itsY;

      public:
      //Konstruktoren und Destruktoren
      S();
      S(double c, int x, int y);
      virtual ~S();

      //set- und get-methoden
      void setC(double c);
      double getC();
};

class W : public S {

      public:
      //Konstruktoren und Destruktoren:
      W();
      W(double c, int x, int y);
      virtual ~W();
};

class DShr : public W {

      public:
      //Konstruktoren und Destruktoren:
      DShr();
      DShr(double c, int x, int y);
      virtual ~DShr();

};

class Shr : public W {

      public:
      //Konstruktoren und Destruktoren:
      Shr();
      Shr(double c, int x, int y);
      virtual ~Shr();

};

class Inc : public S {

      public:
      //Konstruktoren und Destruktoren:
      Inc();
      Inc(double c, int x, int y);
      virtual ~Inc();

};

class Dec : public S {

      public:
      //Konstruktoren und Destruktoren:
      Dec();
      Dec(double c, int x, int y);
      virtual ~Dec();

};

S::S(){}

S::S(double c, int x, int y){
     itsC=c;
     itsX=x;
     itsY=y;
}

S::~S(){
}

void S::setC(double c) {
     itsC=c;
}

double S::getC() {
     double test=itsC;
     return itsC;
}

W::W(){}

W::W(double c, int x, int y)
     :S(c, x, y) {
}

W::~W(){}

DShr::DShr(){}  

DShr::DShr(double c, int x, int y)
     :W(c, x, y) {
}

DShr::~DShr(){}

Shr::Shr(){}  

Shr::Shr(double c, int x, int y)
     :W(c, x, y) {
}

Shr::~Shr(){}

Inc::Inc(){}  

Inc::Inc(double c, int x, int y)
     :S(c, x, y) {
}

Inc::~Inc(){}

Dec::Dec(){}  

Dec::Dec(double c, int x, int y)
     :S(c, x, y) {
}

Dec::~Dec(){}

/*******************************************************************
* Klasse CI, die Pointer auf Instanzen der obigen Klassen enthält  *
*******************************************************************/

class CI {
      //Instanzvariablen:
      public:
      int     itsX, itsY;

      Shr* shr;
      DShr* dShr;
      Dec* dec;
      Inc* inc;

      //Methoden:
      CI(int x, int y);
      ~CI();
};

CI::CI(int x, int y) {
   itsX=x;
   itsY=y;

   shr=0;
   dShr=0;
   dec=0;
   inc=0;

}

CI::~CI() {
}

/***************************************************************
* Klasse A, die ein Array von CI enthält                      *
***************************************************************/

class A {

      //Instanzvariable:
      public:
      CI* ci[xsize][ysize];

      //die Anzahl der jeweiligen Instanzen im Array ci:
      int n_shr, n_dShr, n_dec, n_inc;

      //der Durchschnitt der c-Werte aller Instanzen von jeweils einer
      //der Klassen Shr, DShr, Dec und Inc, übers ganze Array:
      double c_shr, c_dShr, c_dec, c_inc;

      //Methoden:
      A();
      void initA(double sh, double dS, double de, double in);

      void calculate();

};

A::A(){

     c_shr=0.0;
     c_dShr=0.0;
     c_dec=0.0;
     c_inc=0.0;
     n_shr=0;
     n_dShr=0;
     n_dec=0;
     n_inc=0;

     double initShr=0.18325, initDShr=0.065, initDec=0.105, initInc=0.015;

     initA(initShr, initDShr, initDec, initInc);
}

// initialisiert jede Arraykomponente von ci, entweder nur mit einer 
//Instanz von "Shr" oder eine Arraykomponente enthält Instanzen von 
//"DShr", "Inc" und "Dec" gleichzeitig. 
//Der Anteil der Arraykomponenten multipliziert mit dem c-Wert der 
//Instanz entspricht den Parametern sh, dS, de und in der Funktion.
void A::initA(double sh, double dS, double de, double in) {
     double shr_c=sh/0.8; //Anteil der Arraykomponenten mit Shr
     double nonshr_c =1-shr_c; //Anteil Arraykomponenten ohne Shr
     double z;
     for (int x=0; x<xsize; x++) {
         for (int y=0; y<ysize; y++) {
             ci[x][y]= new CI(x,y);
             z=z01();
             if (z< shr_c) ci[x][y]->shr= new Shr(0.8, x,y);
             else
             {
                if (dS>0) ci[x][y]->dShr= new DShr(dS/(nonshr_c/3), x,y);
                if (in>0) ci[x][y]->inc= new Inc(in/(nonshr_c/3), x,y);
                if (de>0) ci[x][y]->dec= new Dec(de/(nonshr_c/3), x,y);
             }
         }
     }
}

//berechnet die Anzahl der jeweiligen Instanzen im Array ci und 
//den durchschnittlichen c-Wert
void A::calculate() {

     c_shr=0.0;
     c_dShr=0.0;
     c_dec=0.0;
     c_inc=0.0;

     n_shr=0;
     n_dShr=0;
     n_dec=0;
     n_inc=0;

     for (int x=0; x<xsize; x++) {
         for (int y=0; y<ysize; y++) {

             if (ci[x][y]->shr!=0)   { c_shr+=ci[x][y]->shr->getC();         n_shr++;}
             if (ci[x][y]->dShr!=0) { double test=ci[x][y]->dShr->getC();                c_dShr+=test; n_dShr++;}
             if (ci[x][y]->inc!=0)   { c_inc+=ci[x][y]->inc->getC();      n_inc++;}
             if (ci[x][y]->dec!=0)   { c_dec+=ci[x][y]->dec->getC();      n_dec++;}

         } //end for y
     } //end for x

     c_shr/=(xsize*ysize);
     c_dShr/=(xsize*ysize);
     c_dec/=(xsize*ysize);
     c_inc/=(xsize*ysize);

}

/***************************************************************
* main                                                         *
***************************************************************/

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

        a=new A();
        a->calculate();
        return 0;
}

In meiner Originalversion vom Code kam die Fehlermeldung in Zeile 257 bzw. 98.

Was hast du für einen Compiler? - Ev. hast du etwas an den Einstellungen falsch eingestellt.

Ich habe VC++ Express Edition. Kannst es ja einmal mit dem probieren.
http://www.microsoft.com/germany/Express/

Ich hab zu Testzwecken in mein Programm A::initA mal abgespeckt eingebaut (das, was im zuletzt geposteten Code in Zeile 218 anfängt):

void A::initA(double sh, double dS, double de, double in) {

     for (int x=0; x<xsize; x++) {
         for (int y=0; y<ysize; y++) {
             ci[x][y]= new CI(x,y);

                 ci[x][y]->dShr= new DShr(0.2, x,y);
                 ci[x][y]->inc= new Inc(0.2, x,y);
                 ci[x][y]->dec= new Dec(0.2, x,y);

         }
     }
}

so daß jede Arraykomponente gleich aufgebaut ist (die Parameter sind da nun überflüssig). Wenn ich mich da durchsteppe im Debugger, müßte der Fehler ja schon beim ersten Arrayelement in "calculate" auftreten, tut es aber nicht. Erst so ca. beim 10. Mal. Das ist doch völlig unlogisch, oder?

Also das klingt für mich so, dass der Fehler nicht wirklich in diesem Code abschnitt liegt. Es kann sein, dass du z.B einen ungültigen Zeiger hast, der nicht auf 0 gesetzt wurde und dann irgendwo immernoch benutzt. Dann können solche Fehler auftreten, die völlig unlogisch erscheinen, weil sie nie da zuschlagen, wo der Fehler wirklich liegt.
Also mein Tipp:
Schau dir alle Zeiger und Speicher an, den du aus dem Freispeicher holst und dann musst du alle abhängigkeiten vor Augen führen und verhindern, dass irgendwo ein ungültiger Zeiger benutzt wird.

Das ist das, was mir einfällt.

Ansonsten musst du halt einmal alles Schritt für Schritt auskommentieren, bis der Fehler nicht mehr kommt. Allerdings bin ich eigentlich sehr davon überzogen, dass es ein Fehler mit einem Zeiger ist. (Kannst sonst ja auch einmal mit smart Pointern probieren, da sollten solche Fehler dann auch nicht mehr auftreten.)

Allerdings ist das ne echte Hiobsbotschaft für mich. Im Grunde hab ich sowas die ganze Zeit befürchtet (auch bei dem seltsamen Fehler, der dann plötzlich verschwunden war, nachdem alles neu übersetzt wurde - bzw. da haben wir gedacht, daß irgendwelcher Speicher (Arrays) durch andere Programmteile unabsichtlich überschrieben wird).
Problem ist, daß ich den Code einer Kollegin verwende, und ich hab keine Ahnung, ob der Fehler bei ihr oder bei mir liegt. Sowohl ihr als auch mein Code ist schon recht umfangreich und bei ihrem Programm kenn ich mich auch gar nicht aus.
Im Grunde kann ich zwar die vorige Programmversion wieder verwenden und da eine sehr einfache Lösung einbauen, nur im Grunde bewahrt mich das nicht davor, daß so ein Fehler wieder auftaucht, sowie ich irgendwas an dem Code ändere (wenn ich es richtig mitbekommen habe). Ich könnte grad nur fluchen, da meine Diss. darauf aufbaut, aber das Programm nur Mittel zum Zweck ist und eh schon alles sch*** läuft...

Aber jetzt doch nochmal zum Verständnis:
das Problem tritt aber dann doch nur auf, wenn ich einen Zeiger nicht auf 0 setze und doch noch verwende?
Für meinen Teil (und eigentlich müßte das auf meine Kollegin auch zutreffen) bin ich aber noch in der Initialisierungsphase wenn der Fehler auftritt. Da ist es ja eigentlich noch nicht so, daß ein Zeiger nicht mehr benutzt wird, deswegen kann ich ja eigentlich auch keinen vergessen haben.

Und entspricht es Eurer Erfahrung, daß so ein Zeigerfehler in einem Programm sein kann, aber sich lange nicht äußert? Also im Prinzip könnte es schon so sein, daß der Fehler im Code meiner Kollegin ist, die ihren Code alleine zwar viel getestet hat, daß er sich aber erst äußert, wenn von mir irgendwelcher Code dazukommt?

Sorry fürs lamentieren, aber ich bin grad verzweifelt und ratlos, in welcher Richtung ich weitermachen soll. Vielleicht doch mal unser beider Code durchforsten, vielleicht ist in der Initialierung ja noch gar nicht soviel fragwürdiges...

Aber jetzt doch nochmal zum Verständnis:
das Problem tritt aber dann doch nur auf, wenn ich einen Zeiger nicht auf 0 setze und doch noch verwende?

Grundsätzlich ja. Aber könnte theoretisch auch sein,dass du ausserhalb von irgendwelchen Grenzen zugreifst und dann kann das auch passieren.
Im übrigen habe ich in deinem Code wirklich kein einziges delete gesehen. Was mich ansich schon einmal ein wenig beunruhigt.

Und entspricht es Eurer Erfahrung, daß so ein Zeigerfehler in einem Programm sein kann, aber sich lange nicht äußert? Also im Prinzip könnte es schon so sein, daß der Fehler im Code meiner Kollegin ist, die ihren Code alleine zwar viel getestet hat, daß er sich aber erst äußert, wenn von mir irgendwelcher Code dazukommt?

Ohh ja. Das ist ja gerade das fiese daran. Das Verhalten ist undefiniert. Und somit kann alles passieren. Und das es durchaus so aussieht, als ob es funktioniert, ist gar nicht einmal so ungewöhnlich. Wenn es eine sicher einen Laufzeitfehler auslöst, dann hätte ich mir auch schon etliche Debug Stunden sparen können. (Das kenn wohl jeder).

Was helfen könnte, wäre sicher auch noch die Initialisierungsliste zu benutzen und alle Zeiger auf 0 zu setzen. Dann musst du ihnen vor der Benutzung einen Wert zuweisen und es kann nicht sein, dass es zufälligerweise doch funktioniert..

erstmal wieder vielen Dank. Bin ja froh, wenn ich das Problem umkreisen kann.

zu den fehlenden deletes in meinem Code: Stimmt, steht auch noch auf meiner ToDo-Liste. Also, normalerweise werden die Pointerobjekte der Arrayelemente (also dshr, inc usw.) teilweise im weiteren Programmverlauf abhängig von irgendwelchen Bedingungen gelöscht (da ist es auch schon drin, aber hab jetzt nicht alles gepostet), das Array ci mit den übrigen Arrayelementen und a bleiben bis zum Programmende bestehen, aber die muß ich da auch noch löschen.

Aber könnte theoretisch auch sein,dass du ausserhalb von irgendwelchen Grenzen zugreifst und dann kann das auch passieren.

Was meinst Du da? Inwiefern darauf zugreifen?

Was helfen könnte, wäre sicher auch noch die Initialisierungsliste zu benutzen

Was ist eine Initialisierungsliste?

Na ja, ich hab jetzt mal die Initialisierung meiner Kollegin als Ganzes auskommentiert, und jetzt klappt es (bzw. der Fehler tritt dann später auf, weil auf irgendwas zugegriffen werden soll, was halt noch nicht initialisert ist). Das spricht ja eigentlich schon dafür, daß es am Code meiner Kollegin liegt, oder? Puh, nur deren Initialisierung ist echt umfangreich...

Was helfen könnte, wäre sicher auch noch die Initialisierungsliste zu benutzen und alle Zeiger auf 0 zu setzen. Dann musst du ihnen vor der Benutzung einen Wert zuweisen und es kann nicht sein, dass es zufälligerweise doch funktioniert..

Ach so, Du meinst es so herum, daß ein Pointer deklariert wurde, aber NOCH einen undefinierten Wert besitzt. Und der dann verwendet wird, obwohl er noch nicht initialisiert wurde? Dann müßte ich den Code auf alle Pointer durchforsten (Suche nach "*") und diese mit 0 initialisieren.

Ich dachte, daß du meinst, daß ein Pointer verwendet wurde, aber nach der Benutzung nicht auf 0 zurückgesetzt wurde, so daß man evtl. auf Werte zurückgreift, die nicht mehr wirklich gültig sind (ist ja auch möglich, aber zumindest wird dabei nichts soooo unplausibles rauskommen oder ist unwahrscheinlicher).

Naja. Du hast ja Arrays und wenn du nun ausserhalb von gültigem Speicher zugreist, kann ein solcher Fehler auch vorkommen. (Auch wenn die Boundchecks stimmen, kann es sein, dass gar kein Speicher angefordert wurde und dann sonst wo zugegriffen wird).

Initialisierungsliste ist die einzige Möglichkeit eine (nicht-statische) Variable innerhalb einer Klasse zu initialisieren.

class foo
{
 foo ()
 :        //Anfang einer Initialisierungsliste
 i ( 2 ), // jede Member mit einem Startwert füllen
 pi ( 0 ), // Zeiger am besten auf 0
 ci ( 42 ) //einzige möglichkeit einen const Wert zu initialisieren
 {
  i = 5; // das hier ist niemals eine initialisierung, sonder immer eine Zuweisung
  ci = 993; // niemals möglich, da eine konstante ihren Wert bei der Initialisierung bekommt
 }

 int i;
 int* pi;
 const int ci;
};

Naja. Ich kann jetzt eigentlich nicht mehr viel machen, ausser zu sagen, dass du das schon noch mit ein wenig Geduld hinbringen kannst. Freunde dich mit deinem Debugger an und geniese die paar Stunden Debugging Sessions und dann das, was am wichtigsten ist. Lern im nachhinein aus deinen Fehlern!

Ok, mit dem direkten delete einbauen mach ich es in Zukunft anders. Aber in dem Fall müßte es doch wirklich am Code meiner Kollegin liegen, oder kann man das so definitiv auch nicht sagen?

Naja. Du hast ja Arrays und wenn du nun ausserhalb von gültigem Speicher zugreist, kann ein solcher Fehler auch vorkommen. (Auch wenn die Boundchecks stimmen, kann es sein, dass gar kein Speicher angefordert wurde und dann sonst wo zugegriffen wird).

Wie kann das gehen? Wenn ich ein Array deklariere, wird doch automatisch Speicher dafür angefordert?! Und wenn ich es nicht deklariere, kann ich es auch nicht verwenden?!

Aber diese Möglichkeit als Fehlerquelle gibt es ja auch noch?! :

Ich dachte, daß du meinst, daß ein Pointer verwendet wurde, aber nach der Benutzung nicht auf 0 zurückgesetzt wurde, so daß man evtl. auf Werte zurückgreift, die nicht mehr wirklich gültig sind

Jedenfalls vielen Dank nochmal!

Wie kann das gehen? Wenn ich ein Array deklariere, wird doch automatisch Speicher dafür angefordert?! Und wenn ich es nicht deklariere, kann ich es auch nicht verwenden?!

char myArray[20];
myArray[200] = 34;

// Oder
char* p = new char[20];
p[30] = 3;

delete[] p;

Das ist gültiges C++ mit gesichertem undefiniertem Verhalten
Also ein standard konformer Kompiler wird das kompilieren, zur Laufzeit wird aber irgendetwas seltsames oder auch nichts passieren. Es ist halt nicht definiert, was passieren wird.

Grüssli

Die ersten 2 Einträge sollten schon genügen..
http://www.google.ch/search?q=initialisierungsliste+c%2B%2B&ie=utf-8&oe=utf-8&aq=t&rls=org.mozillaofficial&client=firefox-a

Grundsätzlich sollten aber alle Member initialisiert werden, um Probleme zu vermeiden. Aber besser die Zeiger, als gar nichts.

Wenn ich ein Array von Pointern hab, wie kann ich das denn initialisieren? (außer in einer Schleife?)

Wie alle Arrays.

Normalerweise kannst du die Array-Initialisierungsliste verwenden. Arrays als Member können nur mit Schleifen initialisiert werden (du kannst natürlich auch Funktionen wie std::fill() oder std::generate() verwenden.