Ich muss auf Arbeit ab und an mal programmieren und nutze ein externes Paket, welches noch in der Entwicklung ist und mir irgendetwas berechnen soll. Das hat immer ganz gut geklappt aber nach dem letzten Update meines Rechners bricht das Programm mit einem Speicherzurgiffsfehler im externen Code ab. Glücklicherweise habe ich den SourceCode davon. Mir ist es jetzt leider noch nicht gelungen ein Minimalbeispiel zu basteln, welches den Fehler erzeugt, aber ich schicke vielleicht mal die entsprechenden Code-Schnipsel.

Irgendwo in einem Header wird das definiert:

#define SizeOfInt      ((long) 4)

Dann wird folgender Code ausgeführt:

KVEL = new int[N_Vertices];

  memset(KVEL, 0, N_Vertices * SizeOfInt);

  // Hier wird jetzt irgendwas berechnet

  delete KVEL;

Der Fehler kommt beim Delete und ich verstehe einfach nicht warum.

malloc(): memory corruption: 0x0000000003796f20

Ich weiß, dass man bei dynamischer Speicherallokierung mit new int[] auch mit delete[] löschen sollte, aber das ist im Gesamten Softwarepaket so gemacht. Valgrind hört mit Meckern gar nicht mehr auf aber ich wollte diese Fehler nicht beheben.

Skeptisch macht mich, dass SizeOfInt auf 4 gesetzt wird. Hängt das nicht von der Rechnerarchitektur ab?

Hat jemand eine Ahnung was da los ist?
Ich komm irgendwie nicht drauf. Auf meinem Arbeitsrechner läuft das alles ohne Probleme durch.

Falls es hilft, noch meine GCC-Version:

g++ --version
g++ (SUSE Linux) 4.8.1 20130909 [gcc-4_8-branch revision 202388]

Danke schonmal für die Hilfe.

Grüße
Max

delete[] KVEL;

*Edit
Ausserdem ist das mit dem SizeOfInt ziemlich merkwürdig kompletter Schwachsinn (und schon gar nicht portablel). Wer hat diesen Code geschrieben?

lol?

define SizeOfInt (sizeof int)

Aber wozu überhaupt C++?

KVEL = malloc(N_Vertices * sizeof(*KVEL)); 
memset(KVEL, 0, N_Vertices * SizeOfInt);

  // Hier wird jetzt irgendwas berechnet

free(KVEL);

Jetzt ist das Problem folgendes:

KMT = new TJoint*[N_RootCells*4];   // Beim Debuggen war RootCells=8
memset(KMT, 0, N_RootCells*4 * SizeOfInt);

// hier wird mal wieder gerechnet und ab und an kommt ein 

KMT[i*4 + j] = new TJoint(...);

// Allerdings werden nicht alle Elemente in KMT belegt und irgendwann fragt er mal

Joint = KMT[Neib*4 + k];
if (Joint)
{
   Joint.Methode(...);
}

Jetzt das Problem:
Er will abfragen ob Joint==NULL ist.
Einige Elemente in KMT haben sinnvolle Werte und Joint.Methode(...) tut was es tun soll. Bei denen die NULL sind wird das Ganze übersprungen.

Direkt nach dem Malloc sehe ich beim Debuggen allerdings folgendes:

(gdb) p KMT[11]
$43 = (TJoint *) 0x0                  <---- Das schaut gut aus, if(Joint) wird übersprungen
(gdb) p KMT[12]
$44 = (TJoint *) 0xbabababababababa   <---- Das ist != NULL aber nichts sinnvolles => Speicherzugriffsfehler

Eigentlich sollten alle Elemente von 0 bis 23 auf 0x0 zeigen.
Darum war meine Vermutung, dass das mit dem SizeOfInt=4 nicht stimmen kann.

Ich habe es jetzt so geändert:

#define SizeOfPointer  sizeof(double*) // vorher ((long) 4)
#define SizeOfInt      sizeof(int)     // vorher ((long) 4)

und

memset(KMT, 0, N_RootCells*4 * SizeOfPointer); // vorher: SizeOfInt

TJoint* ist ja auch ein Pointer, also war SizeOfInt hier sowieso fehlplatziert.
Jetzt läuft alles durch und ich hoffe, dass dieser Fehler nicht noch öfter drin ist.

Ist die Lösung in Ordnung?

Danke für eure Hilfe.

Kann es sein, dass ein int bei mir 4 und ein Pointer 8 Byte hat?

Ja, auf einer 64-bit Architektur hat ein Pointer gewöhnlich 8 Bytes und auf einer 32-Bit Architektur ist ein Pointer in der Regel 4 Bytes.
Ein int ist meistens 4 Bytes aber darauf kannst du dich nicht verlassen. Wie gross ein int ist hängt vom Compiler ab. Der C++ Standard garantiert bloss eine Mindestgrösse.

Max3000 schrieb:

Ist die Lösung in Ordnung?

Nein. Schmeiss die ganzen #define raus (#define braucht man in C++ onehin kaum) und arbeite mit sizeof(..).

Nein. Schmeiss die ganzen #define raus (#define braucht man in C++ onehin kaum) und arbeite mit sizeof(..) sonst ist der Code nicht portabel. Ein int muss nicht zwingend 4 Bytes gross sein.

So würde ich es machen wenn es mein eigener Code wäre.
Aber in fremdem Code alles zu ändern bringt mir auch nichts, da es viel Arbeit ist und ich das beim nächsten Update alles nochmal neu machen müsste. Ich denke hier ist es einfacher das #define anzupassen:

#define SizeOfInt sizeof(int)

Aber du hast natürlich recht, man braucht es eigentlich nicht.

Danke
Max