Malloc

Example

Let's start with a simple example: (source file)

#include <stdio.h>

int main ()
{
  // Declare a pointer to an int.
  int *p;

  // Get the space from malloc:
  p = (int*) malloc (sizeof(int));

  // Assign a value and print:
  *p = 5;
  printf ("Int value: %d\n", *p);

  // Free the memory when done:
  free (p);
}

Note:

The pointer declaration
```
  // Declare a pointer to an int.
  int *p;
    
```
simply declares the pointer variable. The pointer may itself is invalid since it hasn't been assigned a value yet.

In C99, pointers are initialized to zero, e.g.,

#include <stdio.h>

int main ()
{
  // Declare a pointer to an int.
  int *p;

  printf ("Initial value of pointer: %lu\n", p);    // Prints 0 (C99)
}

Thus, the "picture" after declaration is:

To make the pointer point to something, there are two ways:

Assign it an address of a known variable, e.g.

#include <stdio.h>

int main ()
{
  int *p;
  int i;

  // Extract the address of i and put that in p:
  p = &i;
}

Ask malloc to create some space and return the start address of that space:

#include <stdio.h>

int main ()
{
  int *p;

  // Get the space from malloc:
  p = (int*) malloc (sizeof(int));
}

Suppose the space assigned is at location 1023. The picture of memory after the allocation is:
After the space is assigned, it can be used:
```
  *p = 5;
  printf ("Int value: %d\n", *p);
    
```
After this assignment, the picture is:
The argument to malloc is the number of bytes desired.
- The program could also have been written as:
```
#include <stdio.h>

int main ()
{
  int *p;

  p = (int*) malloc (4);

  *p = 5;
  printf ("Int value: %d\n", *p);
}
        
```
  This works if we happen to know that an int takes up 4 bytes.
- Notice that a larger number will work:
```
#include <stdio.h>

int main ()
{
  int *p;

  p = (int*) malloc (16);

  *p = 5;
  printf ("Int value: %d\n", *p);
}
      
```
  Here, 16 contiguous bytes are allocated, of which only 4 are used.
- A smaller number will appear to work, but may in fact tamper with existing memory allocations.
- If you wish to know the number of bytes required for a type, simply print the sizeof value:
```
  printf ("The number of bytes needed by an integer: %d\n", sizeof(int));
  printf ("The number of bytes needed by a double: %d\n", sizeof(double));
       
```
Notice that the return value is cast into the pointer type:
```
  p = (int*) malloc (sizeof(int));
    
```
An easy way to remember this is: "the cast type is the same as the argument to sizeof but with a * appended".
- Thus, if the sizeof argument is an int, the return value should be cast into int* (an int pointer).
- Similarly, if the sizeof argument is an double, the return value should be cast into double*.
- It looks more complicated with 2D arrays, as we will see, but the essence is the same.

After the pointer has a value, we can actually print the address:

#include <stdio.h>

int main ()
{
  // Declare a pointer to an int.
  int *p;

  // Print the initial value of the pointer:
  printf ("Initial value of pointer: %lu\n", p);    // Prints 0 (C99)

  // Get the space from malloc:
  p = (int*) malloc (sizeof(int));

  // Print the address of the memory block returned by malloc:
  printf ("Current pointer: %lu\n", p);
}

Whenever we're done with memory allocated by malloc, we need to return it:
```
  // Free the memory when done:
  free (p);
    
```

Another example: (source file)

#include <stdio.h>

int main ()
{
  double *doublePtr;
  char *charPtr;

  printf ("The number of bytes needed by a double: %d\n", sizeof(double));
  printf ("The number of bytes needed by a char: %d\n", sizeof(char));

  // Get the space from malloc:
  doublePtr = (double*) malloc (sizeof(double));
  charPtr = (char*) malloc (sizeof(char));

  // Print the address of the memory block returned by malloc:
  printf ("double pointer is at location: %lu\n", doublePtr);
  printf ("char pointer is at location: %lu\n", charPtr);

  // Assign values and print:
  *doublePtr = 3.141;
  *charPtr = 'A';

  printf ("double value = %lf   char value = %c\n", *doublePtr, *charPtr);

  // Free the memory when done:
  free (doublePtr);
  free (charPtr);
}

Note:

Observe the pattern in calling malloc:

  doublePtr = (double*) malloc (sizeof(double));
  charPtr = (char*) malloc (sizeof(char));

Arrays

An example using arrays: (source file)

#include <stdio.h>

int main ()
{
  int A[10];
  int *B;

  printf ("BEFORE malloc: Address A=%lu  Address B=%lu\n", A, B);
  // Prints an address for A, but zero for B

  // Assign space to B:
  B = (int*) malloc (sizeof(int) * 10);
  
  printf ("AFTER malloc: Address A=%lu  Address B=%lu\n", A, B);
  // Prints an address for A and newly allocated address for B.

  // Two ways of assigning values:
  A[3] = 5;
  *(A + 4) = 6;
  printf ("A[3]=%d  A[4]=%d\n", A[3], A[4]);    // Prints 5 and 6.

  // Two ways of assigning values:
  B[3] = 7;
  *(B + 4) = 8;
  printf ("B[3]=%d  B[4]=%d\n", B[3], B[4]);    // Prints 7 and 8.

  // Done.
  free (B);
}

