C++ malloc()

The function malloc() in C++ is used to allocate the requested size of bytes and it returns a pointer to the first byte of allocated memory. A malloc() in C++ is a function that allocates memory at the runtime, hence, malloc() is a dynamic memory allocation technique. It returns a null pointer if fails.

Syntax:

pointer_name = (cast-type*) malloc(size);

Here, size is an unsigned integral value (cast to size_t) which represents the memory block in bytes

malloc() in C++ allocates a block of size bytes of memory, returning a pointer to the beginning of the block. The content of the newly allocated block of memory is not initialized, remaining with indeterminate values. Malloc function is present in <cstdlib> header file.

Return Types of malloc()

If the size is zero, the return value depends on the particular library implementation (it may or may not be a null pointer), but the returned pointer shall not be dereferenced.

• void pointer is used to the uninitialized the initialized memory block that is allocated by the function
• null pointer if the allocation fails

Working and Allocation of Memory Blocks Using malloc()

Example 1:

// C++ program to demonstrate working of malloc()

// cstdlib is used to use malloc function
#include <cstdlib>
#include <iostream>
using namespace std;
int main()
{
    // size_t is an integer data type which can assign
    // greater than or equal to 0 integer values
    size_t s = 0; // s is SIZE

    // malloc declaration/initialization
    int* ptr = (int*)malloc(s);

    // return condition if the memory block is not
    // initialized
    if (ptr == NULL) {
        cout << "Null pointer has been returned";
    }

    // condition printing the message if the memory is
    // initialized
    else {
        cout << "Memory has been allocated at address "
             << ptr << endl;
    }

    free(ptr);
    return 0;
}

Memory has been allocated at address 0x8cae70

free() function in C++ is used to dynamically de-allocate the memory.

Example 2:

// C++ program to demonstrate working of malloc()
#include <iostream>  
#include<stdlib.h>  
using namespace std;  
  
int main()  
{  
     // variable declaration
  int var_len = 10;
    
    // pointer variable declaration
  int *ptr;
  
  // allocating memory to the pointer variable using malloc()
  ptr = (int*) malloc(sizeof(int)*var_len);    
  for(int i=0;i<var_len;i++)  
  {  
      cout << "Enter a number : " << endl;  
      cin >> *(ptr+i);  
  }  
  cout << "Entered elements are : " << endl;  
   for(int i=0;i<var_len;i++)  
  {  
     cout << *(ptr+i) << endl;  
  }  
free(ptr);  
    return 0;  
}

Output:

Where Should Malloc be used?

1. Dynamic Memory allocation

Dynamic Memory Allocation helps us allocate a piece of memory as per the user's demand. It returns a pointer to the start of that memory, which could be treated similarly to an array.

2. Heap memory

malloc() allocates the memory location on the heap and returns a pointer on the stack pointing to the starting address of the array type memory being allocated whereas the static array size put a hard upper limit on how much data the program could process at any one time, without being recompiled.

3. Better lifetime

Variables or Arrays created using malloc exist for a lifetime until they are cleared. This is of great importance for various data structures such as linked lists, binary heap, etc.

Difference between new and malloc()