Array von struct

CStoll

BlackPepper schrieb:

CStoll schrieb:

Bist du sicher, daß das der korrekte Code ist (pSomething ist nirgends definiert und der Name SOMETHING wird doppelt verwendet)?

Sorry, wenn ich das nicht gleich gesagt habe, aber ich versuche meißt die Dinge immer etwas einfacher darzstellen. Müssen in pSometing ebenfalls die structs mit new initialisiert werden?

Ja, das struct-Element ist ein Array von Zeigern - aber das ist ja auch eine andere Konstruktion als oben. Und diese Zeiger mußt du jeweils einzeln initialisieren (ob du per new Speicher anforderst oder die Adresse eines vorhandenen Objekts holst, ist dann egal).

Es soll innerhalb MYSTRUCT natürlich
typedef struct{
  int bla;
  SOMETHING pSomething[SIZEOFSOMETHING];
} MYSTRUCT;
heißen. Das ist ein Abschreibfehler gewesen. Mir misslingt aber zur Zeit das initialisieren der Zeiger.

Achso, na dann ist das auch kein Zeiger und du brauchst auch kein new. An der Stelle hast du ein ganz normales Array, auf dessen Elemente du über pMyStruct[index].pSomething[subindex].a zugreifen kannst (dabei mußt du nur aufpassen, daß du die Indexgrenzen nicht überschreitest - wenn subindex>=SIZEOFSOMETHING wird, schreibst du über das Ende deines Arrays hinaus (und dort liegt vermutlich der 'int bla;' vom nächsten MYSTRUCT-Objekt).

BlackPepper

CStoll schrieb:

Achso, na dann ist das auch kein Zeiger und du brauchst auch kein new. An der Stelle hast du ein ganz normales Array, auf dessen Elemente du über pMyStruct[index].pSomething[subindex].a zugreifen kannst (dabei mußt du nur aufpassen, daß du die Indexgrenzen nicht überschreitest - wenn subindex>=SIZEOFSOMETHING wird, schreibst du über das Ende deines Arrays hinaus (und dort liegt vermutlich der 'int bla;' vom nächsten MYSTRUCT-Objekt).

Nur das wir vom selben reden:

MYSTRUCT *pMyStruct = new MYSTRUCT[SIZEOFSTRUCT];

erzeugt ein Array von MYSTRUCT in dem ein Array vom SOMETHING ist. In pSomething [subindex] ist wiederum THING1 bwz THING2. Wenn ich die Indexgrenze garantiert nicht überschreibe, warum überschreibe ich mir dann immer wieder Daten an einer anderen Stelle? Das passiert wie bereits gesagt, nur dann, wenn ich in pMyStruct schreibe.

Gruß,
M. Incani

PS. Bin nun Mittag essen und gegen 12:30h wieder hier.

CStoll

BlackPepper schrieb:

Nur das wir vom selben reden:
MYSTRUCT *pMyStruct = new MYSTRUCT[SIZEOFSTRUCT];
erzeugt ein Array von MYSTRUCT in dem ein Array vom SOMETHING ist. In pSomething [subindex] ist wiederum THING1 bwz THING2.

Ja, soweit ist das richtig.

Wenn ich die Indexgrenze garantiert nicht überschreibe, warum überschreibe ich mir dann immer wieder Daten an einer anderen Stelle? Das passiert wie bereits gesagt, nur dann, wenn ich in pMyStruct schreibe.

Eigentlich solltest du damit auch nichts außerhalb deines Arrays überschreiben (es sei denn, du hast von irgendwo anders einen Zeiger/Referenz, der ins Array zielt - dessen Daten werden durch so einen Zugriff auch beeinflußt). Also zeig mal bitte etwas mehr zusammenhängenden Code, damit wir den Fehler nachvollziehen können (wo ist diese "andere Stelle"? Hast du pMyStruct versehentlich verbogen? ...?).

T0bi

wieso laesst du es net einfach mit dem pointer wenn der compiler meckert und machst es gleich so

MYSTRUCT aMystruct[ SIZEOFSTRUCT ];

so haste doch auch nen container von deiner struct oder?

Gruß Tobi

BlackPepper

T0bi schrieb:

wieso laesst du es net einfach mit dem pointer wenn der compiler meckert und machst es gleich so
MYSTRUCT aMystruct[ SIZEOFSTRUCT ];
so haste doch auch nen container von deiner struct oder?

Gruß Tobi

Hatte ich anfangs auch, aber dann traten diese seltsamen Fehler auf und ich dachte mir geht der Stack aus (Stacksize bei Linux = 8MB). Dann habe ich das Array auf den Heap angelegt, aber ich hab immer noch das gleiche Problem.

Gruß,
M.Incani

BlackPepper

CStoll schrieb:

Ja, soweit ist das richtig.

Wenn ich die Indexgrenze garantiert nicht überschreibe, warum überschreibe ich mir dann immer wieder Daten an einer anderen Stelle? Das passiert wie bereits gesagt, nur dann, wenn ich in pMyStruct schreibe.

Eigentlich solltest du damit auch nichts außerhalb deines Arrays überschreiben (es sei denn, du hast von irgendwo anders einen Zeiger/Referenz, der ins Array zielt - dessen Daten werden durch so einen Zugriff auch beeinflußt). Also zeig mal bitte etwas mehr zusammenhängenden Code, damit wir den Fehler nachvollziehen können (wo ist diese "andere Stelle"? Hast du pMyStruct versehentlich verbogen? ...?).

Nein, ich habe nur eine Referenz auf das Array (pMyStruct) und das sogar innerhalb einer einzigen Funktion. An dessen Ende steht auch delete. Mal überschreibe ich andere Container, mal Programmcode, mal ... ach was weiß ich...

Das Programm bleibt mit Segmentaion fault hängen. Und der Debugger zeigt immer eine andere Stelle, abhängig davon was ich compiliere. Deshalb tippe ich auf Buffer overflow und weiß nicht wie ich ihn finde.

Gruß
M. Incani

CStoll

Na dann zeig doch mal etwas mehr Code, damit sich andere ein Bild von der situation machen können (von hier aus sehen wir nur die Fragmente, die du bisher gezeigt hast - und daraus könnte nur ein Hellseher rekonstuieren, wie das komplette Programm aussehen könnte).

BlackPepper

CStoll schrieb:

Na dann zeig doch mal etwas mehr Code, damit sich andere ein Bild von der situation machen können (von hier aus sehen wir nur die Fragmente, die du bisher gezeigt hast - und daraus könnte nur ein Hellseher rekonstuieren, wie das komplette Programm aussehen könnte).

void Observer::writeDataInContainer(){

  MYSTRUCT *pMyStruct = new MYSTRUCT[SIZEOFSTRUCT];

  for (unsigned int index = 0; index < SIZEOFSTRUCT; index++){
    for (unsigend int subIndex = 0; subIndex < SIZEOFSOMETHING; subIndex++){
      pMyStruct[index].bla = index;
      pMyStruct[index].pSomething[subIndex].a.value1 = index + 1;
      pMyStruct[index].pSomething[subIndex].b.value2 = index + 2;
    }
  }
  // ...
  // ...
  // ...
  delete [] pMyStruct;
}

So wird das Array beschrieben. Wie gesagt, tritt die Segmentaion fault dann irgendwo anders im Programm auf. Wenn ich das Array nicht beschreibe, also die Schleife auskommentiere, hab ich keine Probleme.

Gruß,
M. Incani

CStoll

Erstens ist SOMETHING ein union, also kannst du nur eins der enthaltenen Objekte zur selben Zeit nutzen (die beiden Teile liegen im selben Speicherbereich).

Zweitens sehe ich an deinem Code keinen technischen Fehler (praktisch verbessern könntest du ihn, indem du die nackten Zeiger durch std::vector ersetzt). Also solltest du mal nachschauen, ob nicht "irgendwo anders" über die Grenzen eines Arrays hinausgeschrieben wurde.

BlackPepper

CStoll schrieb:

Erstens ist SOMETHING ein union, also kannst du nur eins der enthaltenen Objekte zur selben Zeit nutzen (die beiden Teile liegen im selben Speicherbereich).

Zweitens sehe ich an deinem Code keinen technischen Fehler (praktisch verbessern könntest du ihn, indem du die nackten Zeiger durch std::vector ersetzt). Also solltest du mal nachschauen, ob nicht "irgendwo anders" über die Grenzen eines Arrays hinausgeschrieben wurde.

Na gut, aber wie finde ich dann einen Buffer Overflow? Fall es einer ist. Welches Tool hilft mir? Oder wie kann mir der gdb den entsprechenden Hinweis geben?

Weil wenn das Array nicht beschrieben wird, klappt alles.

Gruß,
M. Incani