Gerenciamento de memória C++:novo e excluir

Gerenciamento de memória C++:novo e excluir

Neste tutorial, aprenderemos a gerenciar memória de forma eficaz em C++ usando operações new e delete com a ajuda de exemplos.

C++ nos permite alocar a memória de uma variável ou array em tempo de execução. Isso é conhecido como alocação dinâmica de memória.

Em outras linguagens de programação, como Java e Python, o compilador gerencia automaticamente as memórias alocadas às variáveis. Mas este não é o caso em C++.

Em C++, precisamos desalocar a memória alocada dinamicamente manualmente após não termos uso para a variável.

Podemos alocar e desalocar memória dinamicamente usando o new e delete operadores respectivamente.

---

Novo Operador C++

O new operador aloca memória para uma variável. Por exemplo,

// declare an int pointer
int* pointVar;

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

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

Aqui, alocamos memória dinamicamente para um int variável usando o new operador.

Observe que usamos o ponteiro pointVar alocar a memória dinamicamente. Isso ocorre porque o new operador retorna o endereço do local de memória.

No caso de um array, o new O operador retorna o endereço do primeiro elemento da matriz.

A partir do exemplo acima, podemos ver que a sintaxe para usar o new operador é

pointerVariable = new dataType;

---

excluir operador

Uma vez que não precisamos mais usar uma variável que declaramos dinamicamente, podemos desalocar a memória ocupada pela variável.

Para isso, o delete operador é usado. Ele retorna a memória para o sistema operacional. Isso é conhecido como desalocação de memória .

A sintaxe para este operador é

delete pointerVariable;

Considere o 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;

Aqui, temos memória alocada dinamicamente para um int variável usando o ponteiro pointVar .



Após imprimir o conteúdo de pointVar , desalocamos a memória usando delete .

Observação :Se o programa usar uma grande quantidade de memória indesejada usando new , o sistema poderá travar porque não haverá memória disponível para o sistema operacional. Nesse caso, o delete operador pode ajudar o sistema de falha.

---

Exemplo 1:alocação de memória dinâmica 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;
}

Saída

45
45.45

Neste programa, alocamos memória dinamicamente para duas variáveis ​​de int e float tipos. Depois de atribuir valores a eles e imprimi-los, finalmente desalocamos as memórias usando o código

delete pointInt;
delete pointFloat;

Observação: A alocação dinâmica de memória pode tornar o gerenciamento de memória mais eficiente.

Especialmente para arrays, onde muitas vezes não sabemos o tamanho do array até o tempo de execução.

---

Exemplo 2:C++ new and delete Operator for 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;
}

Saída

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

Neste programa, solicitamos que o usuário insira o número de alunos e armazene-o no campo num variável.

Então, alocamos a memória dinamicamente para o float array usando novo .

Nós inserimos os dados no array (e depois os imprimimos) usando a notação de ponteiro.

Após não precisarmos mais do array, desalocamos a memória do array usando o código delete[] ptr; .

Observe o uso de [] após delete . Usamos os colchetes [] para denotar que a desalocação de memória é a de um array.

---

Exemplo 3:C++ new and delete Operator for Objects

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

Saída

Age = 12

Neste programa, criamos um Student classe que tem uma variável privada idade .

Inicializamos idade para 12 no construtor padrão Student() e imprima seu valor com a função getAge() .

Em main() , criamos um Student objeto usando o new operador e use o ponteiro ptr para apontar para o seu endereço.

No momento em que o objeto é criado, o Student() construtor inicializa age para 12 .

Em seguida, chamamos o getAge() função usando o código:

ptr->getAge();

Observe o operador de seta -> . Este operador é usado para acessar membros de classe usando ponteiros.