Gestión de memoria C++:nuevo y eliminar

Gestión de memoria C++:nueva y eliminación

En este tutorial, aprenderemos a administrar la memoria de manera efectiva en C++ utilizando operaciones de nueva y eliminación con la ayuda de ejemplos.

C++ nos permite asignar la memoria de una variable o una matriz en tiempo de ejecución. Esto se conoce como asignación de memoria dinámica.

En otros lenguajes de programación como Java y Python, el compilador administra automáticamente las memorias asignadas a las variables. Pero este no es el caso en C++.

En C++, necesitamos desasignar la memoria asignada dinámicamente manualmente después de que no tengamos uso para la variable.

Podemos asignar y luego desasignar memoria dinámicamente usando el new y delete operadores respectivamente.

---

Nuevo operador C++

El new El operador asigna memoria a una variable. Por ejemplo,

// declare an int pointer
int* pointVar;

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

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

Aquí, tenemos memoria asignada dinámicamente para un int variable usando el new operador.

Observe que hemos utilizado el puntero pointVar para asignar la memoria dinámicamente. Esto se debe a que el new operador devuelve la dirección de la ubicación de la memoria.

En el caso de una matriz, el new operador devuelve la dirección del primer elemento de la matriz.

Del ejemplo anterior, podemos ver que la sintaxis para usar new el operador es

pointerVariable = new dataType;

---

eliminar Operador

Una vez que ya no necesitemos usar una variable que hemos declarado dinámicamente, podemos desasignar la memoria ocupada por la variable.

Para ello, el delete se utiliza el operador. Devuelve la memoria al sistema operativo. Esto se conoce como desasignación de memoria. .

La sintaxis de este operador es

delete pointerVariable;

Considere el código:

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

Aquí, tenemos memoria asignada dinámicamente para un int variable usando el puntero pointVar .

Después de imprimir el contenido de pointVar , desasignamos la memoria usando delete .

Nota :si el programa usa una gran cantidad de memoria no deseada usando new , el sistema puede bloquearse porque no habrá memoria disponible para el sistema operativo. En este caso, el delete el operador puede ayudar a que el sistema no se bloquee.

---

Ejemplo 1:asignación de memoria dinámica de C++

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

Salida

45
45.45

En este programa, asignamos memoria dinámicamente a dos variables de int y float tipos Después de asignarles valores e imprimirlos, finalmente desasignamos las memorias usando el código

delete pointInt;
delete pointFloat;

Nota: La asignación de memoria dinámica puede hacer que la gestión de la memoria sea más eficiente.

Especialmente para arreglos, donde muchas veces no sabemos el tamaño del arreglo hasta el tiempo de ejecución.

---

Ejemplo 2:C++ operador nuevo y eliminado para arreglos

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

Salida

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

En este programa, le hemos pedido al usuario que ingrese el número de estudiantes y lo almacene en el num variables.

Luego, hemos asignado la memoria dinámicamente para el float matriz usando nuevo .

Ingresamos datos en la matriz (y luego los imprimimos) usando notación de puntero.

Después de que ya no necesitemos la matriz, desasignamos la memoria de la matriz usando el código delete[] ptr; .

Observe el uso de [] después de delete . Usamos los corchetes [] para indicar que la desasignación de memoria es la de una matriz.

---

Ejemplo 3:C++ Operador nuevo y eliminado para objetos

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

Salida

Age = 12

En este programa, hemos creado un Student clase que tiene una variable privada edad .

Hemos inicializado edad a 12 en el constructor predeterminado Student() e imprime su valor con la función getAge() .

En main() , hemos creado un Student objeto usando el new operador y use el puntero ptr para apuntar a su dirección.

En el momento en que se crea el objeto, el Student() el constructor inicializa edad a 12 .

Entonces llamamos al getAge() función usando el código:

ptr->getAge();

Observe el operador de flecha -> . Este operador se utiliza para acceder a los miembros de la clase mediante punteros.