Memory leaks: When do they happen?

Question

I have a ram of 8GB and I have Hard disk of 80GB. I have three programs as shown in below.

1)

main()
{

  while(1)
     x();
}

x()
{
  printf("hello\n");
}

Will there be a memory leak here in the above program? I suppose not. In case if it does not happen then what will happen? When will this stop?

2)

main()
{
   int *x;
   while(1)
      x=malloc(100*size(int));//there is a memory leak here
}

It's obvious that this program will crash after some time but I want to know WHEN, looking at the resources I mentioned above.

3)

main()
{
   x();
}
x()
{
   x();
}

Is this above program in infinite recursion? What will happen in the end? When will this program crashes/dies considering the resources I have?

Answer 1

A memory leak occurs when you request memory with malloc() and don't free() the memory.

Bad example

#include <stdlib.h>

int main(int argc, char *argv[]) {
    int *nums = malloc(10 * sizeof(int)); // create array with memory for 10 nums
    nums[0] = 2;
    nums[4] = 8;

    return 0; // main() ended but nums wasn't free'd. Memory leak/
}

Good example

#include <stdlib.h>

int main(int argc, char *argv[]) {
    int *nums = malloc(10 * sizeof(int)); // create array with memory for 10 nums
    nums[0] = 2;
    nums[4] = 8;

    free(nums); // free memory allocated for nums

    return 0;
}

Now about your programs.

1 - reformatted

This program will never end and forever call x (and thus print Hello World! till the end of times)

#include <stdio.h>

void x(void) {
    printf("Hello World!\n");
}

int main(int argc, char *argv[]) {
    while (1) x();
    return 0;
}

2 - reformatted

This program allocates memory for 100 integers every loop but never free's this memory. Huge memory leak that keeps going until the OS is out of memory.

#include <stdlib.h>

int main(int argc, char *argv[]) {
    int *x;
    while (1) {
        x = malloc(100 * size(int)); // allocate memory for an array of 100 integers
    }

    return 0;
}

3 - reformatted

This program keeps recursing until the stack is exhausted (stack trace) and the program will crash (stack overflow).

void x(void) {
    x();
}

int main(int argc, char *argv[]) {
    x();

    return 0;
}

Answer 2

There is no memory leak in the first program, it will run forever (or until it's killed from outside), happily printing that string.

There is a memory leak in the second but it won't crash. You'll just start getting NULL back from the malloc. Otherwise, same effect as number 1 above.

Number three will eventually overflow the stack, unless you have some particularly good tail end recursion optimisation in your compiler, in which case it too will run forever.

By the way, that code is particularly bad. It's been a long time since default return types and main functions without the two canonical argument lists were acceptable.

Answer 3

1. No memory leak. The program will never stop.
2. Here is memory leak. Beacuse during program work you are allocating memory but after next step you don't have any pointer to this memory to delete. When the memory is finished this will throw "bad alloc" error.
3. Here you don't have memory leak, but program will crash when the memory of stack is finished.