C++ malloc()

#include <iostream>
#include <cstdlib>
using namespace std;

int main() {

  // allocate memory of int size to an int pointer
  int* ptr = (int*) malloc(sizeof(int));

  // assign the value 5 to allocated memory
  *ptr = 5;

  cout << *ptr;

  return 0;
}

// Output: 5

malloc() Syntax

The syntax of malloc() is:

malloc(size_t size);

Here, size is the size of the memory (in bytes) that we want to allocate.

malloc() Parameters

The malloc() function takes the following parameter:

• size - an unsigned integral value (casted to size_t) which represents the memory block in bytes

malloc() Return Value

The malloc() function returns:

• a void pointer to the uninitialized memory block allocated by the function
• null pointer if allocation fails

Note: If the size is zero, the value returned depends on the implementation of the library. It may or may not be a null pointer.

malloc() Prototype

The prototype of malloc() as defined in the cstdlib header file is:

void* malloc(size_t size);

Since the return type is void*, we can type cast it to most other primitive types without issues.

Example 1: C++ malloc()

#include <iostream>
#include <cstdlib>
using namespace std;

int main() {

  // allocate 5 int memory blocks
  int* ptr = (int*) malloc(5 * sizeof(int));

  // check if memory has been allocated successfully
  if (!ptr) {
    cout << "Memory Allocation Failed";
    exit(1);
  }

  cout << "Initializing values..." << endl << endl;

  for (int i = 0; i < 5; i++) {
    ptr[i] = i * 2 + 1;
  }
  cout << "Initialized values" << endl;

  // print the values in allocated memories
  for (int i = 0; i < 5; i++) {

    // ptr[i] and *(ptr+i) can be used interchangeably
    cout << *(ptr + i) << endl;
  }

  // deallocate memory
  free(ptr);

  return 0;
}

Output

Initializing values...

Initialized values
1
3
5
7
9

Here, we have used malloc() to allocate 5 blocks of int memory to the ptr pointer. Thus, ptr now acts as an array.

int* ptr = (int*) malloc(5 * sizeof(int));

Notice that we have type casted the void pointer returned by malloc() to int*.

We then check if the allocation was successful or not using an if statement. If it was not successful, we exit the program.

if (!ptr) {
  cout << "Memory Allocation Failed";
  exit(1);
}

Then, we have used a for loop to initialize the allocated memory blocks with integer values, and another for loop to print those values.

Finally, we have deallocated the memory using the free() function.

free(ptr);

Example 2: C++ malloc() with Size Zero

#include <iostream>
#include <cstdlib>
using namespace std;

int main() {

  // allocate memory of size 0
  int *ptr = (int*) malloc(0);

  if (ptr==NULL) {
    cout << "Null pointer";
  }
  else {
    cout << "Address = " << ptr;
  }

  // deallocate memory
  free(ptr);

  return 0;
}

Output

Address = 0x371530

Here, we have used malloc() to allocate int memory of size 0 to the ptr pointer.

int* ptr = (int*) malloc(0);

Using an if statement, we then check whether malloc() returned a null pointer or if it returned an address.

Finally, we deallocated the memory using free().