problem mit delete

Hi ich habe ein Problem beim löschen eines mit new angelegten Arrays:

Ich habe eine Struct:

typedef struct ImageDataRec
{
    int             rowSpan;
    int             sizeX;
    int             sizeY;
    unsigned char   *data;

} ImageDataRec;

In einer Funktion passiert dann folgendes:

data.data = new unsigned char[data.rowSpan * data.sizeY];   

// Anderer Code

for(i = 0; i < (data.rowSpan * data.sizeY); i++)
delete[i] data.data;

data.rowSpan und data.sizeY bekommen ihre Werte aus einer jpg Datei, die Werte stimmen auch da die Datei korrekt geladen wird, allerdings stürzt mein Programm mit einem Speicherfehler ("Damaga after Normal Block") ab wenn ich am ende der Funktion den belegten Speicher unter data.data wieder freigeben will, die Werte von data.rowSpan und data.sizeY werden aber nach dem resavieren des Speichers nicht mehr verändert, wo liegt also der Fehler?

Ich hab auch schon versucht den Speicher mittels

delete [] data.data;

freizugeben, was allerdings den selben Fehler nach sich zieht.

Ich bin ratlos, normalerweise müssten doch beide Arten funktionieren oder?

ups ich hab was vergessen:

Man kann sichs zwar denken aber in der Funktion ist data eine Instanz von ImageDataRec

Wollt ich nur noch gesagt haben.

Knuddlbaer

Hi!

Du brauchst bzw. darfst hier keine Schleife einsetzen.

Ersetze mal

for(i = 0; i < (data.rowSpan * data.sizeY); i++)
delete[i] data.data;

durch

delete[] data.data;

das sollte gehen ?!

delete[] gibt den gesammten speicher frei. Du musst also nicht die Bytes einzeln löschen.

unsigned char * t = new unsigned char[1024];
delete t;

Shade Of Mine

Original erstellt von Knuddlbaer:
unsigned char * t = new unsigned char[1024];
delete t;

Tippfehler:

unsigned char * t = new unsigned char[1024];
delete [] t;

wäre richtig

mnab

Original erstellt von Shade Of Mine:
**Tippfehler:

unsigned char * t = new unsigned char[1024];
delete [] t;

wäre richtig**

ich denke nicht, ich mache es auch so, und ich glaube, beide machen genau das Gleiche

Shade Of Mine

Merksatz:
Jedes new hat sein delete und jedes new[] sein delete[]!

delete gibt ein element frei
delete[] gibt ein array frei

passend dazu:

new belegt platz für ein element
new[] belegt platz für ein array

HumeSikkins

ich denke nicht

Schade

ich mache es auch so

Dann machst du's falsch.

und ich glaube, beide machen genau das Gleiche

Dann vertrittst du hier zweifelsfrei einen Irrglaube.

Ein delete (ohne die []) auf Speicher der mit new[] angefordert wurde resultiert in undefiniertem Verhalten (siehe: 5.3.5p2). Dieses undefinierte Verhalten kann sich auf vielfältige Weise ausdrücken. Es kann sogar alles so laufen wie man es sich wünscht.

mnab

Original erstellt von HumeSikkins:

[quote]ich mache es auch so

Dann machst du's falsch.
[/QB][/QUOTE]
stimmt
ich hae nachgeguckt, man sollte delete[] benutzen. Aber ich bin sicher, ich hab's bei irgendeinem blöden Autor als "delete" gelesen.
Macht nix, dafür seid Ihr da, oder??

Grüße

Daniel E.

Bekomme ich irgendwelche Probleme/Nachteile, wenn ich einfach nie new & delete und immer new[] (mit der Dimension 1) und delete[] verwende?

Gerard

Original erstellt von Daniel E.:
Bekomme ich irgendwelche Probleme/Nachteile, wenn ich einfach nie new & delete und immer new[] (mit der Dimension 1) und delete[] verwende?

erst wenn du selbst new überlädst
AFIK
op new benutzt die operator new funktion
und op delete die operator delete funktion
und mit den ist sowas möglich

int main()
{
    void * p = operator new( 100 ); //allociert 100 bytes
    operator delete( p ); 
    // da operator delete von mir nicht verlang das ich ihn die größe angeben
    // schliesse ich draus das operator new irgend wo die größe abspeichert
}

wenn man ein eigenen allocator schreibt und new pro klasse überläd dann kann man diese overhead beseitigen

ps. sicher auf den gebiet bin ich nicht und habe selbt noch fragen, aber macht erstmal mein posting nieder

[ Dieser Beitrag wurde am 24.04.2003 um 00:34 Uhr von Dimah editiert. ]

volkard

Original erstellt von Daniel E.:
Bekomme ich irgendwelche Probleme/Nachteile, wenn ich einfach nie new & delete und immer new[] (mit der Dimension 1) und delete[] verwende?

hast probleme, konstruktorargumente zu übergeben und vermutlich isses auch leicht lahmer.

Knuddlbaer

Original erstellt von Shade Of Mine:
**Merksatz:
Jedes new hat sein delete und jedes new[] sein delete[]!

delete gibt ein element frei
delete[] gibt ein array frei

passend dazu:

new belegt platz für ein element
new[] belegt platz für ein array**

Oh man, da will man ein Beispiel geben wie es richtig ist und macht alles falsch was man falsch machen kann O *pfeif*

Daniel E.

volkard: Jeah, das Konstruktorargumentenargument ein gut :).

Dimah: Über das Überladen hatte ich nachgedacht, den Gedanken aber wegen »das macht doch eh niemand« wieder verworfen. Außerdem überlade ich -- wenn schon -- new[] gleich mit ;).