C++-Speicherverwaltungsbibliothek<new>

C++ ist eine leistungsstarke Programmiersprache, die eine umfangreiche Standardbibliothek bietet, um Entwicklern zu helfen, Code effizienter zu schreiben.

In C++,<new>Es ist eine sehr wichtige Header-Datei, die Funktionen und Ausnahmetypen für die dynamische Speicherzuweisung enthält.

Die dynamische Speicherzuweisung ermöglicht es Programmen, zur Laufzeit Speicher anzufordern, was bei der Arbeit mit Datenstrukturen unbekannter Größe sehr nützlich ist.

<new>Die Header-Datei definiert die folgenden Schlüsselkomponenten:

  • newOperator: Wird für die dynamische Speicherzuweisung verwendet.
  • deleteOperator: Wird zum Freigeben von dynamisch zugewiesenem Speicher verwendet.
  • nothrowOperator: Wird verwendet, um keine Ausnahme auszulösen, wenn die Speicherzuweisung fehlschlägt.
  • std::bad_allocAusnahme: wird ausgelöst, wenn die Speicherzuweisung fehlschlägt.

Syntax

NutzungnewOperatoren

newOperator, der verwendet wird, um Speicher auf dem Heap zuzuweisen. Seine grundlegende Syntax lautet wie folgt:

<code class="language-cpp">pointer new (type [, initializer]);</code>
  • pointerist ein Zeiger auf den zugewiesenen Speicher.
  • typeist der Typ des Objekts, das zugewiesen werden soll.
  • initializerist ein optionaler Initialisierungsausdruck.

NutzungdeleteOperatoren

deleteOperator wird verwendet, um zuvornewzugewiesenen Speicher freizugeben. Seine grundlegende Syntax lautet wie folgt:

<code class="language-cpp">delete pointer;</code>
  • pointerwird zuvor verwendetnewZeiger auf den zugewiesenen Speicher.

Beispiel

Dynamisches Zuweisen eines einzelnen Objekts:

Beispiel

#include <iostream>
#include <new> // die Header-Datei <new> einbinden

class MyClass {
public:
    int value;
    MyClass() : value(0) {}
};

int main() {
    MyClass* myObject = new MyClass; // Ein MyClass-Objekt allokieren
    myObject->value = 10; // Den Punktoperator verwenden, um auf Member zuzugreifen
    std::cout << "Wert: " << myObject->value << std::endl;

    delete myObject; // Speicher freigeben
    return 0;
}

Ausgabeergebnis:

Value: 10

Dynamisch allokiertes Array:

Beispiel

#include <iostream>
#include <new>

int main() {
    int* myArray = new int[10]; // Ein Array aus 10 Ganzzahlen allokieren
    for (int i = 0; i < 10; ++i) {
        myArray[i] = i * 2; // Das Array initialisieren
    }

    for (int i = 0; i < 10; ++i) {
        std::cout << "Array[" << i << "]: " << myArray[i] << std::endl;
    }

    delete[] myArray; // Den Array-Speicher freigeben
    return 0;
}

Ausgabeergebnis:

Array[0]: 0
Array[1]: 2
Array[2]: 4
Array[3]: 6
Array[4]: 8
Array[5]: 10
Array[6]: 12
Array[7]: 14
Array[8]: 16
Array[9]: 18

nothrow verwenden, um Ausnahmen zu vermeiden:

Beispiel

#include <iostream>
#include <new>

int main() {
    int* myArray = new(std::nothrow) int[10000000]; // Versuch, ein großes Array zuzuweisen
    if (!myArray) {
        std::cout << "Speicherzuweisung fehlgeschlagen." << std::endl;
    } else {
        std::cout << "Speicherzuweisung erfolgreich." << std::endl;
        delete[] myArray; // Speicher freigeben
    }
    return 0;
}

Ausgabeergebnis:

Memory allocation failed. // 或者 Memory allocation succeeded. 取决于系统内存情况

Ausnahmebehandlung

Wenn die Speicherzuweisung mit dem new-Operator fehlschlägt, wirft C++ eine std::bad_alloc-Ausnahme.

Entwickler können diese Ausnahme mit einem try-catch-Block abfangen und behandeln.

Beispiel

#include <iostream>
#include <new>

int main() {
    try {
        int* myArray = new int[10000000]; // Versuch, ein großes Array zuzuweisen
        std::cout << "Speicherzuweisung erfolgreich." << std::endl;
        delete[] myArray; // Speicher freigeben
    } catch (const std::bad_alloc& e) {
        std::cout << "Ausnahme abgefangen: " << e.what() << std::endl;
    }
    return 0;
}

Ausgabeergebnis:

Exception caught: std::bad_alloc // 如果内存分配失败
Weitere Erweiterungen