Werden 'neu' und 'löschen' in C ++ veraltet?

Ich bin auf ein Quiz gestoßen, das eine Array-Deklaration mit unterschiedlichen Größen beinhaltete. Das erste, was mir in den Sinn kam, war, dass ich mit dem newBefehl eine dynamische Zuordnung verwenden müsste , wie folgt :

while(T--) {
   int N;
   cin >> N;
   int *array = new int[N];
   // Do something with 'array'
   delete[] array;
}

Ich habe jedoch gesehen, dass eine der Lösungen den folgenden Fall zulässt:

while(T--) {
    int N;
    cin >> N;
    int array[N];
    // Do something with 'array'
}

Nach ein wenig Recherche habe ich gelesen, dass g ++ dies zulässt, aber ich habe immer wieder darüber nachgedacht, in welchen Fällen ist es dann notwendig, die dynamische Zuordnung zu verwenden? Oder übersetzt der Compiler dies als dynamische Zuordnung?

Die Löschfunktion ist enthalten. Beachten Sie jedoch, dass es hier nicht um Speicherlecks geht.

Keines der gezeigten Snippets ist idiomatischer, moderner C ++ - Code.

newund delete(und new[]und delete[]) sind in C ++ nicht veraltet und werden es niemals sein. Sie sind immer noch die Möglichkeit, dynamisch zugewiesene Objekte zu instanziieren. Da Sie jedoch immer a newmit a delete(und a new[]mit a delete[]) abgleichen müssen, werden sie am besten in (Bibliotheks-) Klassen aufbewahrt, die dies für Sie sicherstellen. Siehe Warum sollten C ++ - Programmierer die Verwendung von "neu" minimieren? .

Ihr erstes Snippet verwendet ein "nacktes" new[]und dann nie delete[]das erstellte Array. Das ist ein Problem. std::vectormacht alles was du brauchst hier ganz gut. Es wird eine Form von newhinter den Kulissen verwendet (ich werde nicht auf Implementierungsdetails eingehen), aber alles, was Sie beachten müssen, ist ein dynamisches Array, aber besser und sicherer.

Ihr zweites Snippet verwendet "Arrays mit variabler Länge" (VLAs), eine C-Funktion, die einige Compiler auch in C ++ als Erweiterung zulassen. Im Gegensatz dazu newwerden VLAs im Wesentlichen auf dem Stapel zugewiesen (eine sehr begrenzte Ressource). Noch wichtiger ist jedoch, dass sie keine Standard-C ++ - Funktion sind und vermieden werden sollten, da sie nicht portierbar sind. Sie ersetzen sicherlich nicht die dynamische (dh Heap-) Zuordnung.

Nun, für Vorspeisen, new/ deletesind nicht veraltet zu werden .

In Ihrem speziellen Fall sind sie jedoch nicht die einzige Lösung. Was Sie auswählen, hängt davon ab, was unter Ihrem Kommentar "Mach etwas mit Array" versteckt wurde.

In Ihrem zweiten Beispiel wird eine nicht standardmäßige VLA-Erweiterung verwendet, die versucht, das Array auf den Stapel zu passen. Dies hat bestimmte Einschränkungen - nämlich eine begrenzte Größe und die Unfähigkeit, diesen Speicher zu verwenden, nachdem das Array den Gültigkeitsbereich verlassen hat. Sie können es nicht herausziehen, es wird "verschwinden", nachdem sich der Stapel abgewickelt hat.

Wenn Ihr einziges Ziel darin besteht, eine lokale Berechnung durchzuführen und die Daten dann wegzuwerfen, funktioniert dies möglicherweise tatsächlich einwandfrei. Ein robusterer Ansatz wäre jedoch, den Speicher dynamisch zuzuweisen, vorzugsweise mit std::vector. Auf diese Weise erhalten Sie die Möglichkeit, Platz für genau so viele Elemente zu schaffen, wie Sie benötigen, basierend auf einem Laufzeitwert (was wir die ganze Zeit anstreben), aber es wird sich auch gut bereinigen und Sie können ihn verschieben dieses Bereichs, wenn Sie den Speicher für später verwenden möchten.

