Gestione della memoria in C++ (new e delete)

In questo articolo, imparerai a gestire efficacemente la memoria in C++ utilizzando le operazioni new e delete.

ArrayPuò essere utilizzato per memorizzare più dati dello stesso tipo, ma esistono gravi difetti nell'uso degli array.

La memoria deve essere allocata quando si dichiara l'array, ma nella maggior parte dei casi, la memoria necessaria esatta può essere determinata solo durante l'esecuzione.

In questo caso, il miglior approccio è dichiarare un array con la massima memoria necessaria possibile (dichiarare un array con la dimensione massima possibile)

Il lato negativo è che la memoria non utilizzata viene sprecata e non può essere utilizzata da altri programmi.

Per evitare lo spreco di memoria, puoi utilizzare gli operatori new e delete in C++ per allocare dinamicamente la memoria necessaria durante l'esecuzione.

Esempio 1: Gestione della memoria in C++

Il programma C++ memorizza i punteggi degli studenti e li visualizza, dove n è il numero di studenti inserito dall'utente.

#include <iostream>
#include <cstring>
using namespace std;
int main()
{
　　　　int num;
　　　　cout << "输入学生总数: ";
　　　　cin >> num;
　　　　float* ptr;
　　　　
　　　　// Numeri float allocati in memoria
　　　　ptr = new float[num];
　　　　cout << "输入学生的成绩。" << endl;
　　　　for (int i = 0; i < num; ++i)
　　　　{
　　　　　　　　cout << "学生" << i + 1 << " \:\: ";
　　　　　　　　cin >> *(ptr + i);
　　　　}
　　　　cout << "\n显示学生的成绩。" << endl;
　　　　for (int i = 0; i < num; ++i) {
　　　　　　　　cout << "学生" << i + 1 << " \:\: " << *(ptr + i) << endl;
　　　　}
　　　　// ptr memoria liberata
　　　　delete [] ptr;
　　　　return 0;
}

Risultato dell'output

Inserisci il numero totale di studenti: 5
Inserisci i punteggi degli studenti.
Studente 1: 295
Studente 2: 485
Studente 3: 650
Studente 4: 700
Studente 5: 540
Visualizza i punteggi degli studenti.
Studente 1:295
Studente 2:485
Studente 3:650
Studente 4:700
Studente 5:540

In questo programma, viene dichiarata dinamicamente solo la memoria necessaria per archiviare num numeri float (inseriti dall'utente).

Operatore new

ptr = new float[num];

L'espressione nel programma precedente restituisce un puntatore a una parte della memoriaPuntatoreche è sufficiente per contenere num dati di tipo float.

Operatore delete

Dopo aver allocato memoria con l'operatore new, deve essere liberata al sistema operativo.

Se il programma utilizza new per allocare una grande quantità di memoria, il sistema potrebbe bloccarsi perché l'operating system non ha più memoria disponibile, causando un'esaurimento della memoria.

L'espressione seguente restituisce la memoria liberata al sistema operativo.

delete [] ptr;

Le parentesi quadrate [] indicano che l'array è stato eliminato. Se si desidera eliminare un singolo oggetto, non è necessario utilizzare le parentesi quadrate. Ad esempio:

delete ptr;

Esempio 2: Gestione della memoria in C++

In C++Gestione del programma menzionato con un approccio orientato agli oggetti.

#include <iostream>
using namespace std;
class Test
{
private:
　　　　int num;
　　　　float *ptr;
public:
　　　　Test();
　　　　{
　　　　　　　　cout << "输入学生总数: ";
　　　　　　　　cin >> num;
　　　　　　　　
　　　　　　　　ptr = new float[num];
　　　　　　　　
　　　　　　　　cout << "输入学生的成绩。" << endl;
　　　　　　　　for (int i = 0; i < num; ++i)
　　　　　　　　{
　　　　　　　　　　　　cout << "学生" << i + 1 << " \:\: ";
　　　　　　　　　　　　cin >> *(ptr + i);
　　　　　　　　}
　　　　}
　　　　
　　　　~Test() {
　　　　　　　　delete[] ptr;
　　　　}
　　　　void Display() {
　　　　　　　　cout << "\n显示学生的成绩。" << endl;
　　　　　　　　for (int i = 0; i < num; ++i) {
　　　　　　　　　　　　cout << "学生" << i+1 << " \:\: " << *(ptr + i) << endl;
　　　　　　　　}
　　　　}
　　　　
};
int main() {
　　　　Test s;
　　　　s.Display();
　　　　return 0;
}

L'output del programma è lo stesso dell'output del programma sopra.

Quando si crea l'oggetto s, viene chiamato il costruttore, che assegna memoria per num dati floating point.

Il costruttore viene chiamato quando l'oggetto viene distrutto, ovvero quando l'oggetto esce dal campo di visibilità.

　　　　~Test() {
　　　　　　　　delete[] ptr;
　　　　}

Questo distruttore esegue delete[] ptr; e restituisce la memoria al sistema operativo.