Using malloc() Function in C

By: Abinaya Printer Friendly Format    

The malloc() function isn't limited to allocating memory for strings, of course; it can allocate space for any storage need. This function allocates memory by the byte. Recall that malloc()'s prototype is

void *malloc(size_t num);

The argument size_t is defined in STDLIB.H as unsigned. The malloc() function allocates num bytes of storage space and returns a pointer to the first byte. This function returns NULL if the requested storage space couldn't be allocated or if num == 0.

Listing below shows you how to use malloc() to determine the amount of free memory available in your system. This program works fine under DOS, or in a DOS box under Windows. Be warned, however, that you might get strange results on systems such as OS/2 and UNIX, which use hard disk space to provide "virtual" memory. The program might take a very long time to exhaust available memory.

Using malloc() to determine how much memory is free.

1: /* Using malloc() to determine free memory.*/
3: #include <stdio.h>
4: #include <stdlib.h>
6: /* Definition of a structure that is
7:    1024 bytes (1 kilobyte) in size.) */
9: struct kilo {
10:    struct kilo *next;
11:    char dummy[1022];
12: };
14: int FreeMem(void);
16: main()
17: {
19:    printf("You have %d kilobytes free.\n", FreeMem());
20:    return(0);
21: }
23: int FreeMem(void)
24: {
25:    /*Returns the number of kilobytes (1024 bytes)
26:    of free memory. */
28:    int counter;
29:    struct kilo *head, *current, *nextone;
31:    current = head = (struct kilo*) malloc(sizeof(struct kilo));
33:    if (head == NULL)
34:       return 0;      /*No memory available.*/
36:    counter = 0;
37:    do
38:    {
39:       counter++;
40:       current->next = (struct kilo*) malloc(sizeof(struct kilo));
41:       current = current->next;
42:    } while (current != NULL);
44:    /* Now counter holds the number of type kilo
45:       structures we were able to allocate. We
46:       must free them all before returning. */
48:    current = head;
50:    do
51:    {
52:       nextone = current->next;
53:       free(current);
54:       current = nextone;
55:    } while (nextone != NULL);
57:    return counter;
58: }
You have 60 kilobytes free.

ANALYSIS: Listing above operates in a brute-force manner. It simply loops, allocating blocks of memory, until the malloc() function returns NULL, indicating that no more memory is available. The amount of available memory is then equal to the number of blocks allocated multiplied by the block size. The function then frees all the allocated blocks and returns the number of blocks allocated to the calling program. By making each block one kilobyte, the returned value indicates directly the number of kilobytes of free memory. As you may know, a kilobyte is not exactly 1000 bytes, but rather 1024 bytes (2 to the 10th power). We obtain a 1024-byte item by defining a structure, which we cleverly named kilo, that contains a 1022-byte array plus a 2-byte pointer.

The function FreeMem() uses the technique of linked lists, which was covered in more detail on Day 15, "Pointers: Beyond the Basics." In brief, a linked list consists of structures that contain a pointer to their own type (in addition to other data members). There is also a head pointer that points to the first item in the list (the variable head, a pointer to type kilo). The first item in the list points to the second, the second points to the third, and so on. The last item in the list is identified by a NULL pointer member.

Ask a Question

Most Viewed Articles (in C )

Latest Articles (in C)

Comment on this tutorial