Note:

The memory picture after malloc is called is:

Array variables are really pointers and can be used as pointers:

  A[3] = 5;
  *(A + 4) = 6;    // Fifth position in array A.

You should use regular array indexing (A[3]=5) where possible, instead of the pointer manipulation (*(A+4) = 5).
The pointer version explains how arrays work:
- A is the address of the start of the array.
- A+4 is the address 4 positions into the array, i.e., the address of A[4].
- The expression *(A+4) follows the address. Thus, the assignment
```
  *(A + 4) = 6; 
       
```
  assigns the value 6 into this location.

Next, let's consider 2D arrays: (source file)

#include <stdio.h>

int main ()
{
  double A[10][10];     // Static allocation of space to array A.
  double **B;           // We'll use malloc to assign space to B.
  int i;

  printf ("BEFORE malloc: Address A=%lu  Address B=%lu\n", A, B);
  // Prints an address for A, but zero for B

  // Assign space for first dimension of B (an array of pointers-to-double)
  B = (double**) malloc (10 * sizeof(double*));
  for (i=0; i<10; i++) {
    B[i] = (double*) malloc (10 * sizeof(double));
  }
  
  printf ("AFTER malloc: Address A=%lu  Address B=%lu\n", A, B);
  // Prints an address for A and newly allocated address for B.

  // Two ways of assigning values:
  A[3][4] = 5.55;
  *((double*)A + 5*10 + 6) = 6.66;
  printf ("A[3][4]=%lf  A[5][6]=%lf\n", A[3][4], A[5][6]);    // Prints 5.55 and 6.66.

  // Twy ways of assigning values:
  B[3][4] = 7.77;
  *((*(B + 5)) + 6) = 8.88;
  printf ("B[3][4]=%lf  B[5][6]=%lf\n", B[3][4], B[5][6]);    // Prints 7.77 and 8.88

  // Free the individual small arrays:
  for (i=0; i<10; i++) {
    free (B[i]);
  }
  // Free the array of double-pointers:
  free (B);
}

Note:

The array A is given a chunk of space for 100 double's.
The picture of memory after the first call to malloc:
After the subsequent calls to malloc:
Both arrays are accessed using standard array indexing:
```
  A[3][4] = 5.55;
  B[3][4] = 7.77;
    
```
However, it is also possible (not recommended) to use the actual addresses and perform address arithmetic:
```
  *((double*)A + 5*10 + 6) = 6.66;

  *((*(B + 5)) + 6) = 8.88;
    
```
Let's explain the first one:
```
  *((double*)A + 5*10 + 6) = 6.66;
    
```
- A double occupies 8 bytes.
- Thus, a 10 x 10 array requires 100*8 = 800 bytes.
- To get to location A[5][6], we compute the address of the first byte in the 8 bytes allocated to A[5][6].
- Note that A[5] is the 6-th row and so, we need to skip past five rows: 5*10.
- Then we skip past 6 positions.
- The total number of positions to skip past: 5*10 + 6.
- Adding this to the start address gives the start address of position A[5][6].
- Finally, because A is declared as a 2D array, we need to cast A into a pointer type to perform arithmetic.
The second one is a little more complicated:
```
  *((*(B + 5)) + 6) = 8.88;
    
```
- Recall that B is a pointer that points to a block of double-pointers.
- Thus, B+5 is the sixth such pointer in the block.
- The expression *(B+5) follows that address, which is the address of the block of 10 elements assigned to the 6-th row.
- We now add 6 to this address to get the exact address of element B[5][6].
- Lastly, we follow the address (pointer) with the (outermost) * operation.
Note that the individual array blocks need to be free'd before the double-pointer block pointed to by B is free'd.

Structures

An example using struct's and pointers: (source file)

#include <stdio.h>

int main ()
{
  // A list node:
  struct ListNode {
    char *name;               // Fields: name and age.
    int age;
    struct ListNode *next;    // The "next" pointer.
  };

  struct ListNode *front;     // Point to front of list.
  struct ListNode *rear;      // To rear.
  struct ListNode *tempPtr;   // For temporary use.

  // Create a first node:
  tempPtr = (struct ListNode *) malloc (sizeof(struct ListNode));
  tempPtr->name = "Alice";
  tempPtr->age = 19;
  tempPtr->next = NULL;

  // Add to list:
  front = rear = tempPtr;

  // Create a second node:
  tempPtr = (struct ListNode *) malloc (sizeof(struct ListNode));
  tempPtr->name = "Bob";
  tempPtr->age = 18;
  tempPtr->next = NULL;

  // Add to list.
  front->next = tempPtr;
  rear = tempPtr;

  // Print etc ...
}

Note:

The memory picture after the first node is created:
The memory picture after the second node is created: