CODEWITHSUNDEEP
c++memory-leaks
Bali C
Bali C

Reputation: 31221

How to create a memory leak in C++?

I was just wondering how you could create a system memory leak using C++. I have done some googling on this but not much came up, I am aware that it is not really feasible to do it in C# as it is managed code but wondered if there was a simple way to do this with C++? I just thought it would be interesting to see how much the system suffers because of code not being written properly. Thanks.

Upvotes: 30

Views: 40110

Answers (10)

Sapphire_Brick
Sapphire_Brick

Reputation: 1672

It's as simple as:⠀⠀⠀

new int;

Upvotes: 2

Abdel Aleem
Abdel Aleem

Reputation: 747

When an object that is created using new is no longer referenced, the delete operator has to be applied to it. If not, the memory it occupies will be lost until the program terminates. This is known as a memory leak. Here is an illustration:

#include <vector>
using namespace std;

void memory_leak(int nbr)
{
   vector<int> *ptrVector = new vector<int>(nbr);
   // some other stuff ...
   return;
}

If we return without calling delete on the object (i.e. delete ptrToVector) a memory leak occurs. To avoid this, don't allocate the local object on the memory heap but instead use a stack-allocated variable because these get automatically cleaned up when the functions exits. To allocate the vector on the run-time stack avoid using new (which creates it on the heap) and the pointer.

Upvotes: 2

somenath mukhopadhyay
somenath mukhopadhyay

Reputation: 1558

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

The way the stack based pointer object refers to the dynamically allocated memory in both the classes can be shown pictorially as below:

enter image description here

Upvotes: 3

Omar Osama
Omar Osama

Reputation: 1431

#include <stdio.h>

void main(){

for(int i = 0; i < 1000; i++)

double* ptr = (double*)malloc(1000000*sizeof(double))

//free(ptr);

ptr = NULL;

}

note : the hashed line of code caused a memory leak while the process allocated it and did't return it back to the OS

Upvotes: 0

David Hammen
David Hammen

Reputation: 33106

There are many kinds of memory leaks:

  • Allocated memory that is unreleasable because nothing points to it.
    These kind of leaks are easy to create in C and C++. They are also pretty easy to prevent, easy to detect, and easy to cure. Because they are easy to detect there are lots of tools, free and commercial, to help find such leaks.

  • Still-accessible allocated memory that should have been released a long time ago.
    These kinds of leaks are much harder to detect, prevent, or cure. Something still points to it, and it will be released eventually -- for example, right before exit(). Technically speaking, this isn't quite a leak, but for all practical purposes it is a leak. Lots of supposedly leak-free applications have such leaks. All you have to do is run a system profile to see some silly application consume ever more memory. These kinds of leaks are easy to create even in managed languages.

  • Allocated memory that should never have been allocated in the first place.
    Example: A user can easily ask Matlab to creating these kinds of leaks. Matlab is also rather aggressive at creating these kinds of leaks. When Matlab gets a failure from malloc it goes into a loop where it waits for a bit and then retries the malloc. Meanwhile, the OS frantically tries to deal with the loss of memory by shuffling chunks of programs from real memory into virtual memory. Eventually everything is in virtual memory -- and everything creeps to a standstill.

Upvotes: 9

Patrick B.
Patrick B.

Reputation: 12333

Just write an application which allocates "a lot of data" and then blocks until it is killed. Just run this program and leave it running.

Upvotes: 3

StackedCrooked
StackedCrooked

Reputation: 35485

A memory leak occurs when you call new without calling a corresponding delete later. As illustrated in this sample code:

int main() {
    // OK
    int * p = new int;
    delete p; 

    // Memory leak
    int * q = new int;
    // no delete
}

Upvotes: 34

sehe
sehe

Reputation: 392833

In C#, just use P/Invoke to allocate a lot of memory, resource handles and keep them around.

You can use unmanaged code just fine in a simple C# harness

Upvotes: 2

Puppy
Puppy

Reputation: 146910

int main() {
    while(true) new int;
}

Upvotes: 17

Tony The Lion
Tony The Lion

Reputation: 63190

  1. Create pointer to object and allocate it on the heap
  2. Don't delete it.
  3. Repeat previous steps
  4. ????
  5. PROFIT

Upvotes: 27

Related Questions