Мне просто интересно, как можно создать утечку системной памяти с помощью С++. Я сделал некоторые ошибки в этом, но не так много, я знаю, что на С# это не реально, так как это управляемый код, но задавался вопросом, был ли простой способ сделать это с С++? Я просто подумал, что было бы интересно посмотреть, насколько сильно система страдает из-за неправильного написания кода. Спасибо.
Утечка памяти возникает, когда вы вызываете new, не вызывая соответствующий delete позже. Как показано в этом примере кода:
int main() {
// OK
int * p = new int;
delete p;
// Memory leak
int * q = new int;
// no delete
}
int main() {
while(true) new int;
}
Существует много типов утечек памяти:
Выделенная память, которая не может быть недоступна, потому что на нее ничего не указывает.
Эти типы утечек легко создавать на C и С++. Они также довольно легко предотвращают, легко обнаруживаются и легко излечиваются. Поскольку их легко обнаружить, есть множество инструментов, свободных и коммерческих, чтобы найти такие утечки.
Все еще доступная выделенная память, которая должна была быть выпущена давным-давно.
Эти виды утечек намного сложнее обнаружить, предотвратить или вылечить. Что-то еще указывает на это, и оно будет выпущено в конце концов - например, прямо перед exit(). Технически говоря, это не совсем утечка, но для всех практических целей это утечка. Многие из предположительно негерметичных приложений имеют такие утечки. Все, что вам нужно сделать, - запустить системный профиль, чтобы увидеть, как какое-то глупое приложение потребляет все больше памяти. Эти типы утечек легко создавать даже на управляемых языках.
Выделенная память, которая никогда не должна была быть выделена в первую очередь.
Пример. Пользователь может легко попросить Matlab создать такие утечки. Matlab также довольно агрессивен при создании таких утечек. Когда Matlab получает сбой из malloc, он переходит в цикл, где он ждет бит, а затем повторяет попытку malloc. Тем временем ОС безумно пытается справиться с потерей памяти, перетасовывая куски программ из реальной памяти в виртуальную память. В конце концов все находится в виртуальной памяти - и все заходит в тупик.
Я нашел эту статью полезной для стресс-тестирования - она также содержит примеры кода.
Просто напишите приложение, которое выделяет "много данных", а затем блокируется до тех пор, пока оно не будет убито. Просто запустите эту программу и оставьте ее в рабочем состоянии.
В С# просто используйте P/Invoke для выделения большого количества памяти, ручек ресурсов и их сохранения.
Вы можете использовать неуправляемый код просто отлично в простой жгуте С#
class ClassWithLeakedMemory{
private:
char* str;
public:
ClassWithLeakedMemory(){
str = new char[100];
}
~ClassWithLeakedMemory(){
cout<<"We are not freeing the dynamically allocated string memory"<<endl;
}
};
class ClassWithNoLeakedMemory{
private:
char* str;
public:
ClassWithNoLeakedMemory(){
str = new char[100];
}
~ClassWithNoLeakedMemory(){
cout<<"We are freeing the dynamically allocated string memory"<<endl;
delete[] str;
str = null;
}
};
int main() {
//we are creating an automatic object of the ClassWithleakedMemory
//when we will come out of the main, this object will be
//out of scope. hence it will be deleted. so destructor will
//be called. but in the destructor, we have not specifically
//deleted the dynamically allocated string.
//so the stack based pointer object str will be deleted but the memory
//it was pointing to won't be deleted. so we will be left with an
//unreferenced memory. that is memory leak.
ClassWithLeakedMemory objectWithLeakedmemory;
ClassWithNoLeakedMemory objectWithNoLeakedmemory;
return 0;
}
Способ, которым объект указателя на основе стека ссылается на динамически распределенную память в обоих классах, может отображаться как показано ниже:
#include <stdio.h>
void main(){
for(int i = 0; i < 1000; i++)
double* ptr = (double*)malloc(1000000*sizeof(double))
//free(ptr);
ptr = NULL;
}
Примечание: хэшированная строка кода вызвала утечку памяти, а процесс выделил ее и не вернул ее обратно в ОС