C++-Speicherverwaltung:neu und löschen

C++-Speicherverwaltung:neu und löschen

In diesem Tutorial lernen wir anhand von Beispielen, Speicher in C++ mithilfe von new- und delete-Operationen effektiv zu verwalten.

C++ ermöglicht es uns, den Speicher einer Variablen oder eines Arrays zur Laufzeit zuzuweisen. Dies wird als dynamische Speicherzuweisung bezeichnet.

In anderen Programmiersprachen wie Java und Python verwaltet der Compiler automatisch die den Variablen zugewiesenen Speicher. Aber das ist in C++ nicht der Fall.

In C++ müssen wir den dynamisch zugewiesenen Speicher manuell freigeben, nachdem wir die Variable nicht mehr brauchen.

Mit new können wir Speicher dynamisch zuweisen und dann freigeben und delete Operatoren.

---

Neuer C++-Operator

Die new Der Operator weist einer Variablen Speicher zu. Zum Beispiel

// declare an int pointer
int* pointVar;

// dynamically allocate memory
// using the new keyword 
pointVar = new int;

// assign value to allocated memory
*pointVar = 45;

Hier haben wir Speicher für int dynamisch zugewiesen Variable mit new Betreiber.

Beachten Sie, dass wir den Zeiger pointVar verwendet haben um den Speicher dynamisch zuzuweisen. Das liegt daran, dass new Operator gibt die Adresse des Speicherplatzes zurück.

Im Fall eines Arrays der new Operator gibt die Adresse des ersten Elements des Arrays zurück.

Aus dem obigen Beispiel können wir sehen, dass die Syntax für die Verwendung von new Betreiber ist

pointerVariable = new dataType;

---

Operator löschen

Sobald wir eine Variable, die wir dynamisch deklariert haben, nicht mehr benötigen, können wir den von der Variablen belegten Speicher freigeben.

Dazu die delete Betreiber verwendet wird. Es gibt den Speicher an das Betriebssystem zurück. Dies wird als Speicherfreigabe bezeichnet .

Die Syntax für diesen Operator ist

delete pointerVariable;

Betrachten Sie den Code:

// declare an int pointer
int* pointVar;

// dynamically allocate memory
// for an int variable 
pointVar = new int;

// assign value to the variable memory
*pointVar = 45;

// print the value stored in memory
cout << *pointVar; // Output: 45

// deallocate the memory
delete pointVar;

Hier haben wir Speicher für int dynamisch zugewiesen Variable mit dem Zeiger pointVar .

Nach dem Drucken des Inhalts von pointVar , haben wir den Speicher mit delete freigegeben .

Hinweis :Wenn das Programm mit new eine große Menge an unerwünschtem Speicher verwendet , kann das System abstürzen, da für das Betriebssystem kein Speicher verfügbar ist. In diesem Fall die delete Bediener kann dem System vor einem Absturz helfen.

---

Beispiel 1:Dynamische C++-Speicherzuweisung

#include <iostream>
using namespace std;

int main() {
    // declare an int pointer
    int* pointInt;

    // declare a float pointer
    float* pointFloat;

    // dynamically allocate memory
    pointInt = new int;
    pointFloat = new float;

    // assigning value to the memory
    *pointInt = 45;
    *pointFloat = 45.45f;

    cout << *pointInt << endl;
    cout << *pointFloat << endl;

    // deallocate the memory
    delete pointInt;
    delete pointFloat;

    return 0;
}

Ausgabe

45
45.45

In diesem Programm haben wir zwei Variablen von int Speicher dynamisch zugewiesen und float Typen. Nachdem wir ihnen Werte zugewiesen und sie gedruckt haben, geben wir schließlich die Speicher mit dem Code

frei

delete pointInt;
delete pointFloat;

Hinweis: Die dynamische Speicherzuweisung kann die Speicherverwaltung effizienter machen.

Besonders für Arrays, bei denen wir die Größe des Arrays oft erst zur Laufzeit kennen.

---

Beispiel 2:C++ new- und delete-Operator für Arrays

// C++ Program to store GPA of n number of students and display it
// where n is the number of students entered by the user

#include <iostream>
using namespace std;

int main() {
    int num;
    cout << "Enter total number of students: ";
    cin >> num;
    float* ptr;
    
    // memory allocation of num number of floats
    ptr = new float[num];

    cout << "Enter GPA of students." << endl;
    for (int i = 0; i < num; ++i) {
        cout << "Student" << i + 1 << ": ";
        cin >> *(ptr + i);
    }

    cout << "\nDisplaying GPA of students." << endl;
    for (int i = 0; i < num; ++i) {
        cout << "Student" << i + 1 << " :" << *(ptr + i) << endl;
    }

    // ptr memory is released
    delete[] ptr;

    return 0;
}

Ausgabe

Enter total number of students: 4
Enter GPA of students.
Student1: 3.6
Student2: 3.1
Student3: 3.9
Student4: 2.9

Displaying GPA of students.
Student1 :3.6
Student2 :3.1
Student3 :3.9
Student4 :2.9

In diesem Programm haben wir den Benutzer gebeten, die Anzahl der Schüler einzugeben und in num zu speichern Variable.

Dann haben wir den Speicher für float dynamisch zugewiesen Array mit new .

Wir geben Daten in das Array ein (und geben sie später aus), indem wir die Zeigernotation verwenden.

Nachdem wir das Array nicht mehr benötigen, geben wir den Arrayspeicher mit dem Code delete[] ptr; frei .

Beachten Sie die Verwendung von [] nach delete . Wir verwenden die eckigen Klammern [] um anzuzeigen, dass die Speicherfreigabe die eines Arrays ist.

---

Beispiel 3:C++ new- und delete-Operator für Objekte

#include <iostream>
using namespace std;

class Student {
    int age;

   public:

    // constructor initializes age to 12
    Student() : age(12) {}

    void getAge() {
        cout << "Age = " << age << endl;
    }
};

int main() {

    // dynamically declare Student object
    Student* ptr = new Student();

    // call getAge() function
    ptr->getAge();

    // ptr memory is released
    delete ptr;

    return 0;
}

Ausgabe

Age = 12

In diesem Programm haben wir einen Student erstellt Klasse, die eine private Variable age hat .

Wir haben age initialisiert bis 12 im Standardkonstruktor Student() und drucke seinen Wert mit der Funktion getAge() .

In main() haben wir einen Student erstellt Objekt mit dem new -Operator und verwenden Sie den Zeiger ptr auf seine Adresse zeigen.

In dem Moment, in dem das Objekt erstellt wird, wird der Student() Konstruktor initialisiert age bis 12 .

Wir rufen dann die getAge() an Funktion mit dem Code:

ptr->getAge();

Beachten Sie den Pfeiloperator -> . Dieser Operator wird verwendet, um mit Zeigern auf Klassenmitglieder zuzugreifen.