Как очистить всю память для неиспользуемого массива, выделенного в куче

0

У меня есть вопрос об удалении [] p. Я написал фрагмент кода для проверки этой функции. Но я обнаружил, что после выполнения удаления [] p, только первые 2 элемента массива были освобождены, а оставшиеся нет. См. Мой тестовый фрагмент и результат вывода, как показано ниже. Кто может сказать мне, почему и как я могу удалить всю память для неиспользуемого массива? Благодарю!

#include <iostream>
using namespace std;
int main()
{
   int *p;
   p = new int[20];
   for(int i=0;i<20;i++)
   {
       p[i]=i+1;
   }
    cout<<"------------------------Before delete-------------------------"<<endl;
    for(int i=0;i<20;i++)
   {
       cout<<"p+"<<i<<":"<<p+i<<endl;
       cout<<"p["<<i<<"]:"<<p[i]<<endl;
   }

    delete[] p;
        cout<<"-------------------After delete------------------------"<<endl;
    for(int i=0;i<20;i++)
   {
       cout<<"p+"<<i<<":"<<p+i<<endl;
       cout<<"p["<<i<<"]:"<<p[i]<<endl;
   }
   return 0; 
}

ВЫХОД В www.compileronline.com

Compiling the source code....
$g++ main.cpp -o demo -lm -pthread -lgmpxx -lgmp -lreadline 2>&1


Executing the program....
$demo

------------------------Before delete-------------------------
p+0:0xa90010
p[0]:1
p+1:0xa90014
p[1]:2
p+2:0xa90018
p[2]:3
p+3:0xa9001c
p[3]:4
p+4:0xa90020
p[4]:5
p+5:0xa90024
p[5]:6
p+6:0xa90028
p[6]:7
p+7:0xa9002c
p[7]:8
p+8:0xa90030
p[8]:9
p+9:0xa90034
p[9]:10
p+10:0xa90038
p[10]:11
p+11:0xa9003c
p[11]:12
p+12:0xa90040
p[12]:13
p+13:0xa90044
p[13]:14
p+14:0xa90048
p[14]:15
p+15:0xa9004c
p[15]:16
p+16:0xa90050
p[16]:17
p+17:0xa90054
p[17]:18
p+18:0xa90058
p[18]:19
p+19:0xa9005c
p[19]:20
-------------------After delete------------------------
p+0:0xa90010
p[0]:0
p+1:0xa90014
p[1]:0
p+2:0xa90018
p[2]:3
p+3:0xa9001c
p[3]:4
p+4:0xa90020
p[4]:5
p+5:0xa90024
p[5]:6
p+6:0xa90028
p[6]:7
p+7:0xa9002c
p[7]:8
p+8:0xa90030
p[8]:9
p+9:0xa90034
p[9]:10
p+10:0xa90038
p[10]:11
p+11:0xa9003c
p[11]:12
p+12:0xa90040
p[12]:13
p+13:0xa90044
p[13]:14
p+14:0xa90048
p[14]:15
p+15:0xa9004c
p[15]:16
p+16:0xa90050
p[16]:17
p+17:0xa90054
p[17]:18
p+18:0xa90058
p[18]:19
p+19:0xa9005c
p[19]:20
  • 0
    Найдите unique_ptr <> для C ++ 11 и auto_ptr <> для более старых версий C ++. Кроме того, std :: shared_ptr <>.
  • 0
    Мне кажется, этот код может вызвать ошибку сегментации, так как вы обращаетесь к памяти, не выделенной вашим процессом, при чтении массива после удаления [].
Теги:
arrays
dynamic
heap
delete-operator

2 ответа

0
Лучший ответ

Важно различать очищенную память и удаленную память.

Когда память очищается, она инициализируется некоторым значением - возможно, всеми нулями. Но когда память удаляется или освобождается, она возвращается в кучу. Когда память освобождается, менеджер памяти не обязан снимать память. Два байта, которые вы видите, меняются, скорее всего, из маркера отладки, используемого диспетчером памяти, чтобы помочь отслеживать переполнение буфера.

Если вы хотите очистить всю память, вам нужно сделать это, прежде чем удалять ее - только в этот момент у вас все еще есть право владения этой памятью. Очистка после удаления происходит с использованием памяти, которой вы не владеете.

  • 0
    Спасибо за указание на ключевой момент, который я неправильно понял !!!
2

Память очищается - просто нет требования, чтобы компилятор фактически обнулял int в своем деструкторе. То, что вы видите, это то, что компилятор не думал, что это необходимо, так что он все еще там. Деструктор называется и память освобождается.

Вы можете видеть это более четко, если вы сделали что-то вроде:

struct A {
    int i;
    A() : i(7) { }

    ~A() {
        std::cout << "deleting A." << std::endl;
        i = 0;
    }
};

И повторите свой эксперимент с помощью A* p = new A[20]; ,

Ещё вопросы

Сообщество Overcoder
Наверх
Меню