//ein Batzen Speicher für beide Dimensionen
long* mem  = new long[dim1*dim2];
memset(mem, 0, dim1*dim2*sizeof(long));

//Speicher virtuelle erste Dimension
long** ptrmem = new long*[dim1];

//Dim1 Adressen aus Batzen zuweisen
int i = 0;
for(;i<dim1;++i)
   ptrmem[i] = &mem[i*dim2];
//test ptrmem[x][y] = 10;

//alles wieder löschen
//is das überhaupt nötig, hier auf
//NULL zu setzen?
for(i = 0;i<DIM1;++i) 
   ptrmem[i] = NULL;
//auch hier bin ich mir nicht sicher
//ob del[] oder del
delete ptrmem;
ptrmem = NULL;
delete[] mem;
mem = NULL;

Das ist eigentlich vollkommen unnötig und überflüssig, weil du den ganzen Speicher ja eh wieder freigibst und dann das Betriebssystem da dann ganz andere Werte als NULL reinschreiben kann.

//auch hier bin ich mir nicht sicher
//ob del[] oder del
delete ptrmem;
ptrmem = NULL;
delete[] mem;
mem = NULL;

Hmmm, theoretisch genügt meiner Meinung nach ein "normales" delete. delete[] unterscheidet sich ja nur darin vom "normalen" delete, dass delete[] für jedes Objekt des Arrays den Destruktor aufruft, während das "normale" delete nur für das erste Objekt des Arrays den Destruktor aufruft. Beide Operatoren sollten aber den gleichen Speicherbereich wieder freigeben, und da du in deinem Beispiel nur mit elementaren Datentypen hantierst (die an sich keinen Konstruktor bzw. Destruktor haben), reicht theoretisch das "normale" delete.

Allerdings heißt ja "genügen" nicht, dass man es nicht anders machen sollte. Ich persönlich würde auf jeden Fall ein delete[] verwenden, damit es im Quelltext offensichtlich wird, dass du Speicherplatz für ein Array freigibst und damit, falls du irgendwann mal den Datentyp des Arrays beim Umschreiben des Quelltextes ändern solltest, nicht vergisst beim delete die eckigen Klammern zu setzen.

Hmmm, theoretisch genügt meiner Meinung nach ein "normales" delete. delete[] unterscheidet sich ja nur darin vom "normalen" delete, dass delete[] für jedes Objekt des Arrays den Destruktor aufruft, während das "normale" delete nur für das erste Objekt des Arrays den Destruktor aufruft. Beide Operatoren sollten aber den gleichen Speicherbereich wieder freigeben, und da du in deinem Beispiel nur mit elementaren Datentypen hantierst (die an sich keinen Konstruktor bzw. Destruktor haben), reicht theoretisch das "normale" delete.

Falsch. Alles, was mit new[] angelegt wurde, muß mit delete[] wieder freigegeben werden - alle Versuche, new/delete und new[]/delete[] zu mischen, wären nicht portabel.

BTW, um alles auf null zu setzen gibt’s die nette Funktion "SecureZeroMemory" da brauchst du keine Schleife.
(Aber für deine zwecke in dem Beispiel brauchst du nichts auf NULL setzen wie mein Vorredner schon anmerkte.)

BTW, um alles auf null zu setzen gibt’s die nette Funktion "SecureZeroMemory" da brauchst du keine Schleife.

Wenn schon, dann memset. WinAPI != C++.

Mr Evil schrieb:

BTW, um alles auf null zu setzen gibt’s die nette Funktion "SecureZeroMemory" da brauchst du keine Schleife.

Wenn schon, dann memset. WinAPI != C++.

Wenn schon C++, warum dann nicht Sprachmittel?

long* mem  = new long[dim1*dim2] (); // fertig

Wenn schon C++, warum dann nicht Sprachmittel?

Weil es um diesen Abschnitt geht:

int i = 0;
for(i = 0;i<DIM1;++i)
   ptrmem[i] = NULL;

long* mem  = new long[dim1*dim2] (); // fertig

Und das schluckt der Compiler? Btw wäre mir neu, daß man bei new[] zusätzlich Ctor-Parameter mitgeben kann.

Weil es um diesen Abschnitt geht:

int i = 0;
for(i = 0;i<DIM1;++i)
   ptrmem[i] = NULL;

Ist mir schon klar. Der Sinn war ja auch dass dieser Abschnitt unnötig wird.

CStoll schrieb:

Und das schluckt der Compiler? Btw wäre mir neu, daß man bei new[] zusätzlich Ctor-Parameter mitgeben kann.

