In our previous lessons, we have learnt
the concept of dynamic memory allocation. We have understood what is stack and what is
heap in applications memory. Now in this this
lesson, we're going to talk about one situation which has caused by improper use of dynamic memory or the memory on the heap and this
situation is memory leak. A quick recap of some of the concepts
that we have discussed in our previous lessons. The memory that is allocated for the
execution of an of of a program or what we can also
call applications memory is typically divided into these four
segments or these four sections. One section store stuff instructions in
the program that need to be executed this section is
called the code segment or the text segment, another section is use to
store the global variables, the variables which are declared inside functions and have
lifetime of the whole application. Another section of the memory is used to
execute the function calls and store all the local variables this
section is called stack. The size of these three segments the
code segment, the global variable segment, and the stack segment are fixed and decided when the program is
compiling and that is that the compile-time, and
the forth section which is quite heap or dynamic memory
does not have a fixed size. Heap can grow as per our need. As we know we get memory from the heap
by making the call to malloc function in C and when we are done using that memory
on the heap, we make a call to the free function to deallocate
or free that particular memory. In C++ apart from malloc and
free, we can also use the operater new to get some memory and
operater delete to free that memory. Leak is a
situation when we get to memory on the heap and do not
free it when we are done using it. So our application is actually holding on to some unused
memory on the heap but why do we call the situation memory leak and why does it happen due to improper
use of dynamic memory only, due to improper use
of heap only and not some other sections of applications memory.
We will try to understand this through one simple program so what I'll do is
I'll write one simple program and show the simulation of its execution in the
memory to explain these concepts. In my C program here, I'm going to write a
very simple betting game and the game is that we have three
positions and three cards Jack, queen and king Initially jack is at the first position.
Queen is at the second position and King is at the third position and then computer shuffles these cards so
that the positions of these cards is changed, is randomized and now the player has to guess the position of the
Queen. He has to bet some amount of money. Let's say it's a virtual cash and if
he win see if he predicts the position if I guess the position of
queen correctly, he takes over it three times the amount that he had bet and if he loses he simply loses the bet
amount. Let's say player initially has
hundred-dollar of virtual cash and he can me as many times as he wants and untill he runs out of cash. So let us
know implement this game the first thing that I want to do is I
wanted to declear a global variable named cash that at any point will
store the virtual cash available with the
player. Initially, he has hundred dollars of virtual cash and then
in the main method I will declare a variable name bet and have a great code something
like this. While cash is greater than zero, while player still
has some cash. We will ask him to bet something and we will it take this input in this
variable bet using scanf. For negative scenarios
like bet equals zero, bet being greater than the cash available,
we will break out of this loop. We will end our game. For all other conditions, let's say it
will make a call to play function, and of course now we will have to write
the play function. We will be passing bet to the play function, so bet will be an
argument. Now in a play function, i will declare a character J array of size 3 and initially, we will have the character at the
first position to say that there is jack at the first position.
J for jack and similarly Q is for Queen and
K is for king and now the computer must perform a
randomized shuffling. So we will write a print statement like
this. Now we need to find a logic to make a random shuffle of cards. One such logic is that we can make a
call to random number generator function in C. To use the random number generator
first we will make a call to srand function and pass it an argument something like this. I'll come back to
what I'm doing here in a srand by making a call to
srand and now let's say we run a loop five times and we will choose any two random positions among
0, 1 and 2 and swap the later said these positions
in the array. Let's say these positions are X&Y. Now
then we make a call to rand function we will get at random number but we want a number
between zero and 2, O and 2 included. So we will take modulo by 3 so that we either get 0 or 1 or 2 So we will take 2 such a random
positions, with statements like this and now what we can do is we can swap the
character at these positions. So we will use a temporary variable. First
we will store the character that position X
in temp and then we will do something
like this. I'm short of space here. I'm writing three
statements in the same line. Okay so now swapping is done.
104
00:06:08,710 --> 00:06:11,770
So we are swapping or shuffling characters at two positions, five times
each time we are picking up two positions X and Y randomly by making call to rand
function and taking a modulo by 3. So this will guarantee us that X and Y is
between 0 and 2 that will be valid positions. By
making a call to rand function, we will get the random numbers, but we also used this srand once and passed this time null the return of time function. In random number generation, there is
something is one concept of seeding the random
number generator, so we are passing seed to random number
generator. We will not go into the details of random number generation now. Now what I'll do in the play function
is i'll have a variable named players guess and I'll ask the player to guess the
position of Queen and then I will use scanf to take the
input. Now if the player is correct then the character at that particular
position in character array c and the position will be one minus what
the their inputs because the player is inputting
1, 2 or 3 that will map to 0, 1 and 2 in the array. So if the
character is queen he has won. So his overall cash will be incremented by three times the
bet amount else he has lost and his cash will be
decremented by the bet amount. So in the case of when we will write
a print statement like this. We will say that you have won and the
result is this and your total cash right now is this. Remember
cash is a global variable and we will print something similar if
the player loses. Finally our play function is looking
something like this and we have also moved this variable
cash at the top. In the main method, i have added two
more print statement initially. Let's now play this game and see what
happens. what I have done is I have compiled this code and created an
executable named game.exe and now I'm going to
run that executable. So this is asking what's your bet.
Let's say we want to bet five Dollars on position 1 and I lose on my balance now is ninety five dollars.
Let's bet again, this time again i lose and I can go on
playing. So i'm losing again and again. Finally a win after a longtime. I can go on playing this game but I want
to show you something else. I have opened the task manager of
Windows and here as you can see and this
highlighted row is for game.exe. The third
column here is the memory consumed by this executable
game.exe. You will have to see this in full screen. Now as I go on playing, the memory
consumption here the memory that showing here is not increasing.
It's always 348 k. Now I'll go ahead and make some
changes in my code. I'll do here is, this particular
character array that I'm creating as a local variable in the play function right now it's created as a local
variable , so it will go on the stack. I want to
create a character array on the heap. So what I'll do is I'll right statement like this, i'll declare
a character pointer named C and then I'll use malloc to fetch memory to store 3 character
variables. In C++, we could have said
something like this, we could have used the new operator and
now i'll set the values at
zeroth index as J, oneth as Q and twoth
as K. So we have created an array on the heap and C is a pointer to the base address of that array. C is still
a local variable but now it is a pointer to character and we can still use it like array. The rest of the code
will just work fine. Let us run this code and see what happens. I have opened the task manager and I'm
running the executable. Watch for the memory consumption of
game.exe. I will make some bets. As you can see
right now the memory consumption is 348k. I just kept on playing and after
some time the memory consumption is 488 K. It has shot up and if you will
keeping this game further after some time it will shoot up again.
Maybe after some time but it for shoot up for sure. So why is it
happening. Why was it not shooting up when C
the character array was not on not on the heap and it
was under stack. Let's try to understand. I have drawn sections of applications
memory here, and let us now see what really happens
in the memory when we are playing a game. As we know
from our previous lessons all the information about function
call execution goes into the stack section of the memory. Any
time the function is called are some amount of memory from the stack
is allocated for its execution. When the program starts executing first
the main method is invoked or called. So let's say some amount of memory is
allocated for the execution of main this is what we call the stack
frame of a function. So this is stack frame of main and all the
local variables of main will sit inside this stack frame in
our code we had a local variable named bet. So it will go here and we had a global
variable named cash. Initially let's say main
function is executing. When we play a game main function makes
multiple calls to play function. What really happens when a
function makes calls to another function is that. That particular function is
paused and memory is allocated for the execution of on the called function. So main will pause
and play even start executing and play will go on top of main
in the stack. We had a couple of local variables in
play all will go in this stack frame. I X Y players guess and for the case one when we had the
character array C on the stack itself, so it was not created using a call to
malloc by the character array C will also
sit in this stack frame. Now when the execution of play function
will finish, control will return back to main and a
memory that was allocated for the execution of play function will be
reclaimed. Any time function call finishes the
memory that it is allocated on the stack is reclaimed. So there is one stack frame
corresponding to each call and at soon as that call finishers that
memory is claimed back and now main will make
another call to play because we will play multiple rounds. So play will again come into the stack and
it will be cleared again when play finishes. As you can see all the local variables get
cleared each time the function call finishes. For anything on the stack we do not have
to worry about it's deallocation it happens automatically when the
function call finishes. Now let's talk about the second case when
character array is created on the heap using a call to malloc function. Once again we will make multiple calls to
play function. Now what will happen this time is
that we will not create the array on the stack. we will still
have are varaible named C, a local
variable named C. But this variable will not be of type
character array of size 3. This variable will be of type pointer to
character and we will make a call to malloc function
to create the array on the heap and this local variable which is a
pointer to character will only points to this particular memory block. Anything that is on the heap has to be
accessed through a pointer variable. So here we have created the array on the
heap and we have kept only a pointer variable on the stack. Now when the call to play function will
finish the memory allocated for the execution of call to play function will be reclaimed so all the local
variables will go away. But this memory on the heap the lie
unused and un referenced and it will not get deallocated.
Anything on the heap has to be explicitly deallocated by making the
call to free function or by using a delete operator and
think about it. We will make multiple cause to play function as we play multiple rounds of our game
and each time in each call we will
create one such memory block on the heap that will lie unreferenced and unused
when call to play function will finish. If we will play a game 100 rounds then they will have 100 such unreferenced
and unused memory blocks of 3 characters in the heap. heap is not fixed in size and our
application can claim can get more memory in the heap
section as long as our system itself is not
running out of memory and if we are not be allocating and
this unused memory on the heap, we are depleting and wasting memory which
is an important resource. Our applications memory consumption will
only keep on growing with time. Memory leaks are really nasty
bugs to have in your program. Anything unused and unreferenced under
heap is garbage. In C or C++ we have to make
sure as programmers that garbage is not
created on the heap. Memory leak is nothing but growth of
garbage in the heap. In languages like Java and C#, garbage automatically
cleared from the heap. So programmer does not have to worry about freeing or deallocating the memory
on heap which is a cool feature to have. It avoids memory leak. In this example, we
were creating an array of three characters on the heap, What if we were creating an array of
10,000 characters and not freeing the memory after we were done using
it. At the end of the function the memory consumption would have shot
up like anything. Coming back to my code here, what I have done is I have created a
character array of size ten thousand of ten thousand characters here. My
logic would not change. I'll just use first three positions in the
array. I'm just trying to show you something and ta end of this
particular function when we are done using this array on the heap. We are making
call to free function, passing it the address of this memory
block this array C. Our program will just work like before,
but let's from this and monitor the memory consumption once again. Once again I'm showing you that task
manager and I am playing the game let's make some bets. Now watch out
the memory consumption of game.exe. For howsoever long you will play the
game the memory consumption wont shoot up. As
you can see it's 356 K and it's not shooting up for me even after playing for a long time, and
it is not shooting up because we had used free to deallocate the memory when we were
done using it at the end of the function. Remember we had created an array of
size ten thousand and if we were not using free then the
memory would have shot up like anything. The memory consumption would
have shot up like anything. but because we are freeing at the end
of the function it's not going up there is no memory
leak. so finally to summarize it, memory leak is improper use of dynamic
memory or the heap section of memory that
causes the memory consumption of our program to increase over a period of time.
Remember memory leak always happens because of unused and unreferenced memory
blocks in the heap. Anything on the stack is deallocated automatically and
stack is all is fixed in size. At the most we can have an overflow
in stack. So this was memory leak in C C++. Thanks for watching.
