C ++ mäluhaldus: uus ja kustutatud

Selles õpetuses õpime C ++ -s tõhusalt mälu haldama, kasutades näiteid kasutades uusi ja kustutavaid toiminguid.

C ++ võimaldab meil eraldada muutuja või massiivi mälu tööajal. Seda nimetatakse dünaamiliseks mälu eraldamiseks.

Teistes programmeerimiskeeltes, nagu Java ja Python, haldab kompilaator muutujatele eraldatud mälusid automaatselt. Kuid see ei kehti C ++ puhul.

C ++ puhul peame dünaamiliselt eraldatud mälu käsitsi lahendama, kui meil pole muutujat kasutada.

Me ei saa eraldada ja siis deallocate mälu abil dünaamiliselt newja deleteettevõtjate kaupa.

C ++ uus operaator

newOperaator eraldab mälu muutuja. Näiteks,

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

Siin oleme operaatori intabil muutuja jaoks dünaamiliselt mälu eraldanud new.

Pange tähele, et me kasutasime mälu dünaamiliseks jaotamiseks pointer pointVar. Seda seetõttu, et newoperaator tagastab mälu asukoha aadressi.

Massiivi korral newtagastab operaator massiivi esimese elemendi aadressi.

Ülaltoodud näite põhjal näeme, et newoperaatori kasutamise süntaks on

 pointerVariable = new dataType;

Kustuta Operaator

Kui me ei pea enam dünaamiliselt deklareeritud muutujat kasutama, saame muutujaga hõivatud mälu jaotada.

Selleks kasutatakse deleteoperaatorit. See tagastab operatsioonisüsteemi mälu. Seda tuntakse kui mälu jagamist .

Selle operaatori süntaks on

 delete pointerVariable;

Mõelge koodile:

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

Siin oleme intmuutuja jaoks dünaamiliselt eraldanud mälu, kasutades pointer pointVar.

Pärast pointVari sisu printimist jagasime mälu kasutades delete.

Märkus . Kui programm kasutab suures koguses soovimatut mälu new, võib süsteem kokku kukkuda, kuna opsüsteemi jaoks pole vaba mälu. Sellisel juhul saab deleteoperaator aidata süsteemi krahhi.

Näide 1: C ++ dünaamilise mälu jaotamine

 #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; )

Väljund

 45 45.45

Selles programmis eraldasime dünaamiliselt mälu kahele muutujale intja floattüübile. Pärast neile väärtuste määramist ja nende printimist jagame mälud lõpuks koodi abil

 delete pointInt, pointFloat;

Märkus. Dünaamiline mälu eraldamine võib muuta mäluhalduse tõhusamaks.

Eriti massiivide puhul, kus me ei tea paljudel juhtudel massiivi suurust enne tööaega.

Näide 2: C ++ uus ja kustutage massiivide operaator

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

Väljund

Sisestage õpilaste koguarv: 4 Sisestage õpilaste GPA. Õpilane1: 3,6 Õpilane2: 3,1 Õpilane3: 3,9 Õpilane4: 2,9 Üliõpilaste GPA kuvamine. Õpilane1: 3,6 Õpilane2: 3,1 Õpilane3: 3,9 Õpilane4: 2,9

Selles programmis oleme palunud kasutajal sisestada õpilaste arv ja salvestada see muutujasse num.

Seejärel eraldasime floatmassiivi jaoks dünaamiliselt mälu, kasutades uut.

Andmed sisestame massiivi (ja hiljem printime), kasutades kursori märke.

Pärast seda, kui massiivi pole enam vaja, jaotame massiivi mälu koodi abil delete () ptr;.

Pange tähele ()pärast delete. Kasutame nurksulgudes ()tähistamaks, et mälu jagamine on massiivi oma.

Näide 3: C ++ uus ja kustutage objektide operaator

 #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.

Huvitavad Artiklid...