Блог

 std::map<int, int> * mp = new std::map<int, int>;
for(int i = 0; i < 999999; i  ){
  mp->insert(std::pair<int, int>(i, 999999-i )); 
}
p("created");
//mp->clear();     -     doesn't help either
delete mp;
p("freed");
  

Проблема в том, что «удалить mp» ничего не делает. Для сравнения:

 std::vector<int> * vc = new std::vector<int>;
for(int i = 0; i < 9999999; i  ){
  vc->push_back(i); 
}
p("created");
delete vc;
p("freed");
  

освобождает память. Как освободить память из map?
PS: p(«строка») просто приостанавливает программу и ожидает ввода.

Используемая приложением оперативная память не является точным способом определить, была ли память освобождена семантически.

Освобожденная память — это память, которую вы можете повторно использовать. Однако иногда вы не видите эту освобожденную память непосредственно в том, что ОС сообщает как память, используемую нашим приложением.

Вы знаете, что память освобождена, потому что так гласит семантика языка.

На самом деле, если следующий код не протекает:

 {
  std::map<int, int> some_map;
}
  

Следующий код также не должен протекать:

 {
  std::map<int, int>* some_map = new std::map<int, int>();
  /* some instructions that do not throw or exit the function */
  delete some_map;
}
  

Это применимо к любому типу, с которым вы используете new , при условии, что тип хорошо написан. И std::map , вероятно, написан очень хорошо.

Я предлагаю вам использовать valgrind для проверки ваших утечек. Я сильно сомневаюсь, что то, что вы наблюдали, было реальной утечкой.

Как упоминает Дэниел, оперативная память, используемая приложением, не обязательно является показателем утечки памяти. Что касается поведения, которое вы заметили в отношении векторов, вектор гарантирует, что расположение памяти является непрерывным, и, следовательно, при создании вектора размером 99999999 все элементы 99999999 расположены последовательно и будут составлять довольно значительный кусок памяти. Удаление этого определенно повлияет на размер процесса. Карта ведет себя по-разному (согласно Википедии, ее часто реализуют как самобалансирующееся двоичное дерево), поэтому я предполагаю, что ее удаление вызывает фрагментацию в пространстве памяти процесса и, возможно, из-за этого память процесса не удаляется немедленно. Лучшим способом обнаружения утечек памяти было бы использовать такой инструмент, как valgrind, который четко укажет, что не так.

Чтобы точно определить, освобождаете вы память или нет, попробуйте добавить наблюдаемые эффекты к деструкторам вашего объекта и … понаблюдайте за ними. Например, вместо map создайте пользовательский класс, который выдает выходные данные при вызове деструктора. Что-то вроде этого:

 #include <map>
#include <iostream>
#include <utility>

class Dtor{
        int counter;
    public:
        explicit Dtor(int c):counter(c) {std::cout << "Constructing counter: " << counter << std::endl; }
        Dtor(const Dtoramp; d):counter(d.counter) {std::cout << "Copy Constructing counter: " << counter << std::endl; }
        ~Dtor(){ std::cout << "Destroying counter: " << counter << std::endl; }
};

int main(){
    std::map<int, const Dtoramp;> * mp = new std::map<int, const Dtoramp;>;
    for (int i = 0; i < 10;   i){
        mp -> insert(std::make_pair(i, Dtor(i)));
    }
   delete mp;
   return 0;
}
  

Вы увидите, что удаление указателя вызывает деструктор ваших объектов, как и ожидалось.