Editing Memory leak (section)

==Examples==
===Pseudocode===
The following example, written in [[pseudocode]], is intended to show how a memory leak can come about, and its effects, without needing any programming knowledge. The program in this case is part of some very simple software designed to control an [[elevator]]. This part of the program is run whenever anyone inside the elevator presses the button for a floor.

 When a button is pressed:
   Get some memory, which will be used to remember the floor number
   Put the floor number into the memory
   Are we already on the target floor?
     If so, we have nothing to do: finished
     Otherwise:
       Wait until the lift is idle
       Go to the required floor
       Release the memory we used to remember the floor number

The memory leak would occur if the floor number requested is the same floor that the elevator is on; the condition for releasing the memory would be skipped. Each time this case occurs, more memory is leaked.

Cases like this would not usually have any immediate effects. People do not often press the button for the floor they are already on, and in any case, the elevator might have enough spare memory that this could happen hundreds or thousands of times. However, the elevator will eventually run out of memory. This could take months or years, so it might not be discovered despite thorough testing.

The consequences would be unpleasant; at the very least, the elevator would stop responding to requests to move to another floor (such as when an attempt is made to call the elevator or when someone is inside and presses the floor buttons). If other parts of the program need memory (a part assigned to open and close the door, for example), then no one would be able to enter, and if someone happens to be inside, they will become trapped (assuming the doors cannot be opened manually).

The memory leak lasts until the system is reset. For example: if the elevator's power were turned off or in a power outage, the program would stop running. When power was turned on again, the program would restart and all the memory would be available again, but the slow process of memory leak would restart together with the program, eventually prejudicing the correct running of the system.

The leak in the above example can be corrected by bringing the "release" operation outside of the conditional:

 When a button is pressed:
   Get some memory, which will be used to remember the floor number
   Put the floor number into the memory
   Are we already on the target floor?
     If not:
       Wait until the lift is idle
       Go to the required floor
   Release the memory we used to remember the floor number

===C++===
The following [[C++]] program deliberately leaks memory by losing the pointer to the allocated memory.

<syntaxhighlight lang="c++">

int main() {
     int* a = new int(5);
     a = nullptr;
    /* The pointer in the 'a' no longer exists, and therefore cannot be freed,
     but the memory is still allocated by the system.
     If the program continues to create such pointers without freeing them, 
     it will consume memory continuously.
     Therefore, a leak would occur. */
}
</syntaxhighlight>