Ist es notwendig, Elemente als Array schrumpft zu löschen?

Question

Ich bin ein Student, ein Verfahren, dass Nullen entfernt von dem Ende eines Arrays von Ints, in C ++ zu schreiben. Das Array ist in einer Struktur, und die Struktur hat auch einen int, die den Überblick über die Länge des Arrays hält.

Das Verfahren untersucht jedes Element aus dem letzten Start, bis es den ersten Nicht-Null-Element trifft, und die Markierungen, daß man als die „letzte Element“, indem der Wert der Länge ändert. Dann wird das Verfahren geht zurück bis zum ursprünglichen „letzten Elemente“, die Elemente zu löschen, die nicht außerhalb der Grenzen (die Nullstellen).

Der Teil, der das ith Element im Array löscht, wenn i größer ist als die aktualisierte Länge des Arrays ist, sieht wie folgt aus:

if (i > p->length - 1) {
  delete (p->elems + i); // free ith elem

Diese Zeile ist falsch, though. Löschen nimmt einen Zeiger, nicht wahr? Also mein Gefühl ist, dass ich den Zeiger auf das Array zu erholen, und dann i, um es hinzuzufügen, so dass ich den Speicherplatz der ganzen Zahl haben werde ich löschen möchten.

Ist meine Intuition falsch? Ist der Fehler subtil? Oder habe ich die völlig falsche Idee? Ich habe zu Wunder begonnen: brauche ich wirklich diese Primitiven zu befreien? Wenn sie nicht Primitive wären, würde ich brauchen, und in diesem Fall, wie sollte ich?

Answer 1

Wenn p->elems ein Zeiger ist, so ist p->elems + i (vorausgesetzt, dass die Operation definiert ist, d i der Integral-Typ ist) - und p->elems + i == &p->elems[i]

Wie auch immer, werden Sie wahrscheinlich nicht wollen (und können) löschen Ints aus einem Array von int (sei es dynamisch oder automatisch zugewiesen). Das heißt

int* ptr = new int[10];
delete &ptr[5]; // WRONG!

Das ist einfach etwas, das Sie nicht tun können. Wenn jedoch die Struktur der Länge des Arrays enthält, können Sie das Array betrachten „verkleinerte“, nachdem Sie die Längeninformation von der Struktur enthaltenen ändern - schließlich gibt es keine Möglichkeit, die Größe des Arrays einen Zeiger zu erzählen.

Wenn aber Ihr Array ist ein Array von Zeigern auf ganze Zahlen (int*[]) und diese Zeiger verweisen auf dynamisch zugewiesenen Speicher, dann ja, können Sie einzelne Elemente löschen könnte, und Sie würden es entlang der Linien des Codes tun (Sie sind so wenig Code zeigt, ist es schwierig, genau zu sein).

Answer 2

habe ich die völlig falsche Idee?

Ich fürchte, so.

Wenn Sie einen new[] Anruf ein Array zuweisen, dann müssen Sie einen delete[] Anruf machen es zu befreien:

int *p = new int[10];
...
delete[] p;

Wenn Ihr Array in einer Struktur ist, und Sie machen einen Aufruf an die Struktur zuweisen, dann müssen Sie einen Anruf machen es zu befreien:

struct Foo {
    int data[10];
};

Foo *foo = new Foo;
...
delete foo;

Es gibt keine Möglichkeit zum freien Teil eines Arrays.

Ein int[10] Array tatsächlich ist 10 ganze Zahlen sind, in einer Reihe (dh 40 Bytes des Speichers auf einem 32-Bit-System, möglicherweise zuzüglich Overhead). Die ganze Zahl Werte , die in dem Array gespeichert sind, belegen, dass der Speicher - sie sind nicht selbst Speicherzuordnungen, und sie nicht befreit werden müssen

.

Alles, was gesagt, wenn Sie möchten, eine variable Länge Array:

das ist, was std :: vector ist für

#include <vector>
#include <iostream>

struct Foo {
    std::vector<int> vec;
};

int main() {
    Foo foo;

    // no need for a separate length: the current length of the vector is
    std::cout << foo.vec.size() << "\n";

    // change the size of the vector to 10 (fills with 0)
    foo.vec.resize(10);

    // change the size of the vector to 7, discarding the last 3 elements
    foo.vec.resize(7);
}