Sind ja auch keine Parameter. IMHO kann man so die Default-Initialisierung für Arrays erzwingen. Wie bei int i(), wonach i garantiert 0 ist.

Das schlucken Comeau, MSVC und GCC, und der MSVC verhält sich auch so dass mit Klammern alle Elemente des Arrays auf 0 gesetzt sind. (Der GCC auch, aber der macht es auch ohne Klammern, beim MSVC steht dann Schrott drin).

Ist mir schon klar.

Ich fürchte nicht.

Der Sinn war ja auch dass dieser Abschnitt unnötig wird.

Der Abschnitt wird aber durch dein new[] nicht unnötig. Es geht darum, ein bereits bestehendes Array mit 0 zu füllen. Du beziehst dich auf ein anderes Stück Code als ich.

//alles wieder löschen
//is das überhaupt nötig, hier auf
//NULL zu setzen?
for(i = 0;i<DIM1;++i)
   ptrmem[i] = NULL;

Ich sage: es ist nicht nötig, aber wenn mans trotzdem macht ist memset wohl sinnvoller als irgendwelche WinAPI-Funktionen.

Falsch. Alles, was mit new[] angelegt wurde, muß mit delete[] wieder freigegeben werden - alle Versuche, new/delete und new[]/delete[] zu mischen, wären nicht portabel.

Ist das sicher? Also in meinem Buch und in diesem Tutorial z.B. steht es anders http://www.cpp-tutor.de/cpp/le11/le11_01.htm#delete

Und zumindest mein Buch, schmückt sich damit standard-konform zu sein...

Ist das sicher? Also in meinem Buch und in diesem Tutorial z.B. steht es anders http://www.cpp-tutor.de/cpp/le11/le11_01.htm#delete

In diesem Tutorial steht exakt das drin, was CStoll auch gesagt hat!?

Wurde dagegen Speicher für ein Feld reserviert, so muss nach dem delete Operator zunächst eine leere eckige Klammer stehen und erst danach der von new zurückgelieferte Zeiger. [...] Vergessen Sie daher niemals die eckigen Klammer beim delete von Feldern.

In vielen Fällen verwenden new und new[] tatsächlich die selbe Speicherverwaltung, dann macht es nichts aus, daß du die [] weglässt. Aber das ist keineswegs garantiert (schließlich braucht new[] noch zusätzlichen Verwaltungsaufwand, um die Arraygröße zu notieren).

Eine Beispiel-Implementation:

void* operator new(size_t s)
{
  return malloc(s);
}

void operator delete(void* p)
{
  free(p);
}

void* operator new[](size_t s)
{
  char* p=malloc(s+sizeof(size_t));
  *((int*)p) = s/typesize;//damit beim delete[] nachgesehen werden kann, wieviele Objekte ich löschen muß
  return p+sizeof(size_t);
}

void* operator delete[](void* p)
{
  free((char*)p-sizeof(size_t));
}

wenn du jetzt einen Zeiger von new[] an delete weitergibst, hast du gute Chancen auf eine Access Violation

... und in diesem Tutorial z.B. steht es anders http://www.cpp-tutor.de/cpp/le11/le11_01.htm#delete

Dann muss sich das Tutorial aber zwischen deinem Post und meinem Lesen geändert haben. Dort steht es genauso wie von CStoll gesagt.

Und ja - das ist sicher. GCC-Executables schmieren dann schon mal gerne mit der Meldung mismatched delete ab.

Vergessen Sie diese leere eckige Klammer, so meldet Ihnen der Compiler keinen Fehler! Bei Felder von einfachen Datentypen, d.h. keine Objekte, wird der reservierte Speicher auch richtig freigegeben.

Hab' mich auf das Zitat bezogen und es geht ja immoment nur um elementare Datentypen...

Vergessen Sie diese leere eckige Klammer, so meldet Ihnen der Compiler keinen Fehler! Bei Felder von einfachen Datentypen, d.h. keine Objekte, wird der reservierte Speicher auch richtig freigegeben.

Hab' mich auf das Zitat bezogen und es geht ja immoment nur um elementare Datentypen...

... na ich lese da ganz klar eine Warnung, es nicht so zu machen. Immerhin weist er (mit Ausrufezeichen) darauf hin, dass der Compiler nicht warnt und bei primitiven Typen der Fehler evtl. nicht auffällt und nicht als Anleitung, es so zu machen.

Gruß,

Simon2.

Bei meinem ersten Post in diesem Thread ging es mir ja auch eigentlich darum, herauszustellen, dass bei dem Beispiel des Threaderstellers meiner Meinung nach kein delete[] stehen muss, sondern dass ein delete[] stehen sollte.

