C ++ Memóriakezelés: új és törlés

Ebben az oktatóanyagban megtanuljuk hatékonyan kezelni a memóriát a C ++ nyelven, új és törlési műveletek segítségével, példák segítségével.

A C ++ lehetővé teszi számunkra, hogy egy változó vagy egy tömb memóriáját lefuttassuk futási időben. Ez az úgynevezett dinamikus memória-allokáció.

Más programozási nyelvekben, mint például a Java és a Python, a fordító automatikusan kezeli a változókhoz rendelt memóriákat. De a C ++ esetében ez nem így van.

A C ++ - ban manuálisan kell lefoglalnunk a dinamikusan lefoglalt memóriát, miután nem használjuk a változót.

A memóriát dinamikusan lefoglalhatjuk, majd dinamikusan eloszthatjuk a newés az deleteoperátorok segítségével .

C ++ új kezelő

Az newoperátor memóriát rendel egy változóhoz. Például,

 // declare an int pointer int* pointVar; // dynamically allocate memory // using the new keyword pointVar = new int; // assign value to allocated memory *pointVar = 45;

Itt dinamikusan rendeltünk memóriát egy intváltozóhoz az newoperátor segítségével.

Figyelje meg, hogy a pointVar mutatót használtuk a memória dinamikus lefoglalására. Az newoperátor ugyanis visszaadja a memóriahely címét.

Tömb esetén az newoperátor visszaadja a tömb első elemének címét.

A fenti példából láthatjuk, hogy az newoperátor használatának szintaxisa az

 pointerVariable = new dataType;

törli az Operátort

Ha már nincs szükségünk egy dinamikusan deklarált változó használatára, akkor szét tudjuk osztani a változó által elfoglalt memóriát.

Ehhez az deleteoperátort használják. Visszaadja a memóriát az operációs rendszerhez. Ez az úgynevezett memória-elosztás .

Ennek az operátornak a szintaxisa a

 delete pointerVariable;

Vegye figyelembe a kódot:

 // 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;

Itt dinamikusan intosztottunk memóriát egy változóhoz a pointVar mutató segítségével.

A pointVar tartalmának kinyomtatása után elosztottuk a memóriát delete.

Megjegyzés : Ha a program nagy mennyiségű nem kívánt memóriát használ fel new, a rendszer összeomolhat, mert nem lesz memória az operációs rendszer számára. Ebben az esetben az deleteüzemeltető segíthet a rendszer összeomlásában.

1. példa: C ++ dinamikus memóriaallokáció

 #include 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, pointFloat; return 0; )

Kimenet

 45 45.45

Ebben a programban dinamikusan osztottunk memóriát két változóhoz intés floattípushoz. Miután hozzárendeltük hozzájuk az értékeket és kinyomtattuk őket, végül a memória kódját használjuk

 delete pointInt, pointFloat;

Megjegyzés: A dinamikus memóriakiosztás hatékonyabbá teheti a memóriakezelést.

Különösen tömbök esetében, ahol sokszor nem tudjuk a tömb méretét a futási időig.

2. példa: C ++ új és törölje az Operátort tömbökhöz

 // 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 #include using namespace std; int main() ( int num; cout <> 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 <> *(ptr + i); ) cout << "Displaying 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; )

Kimenet

Adja meg a hallgatók teljes számát: 4 Írja be a hallgatók GPA-ját. Student1: 3.6 Student2: 3.1 Student3: 3.9 Student4: 2.9 A hallgatók GPA-jának megjelenítése. Tanuló1: 3,6 Tanuló2: 3,1 Tanuló3: 3,9 Tanuló4: 2,9

Ebben a programban arra kértük a felhasználót, hogy adja meg a tanulók számát, és tárolja a num változóban.

Ezután dinamikusan lefoglaltuk a memóriát a floattömb számára az új felhasználásával.

Adatokat beírunk a tömbbe (és később kinyomtatjuk) mutató jelöléssel.

Miután már nincs szükségünk a tömbre, a kód segítségével elosztjuk a tömb memóriáját delete () ptr;.

Figyelje meg a ()after használatát delete. A szögletes zárójeleket ()arra használjuk, hogy jelezzük, hogy a memória elosztása egy tömbé.

3. példa: C ++ new és törölje az Operator for Objects alkalmazást

 #include using namespace std; class Student ( int age; public: // constructor initializes age to 12 Student() : age(12) () void getAge() ( cout << "Age = " << age

Output

 Age = 12

In this program, we have created a Student class that has a private variable age.

We have initialized age to 12 in the default constructor Student() and print its value with the function getAge().

In main(), we have created a Student object using the new operator and use the pointer ptr to point to its address.

The moment the object is created, the Student() constructor initializes age to 12.

We then call the getAge() function using the code:

 ptr->getAge();

Notice the arrow operator ->. This operator is used to access class members using pointers.

érdekes cikkek...