ich habe eine (eigentlich) triviale Frage. Ich habe folgendes struct:

#define SIZEOFSTRUCT 100

typedef struct{
  int bla;
} MYSTRUCT;

Davon brauche ich nun x Stück. Ich lege mir ein Array mit

MYSTRUCT *pMyStruct = new MYSTRUCT[SIZEOFSTRUCT];

an. Ich bin nun der Meinung pMyStruct ist ein Array von Pointern, wehalb ich nun jedem Pointer ein MYSTRUCT zuweisen muss. Dazu würde ich

for(unsigned int index = 0; index < SIZEOFSTRUCT; index++){
  pMyStruct[index] = new MYSTRUCT;
}

schreiben. Aber der Compiler mag das nicht, er meint:
error: no match for ‘operator=’ in ‘(((MYSTRUCT)(((unsigned int)index) * 15376u)) + pMyStruct) = (MYSTRUCT)operator new(15376u)’*

Wie weise ich nun jedem Pointer im Array pMyStruct ein struct zu?

Danke für jede Hilfe,
M. Incani

Ich bin nun der Meinung pMyStruct ist ein Array von Pointern, wehalb ich nun jedem Pointer ein MYSTRUCT zuweisen muss.

Falsch: pMyStruct ist ein Zeiger auf ein Array von (leer initialisierten) Structs, d.h. du hast dort schon n fertige Objekte liegen, die du nur noch füllen mußt:

for(unsigned int index = 0; index < SIZEOFSTRUCT; index++){
  pMyStruct[index].bla = 4711 + index;
}

Falsch: pMyStruct ist ein Zeiger auf ein Array von (leer initialisierten) Structs, d.h. du hast dort schon n fertige Objekte liegen, die du nur noch füllen mußt:

for(unsigned int index = 0; index < SIZEOFSTRUCT; index++){
  pMyStruct[index].bla = 4711 + index;
}

Wenn ich aber beginne pMyStruct[index] zu füllen, überschreibe ich mir irgendwann anderswo Daten. Wenn ich pMyStruct[index] nicht fülle, passiert das nicht. Deshalb bin ich auf die Idee gekommen,

MYSTRUCT *pMyStruct = new MYSTRUCT[SIZEOFSTRUCT]

wären nur Zeiger. Ich muss jetzt mal dazu sagen, das in MYSTRUCT wieder ein array eines union ist, also eigentlich so aussieht.

#define SIZEOFSTRUCT 100
#define SIZEOFSOMETHING 100

typedef struct{
  int value1;
} THING1;

typedef struct{
  int value2;
} THING2;

typedef union
{
  THING1 a;
  THING2 b;
}SOMETHING;

typedef struct{
  int bla;
  pSomething SOMETHING[SIZEOFSOMETHING];
} MYSTRUCT;

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?

Gruß
M. Incani

CStoll schrieb:

Falsch: pMyStruct ist ein Zeiger auf ein Array von (leer initialisierten) Structs, d.h. du hast dort schon n fertige Objekte liegen, die du nur noch füllen mußt:

for(unsigned int index = 0; index < SIZEOFSTRUCT; index++){
  pMyStruct[index].bla = 4711 + index;
}

Wenn ich aber beginne pMyStruct[index] zu füllen, überschreibe ich mir irgendwann anderswo Daten. Wenn ich pMyStruct[index] nicht fülle, passiert das nicht.

Wie bitte? Natürlich überschreibst du deine Daten, wenn du pMyStruct[Index] füllst. Und wenn du dabei über das Ziel hinausschießt, kannst du auch fremde Daten zerlegen.

Ich muss jetzt mal dazu sagen, das in MYSTRUCT wieder ein array eines union ist, also eigentlich so aussieht.

#define SIZEOFSTRUCT 100
#define SIZEOFSOMETHING 100

typedef struct{
  int value1;
} THING1;

typedef struct{
  int value2;
} THING2;

typedef union
{
  THING1 a;
  THING2 b;
}SOMETHING;

typedef struct{
  int bla;
  pSomething SOMETHING[SIZEOFSOMETHING];
} MYSTRUCT;

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

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.

pMyStruct[index].pSomething = new SOMETHING[SIZEOFSOMETHING];

quittiert der Compiler mit der genannten Fehlermeldung. Und ich finde gerade keinen Hinweis darauf, wie ich das richtig mache.
Auch

pMyStruct[index].pSomething[0] = new SOMETHING;

oder

pMyStruct[index].pSomething[0] = new THING1;

schlägt fehl.

Gruß,
M. Incani

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

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.

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

MYSTRUCT aMystruct[ SIZEOFSTRUCT ];

so haste doch auch nen container von deiner struct oder?

Gruß Tobi

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

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

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

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.

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