Wenn Sie zum Anfang zurückkehren, vector werden Sie wahrscheinlich newein paar Schichten tiefer gehen, aber Sie sollten sich damit nicht befassen, da die Benutzeroberfläche viel besser ist. In diesem Sinne kann die Verwendung von newund deleteals entmutigt angesehen werden.

In Ihrem zweiten Beispiel werden Arrays mit variabler Länge (VLAs) verwendet, die eigentlich eine C99-Funktion ( nicht C ++!) Sind, aber dennoch von g ++ unterstützt werden .

Siehe auch diese Antwort .

Beachten Sie, dass Arrays mit variabler Länge sich von new/ unterscheiden deleteund diese in keiner Weise "verwerfen".

Beachten Sie auch, dass VLAs nicht ISO C ++ sind.

Modernes C ++ bietet einfachere Möglichkeiten, mit dynamischen Zuordnungen zu arbeiten. Intelligente Zeiger können sich um die Bereinigung nach Ausnahmen (die bei Bedarf überall auftreten können) und vorzeitigen Rückgaben kümmern, sobald die referenzierten Datenstrukturen den Gültigkeitsbereich verlassen. Daher kann es sinnvoll sein, diese stattdessen zu verwenden:

  int size=100;

  // This construct requires the matching delete statement.
  auto buffer_old = new int[size];

  // These versions do not require `delete`:
  std::unique_ptr<int[]> buffer_new (new int[size]);
  std::shared_ptr<int[]> buffer_new (new int[size]); 
  std::vector<int> buffer_new (size);  int* raw_access = buffer_new.data();

Ab C ++ 14 können Sie auch schreiben

auto buffer_new = std::make_unique<int[]>(size);

Dies sieht noch besser aus und würde einen Speicherverlust verhindern, wenn die Zuordnung fehlschlägt. Ab C ++ 20 sollten Sie in der Lage sein, so viel wie möglich zu tun

auto a = std::make_shared<int[]>(size);

Dies wird für mich zum Zeitpunkt des Schreibens mit gcc 7.4.0 noch nicht kompiliert. In diesen beiden Beispielen verwenden wir auch autoanstelle der Typdeklaration links. Verwenden Sie in allen Fällen das Array wie gewohnt:

buffer_old[0] = buffer_new[0] = 17;

Speicherlecks newund Abstürze durch Verdoppelung deletesind etwas, das C ++ seit vielen Jahren verprügelt hat und der "zentrale Punkt" der Argumentation für den Wechsel in andere Sprachen ist. Vielleicht besser zu vermeiden.

Neu und Löschen werden nicht veraltet.

Die vom neuen Operator erstellten Objekte können als Referenz übergeben werden. Die Objekte können mit delete gelöscht werden.

Neu und Löschen sind die grundlegenden Aspekte der Sprache. Die Persistenz eines Objekts kann mit new und delete verwaltet werden. Diese werden definitiv nicht veraltet sein.

Die Anweisung - int array [N] ist eine Möglichkeit, ein Array zu definieren. Das Array kann im Rahmen des umschließenden Codeblocks verwendet werden. Es kann nicht so übergeben werden, wie ein Objekt an eine andere Funktion übergeben wird.

Das erste Beispiel benötigt delete[]am Ende ein, sonst tritt ein Speicherverlust auf.

Im zweiten Beispiel wird eine variable Arraylänge verwendet, die von C ++ nicht unterstützt wird. Es erlaubt nur einen konstanten Ausdruck für die Array-Länge .

In diesem Fall ist es nützlich, std::vector<>als Lösung zu verwenden; Dadurch werden alle Aktionen, die Sie für ein Array ausführen können, in eine Vorlagenklasse zusammengefasst.

Die Syntax sieht aus wie C ++, aber die Redewendung ähnelt der einfachen alten Algol60. Es war üblich, Codeblöcke wie diesen zu haben:

read n;
begin
    integer array x[1:n];
    ... 
end;

Das Beispiel könnte wie folgt geschrieben werden:

while(T--) {
    int N;
    cin >> N;
    {
        int array[N];
        // Do something with 'array'
    }
}

Ich vermisse das manchmal in den aktuellen Sprachen;)