Allerdings bin ich mir jetzt nach dieser Diskussion irgendwie nicht mehr sicher...

Gruß,

Simon2.

Wollte folgenden Link nur noch mal hinzufügen, da hier im selben Tutorial delete[] für Objektfelder erklärt wird... http://www.cpp-tutor.de/cpp/le11/le11_02.htm#objektfelder
Und hier wird auch wieder nur auf die Destruktoraufrufe aufmerksam gemacht, nicht aber, dass delete und delete[] uterschiedlich viel speicher freigeben würden.

Wie gesagt, mir ging es ja nur darum, ob delete und delete[] für Felder von elementaren Datentypen nicht im Endeffekt das gleiche machen (sollten, wenn der Compiler Standardkonform ist)? Ich habs auf jeden Fall immer so verstanden und les' es auch aus diesem Tutorial heraus und auch noch immer aus meinem Buch.

Informatik ist aber eine Wissenschaft und da sollte man meiner Meinung nach schon mit so Wörtern wie "müssen", "dürfen" und "sollen" anders umgehen....

OK - langer Rede, kurzer Sinn: Verwendung von delete nach new[] oder von delete[] nach new ist vom Standard nicht abgedeckt => führt zu undefiniertem Verhalten - unabhängig vom Typ.

Wenn Dein Tutorial etwas anderes sagt, verstehst Du es entweder falsch oder es IST falsch (in diesem Punkt). Deine Entscheidung.

Gruß,

Simon2.

P.S.: Ich persönlich stelle ja schon die Grundaussage "für elementare Typen funktioniert das" infrage (auf allen Compilern).

Hat mich nur verwirrt, weil ich schon öfters das Beispiel (in Einführungen zu c++) gefunden habe, dass delete nach new[] aufgerufen wird, um zu zeigen, dass dann nur für ein Objekt der Destruktor aufgerufen wird. Wahrscheinlich verhalten sich viele Compiler auch so, aber nach ISO-Standard ist es undefiniert, was dann passiert.

Ich schiebe also einfach mal alle Schuld auf Tutorials die so etwas behaupten

(würde ja niemals zugeben, dass ich etwas falsch verstehe )

...
Ich schiebe also einfach mal alle Schuld auf Tutorials die so etwas behaupten ...

Da liegt es auch gut !
Es gibt soooooo viele grottige Tutorials, dass es überhaupt ein Wunder ist, dass irgendjemand vernünftig C++ programmieren kann.

Du gibst ja selbst ein Beispiel von "gut gemeint und schlecht gemacht": Da wollen Tutorials zeigen, dass delete nicht zu new[] passt ... und "belegen" das mit einem Verhalten (nur erstes Element wird gelöscht), das gar nicht definiert ist, sondern vielleicht lediglich von dem einen oder anderen Compiler zufällig so auftritt.
Ich denke, "reine Schrifttreue" fällt vielen Autoren unheimlich schwer ... sie wollen eine technische Begründung, warum etwas nicht funktioniert - leider auch da, wo sie nicht sauber geliefert werden kann.

Gruß,

Simon2.

Da liegt es auch gut !
Es gibt soooooo viele grottige Tutorials, dass es überhaupt ein Wunder ist, dass irgendjemand vernünftig C++ programmieren kann.

Da stimme ich dir auf jeden Fall zu! Allerdings halte ich das Tutorial und auch das Buch, welches ich die ganze Zeit meinte ("C++ Lernen und professionell anwenden", das auch hier im Forum öfters mal als sehr gutes Buch beschrieben wird) jetzt nicht für grottig... (auch wenn du die Beiden wahrscheinlich jetzt nicht speziell meintest, wollte ich das zumindest nochmal herausstellen)
Habe eher das Gefühl, dass dies doch ein recht häufiges Missverständnis ist...

Ich mein, zum einen schreiben sie ja auch richtig, dass für ein new[] ein delete[] aufgerufen werden muss, zum anderen widersprechen sie ihrer
Aussage, dass sie sagen, dass es ein definiertes Verhalten dafür gibt, wenn man ein "einfaches" delete aufruft.

@Simon2
Danke auf jeden Fall, dass du dir die Mühe gemacht hast, auf jeden meiner Beiträge zu antworten. Das hat mich dazu gebracht es mal offiziell nachzuschlagen, weil ich es sonst einfach nicht geglaubt hätte. (weil ich es schon so oft anders gelesen hatte)

Man kann im Leben halt doch nur dazulernen

dass es überhaupt ein Wunder ist, dass irgendjemand vernünftig C++ programmieren kann.

Das liegt an dem tollen Forum