3. "ungültige Gleitkommaoperation" in Funktion, die nichts berechnet

"ungültige Gleitkommaoperation" in Funktion, die nichts berechnet

  • S

    So, jetzt hier der Code ein bißchen vollständiger. Da das Programm sehr groß ist, hab ich viel weggelassen, mußte auch einiges umbenennen, ich hoffe, mir ist dabei kein Fehler unterlaufen.

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

    0
  • ?

    Also ich finde ja, dies kommt der Definition von unlerserlichem Code schon ziemlich nahe. Schade, dass es sich auch nicht kompilieren lässt, dann hätte einem der Debugger ja schnell gesagt, was Sache ist.

    0
  • S

    Ja, ist in der Hinsicht nicht so dolle. Ist bei mir auch nicht so unleserlich. Aber ich kann nicht alles angeben hier, das würde den Rahmen sprengen. Und ich glaube auch nicht, daß die Originalbezeichnungen viel weiterhelfen würden, wenn man die Anwendung nicht kennt. Aber vielleicht helfen die Kommentare jetzt ja weiter.
    So, die Version jetzt müßte aber übersetzbar sein, nur ist die Originalversion bei mir an umfangreiche Ein- und Ausgabe gebunden, so daß ich sehen kann, was passiert. Das hier übersetzt zwar und läuft auch, aber ich weiß nicht, ob alles korrekt ist (würde ich die von mir zuvor beschriebene Fehlermeldung ganz unabhängig von der Benutzeroberfläche bekommen? Das Fenster mit der Standardausgabe verschwindet so schnell, daß ich nicht sehen kann, was passiert und durchsteppen geht auch nicht.)

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

    0
  • S

    Müßte ich noch irgendwas besser erklären/umbenennen, damit es für Außenstehende verständlich ist?
    Ich bin grad dabei, das Programm umzuschreiben für eine reproduzierbare Initialisierung des Arrays ci (im Moment ist die Initialisierung ja abhängig von einer Zufallszahl), um dann zu hoffen, dem Fehler mit dem Debugger (und Assembler?) systematisch wirklich auf die Schliche zu kommen. Aber im Grunde konnte ich es mir ja auch unsystematisch im Debugger ansehen und mir ist nichts aufgefallen. Ich weiß echt nicht weiter... Leider hab ich nicht mehr viel Zeit, da ich bis Anfang Januar noch einiges anderes an dem Programm machen muß und notfalls die alte Prg.version heranziehen und dort einige "billige" Implementierungen einbauen muß. Na ja, hoff ich mal, daß ich den Fehler bis heut nachmittag noch finde.
    Also, wenn ich noch was erklären müßte, sagt Bescheid, bin über jede Hilfe äußerst dankbar!!!

    0
  • D

    Hmm. Also ich kann das kompilieren und ohne Fehler laufen lassen.

    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/

    0
  • S

    Ich habe den Borland Builder 5. Das ganze Programm mit nem anderen Compiler zu testen geht nicht so einfach, da eine umfangreiche GUI dranhängt, die BCB-spezifisch ist.
    An was für Einstellungen könnte ich denn was ändern? Bevor ich einige umfangreiche Änderungen an den Datenstrukturen meiner Klassen gemacht habe, lief es ja mit den Einstellungen... Andererseits hatte ich neulich auch mal einen absolut unerklärlichen Fehler, hab den Code so geändert, daß er alles neu übersetzen mußte, und dann ging es (auch als ich den Code dann zurückgeändert habe). So ganz logisch find ich das alles nicht...

    0
  • S

    Also, bei mir, in meinem Gesamtprogramm, hängt es immer noch. Ich weiß nicht, ob ich was wesentliches weggelassen hab hier, aber wüßte nicht, was...

    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?

    0
  • D

    Hmm. Sehr verzwackt. 😉

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

    0
  • S

    Erstmal vielen Dank! Die Feststellung mit den Zeigern schränkt das Problem ja schon mal ein.

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

    0
  • D

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

    0
  • S

    Hi drakon,

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

    0
  • S

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

    0
  • D

    Nun ja. Deletes sollten eigentlich immer in direktem Zusammenhang mit den jeweiligen new's sein. Da du ansonsten im Falle von z.B einer Exception ziemlich sicher Speicherlecks bekommst. Ich würde euch dringend anraten Smart Pointer zu benutzen.
    http://www.boost.org/doc/libs/1_37_0/libs/smart_ptr/smart_ptr.htm

    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! 😉

    0
  • S

    Tja, das mit der Geduld ist so ne Sache. Wenn man nicht irgendwelchen Zwängen von außen unterliegen würde... Na ja, mal sehen, wie ich den besten Kompromiß finde... (auch das mit den SmartPointern: hört sich ganz gut an, aber bis Januar muß es erstmal einfach nur irgendwie funktionieren, und einiges mehr)

    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!

    0
  • Administrator

    susie schrieb:

    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

    0
  • S

    😮 staun, das wußt ich gar nicht, daß das geht.
    Na ja, im Grunde glaub ich nicht, daß das mein Problem ist, da meine Indizes immer in for-Schleifen hochgezählt werden, immer bis zur selben Grenze, aber ich werds im Hinterkopf behalten.

    0
  • S

    Doch noch ne Frage zu den Initialisierungslisten, zu der ich in den Büchern keine Antwort gefunden hab: Wenn ich das mache, muß ich dann jedes Member in dieser Liste angeben? Oder kann ich mir nur grad die Pointer raussuchen und diese mit 0 initialisieren, die restlichen Member so lassen, wie sie sind (mag in fremden Code so wenig wie möglich ändern)?

    0
  • D

    Ja, kannst du.

    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.mozilla🇩🇪official&client=firefox-a

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

    0
  • S

    Hm, weit bin ich damit nicht gekommen, die wenigsten Pointer sind Member einer Klasse.
    Außerdem ist eine neue Frage aufgetaucht: Wenn ich ein Array von Pointern hab, wie kann ich das denn initialisieren? (außer in einer Schleife?)

    0
  • N

    susie schrieb:

    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.

    0
Anmelden zum Antworten