Understanding How malloc and new Work in C++

In C++, there are two common ways to get memory for your program while it’s running: using malloc and new. Both give you space to store things like numbers or objects, but they work a bit differently. Let’s take a closer look at how each of them works, with some examples to make things clearer.

1. How malloc Works

malloc is a function that comes from C, the language that C++ is built on. It’s used to get a chunk of memory from your computer’s heap (which is like a big, shared storage area). Here’s what happens when you use malloc:

• Asking for Memory: Imagine you want to keep track of 5 numbers in your program. You need space to store them, so you ask malloc for enough memory to hold 5 integers.

Example:

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

Here, malloc is being asked to give enough memory to hold 5 integers. The sizeof(int) part tells malloc how big each integer is, so it knows how much memory to give you. If everything goes well, ptr will point to the start of this new memory block.

• Managing Small Pieces of Memory: Sometimes, your program might need a lot of small pieces of memory. malloc is smart and tries to keep track of these small pieces efficiently. For example, if your program needs space for a single number, malloc will find a small piece of memory that’s just the right size.

Example:

char* c = (char*)malloc(sizeof(char));

Here, malloc gives you just enough memory to store a single character (like ‘A’ or ‘B’).

• What If It Fails?: Sometimes, there might not be enough memory available. When this happens, malloc returns NULL to let you know something went wrong. You should always check for this to avoid problems in your program.

Example:

int* data = (int*)malloc(1000000000 * sizeof(int)); // Asking for a lot of memory
if (data == NULL) {
    printf("Memory allocation failed!\n");
}

If the request is too large, malloc might not be able to find that much memory, and data would be NULL.

2. How new Works

new is an operator in C++ that not only gives you memory like malloc, but also helps set up that memory for you. It’s a bit like buying a new phone and having the store set it up with all your contacts and apps. Here’s how new works:

• Getting the Memory: Just like malloc, new can get a block of memory for you. But new does more than that—it also makes sure the memory is ready for you to use.

Example:

int* numbers = new int[5];

Here, new not only gives you space for 5 integers, but also makes sure the memory is set up so you can start using it right away.

• Setting Up Objects: If you’re working with objects (like a custom Car class), new not only gets the memory but also calls the constructor to set up the object for you.

Example:

class Car {
public:
    Car() {
        // Constructor code
    }
};

Car* myCar = new Car();

In this example, new gives you memory for a Car object and then runs the constructor to make sure your car is ready to go.

• What If It Fails?: If new can’t get the memory it needs, it doesn’t return NULL like malloc does. Instead, it throws an exception, which is a way of telling your program something went wrong in a more structured way.

Example:

try {
    int* data = new int[1000000000]; // Asking for a lot of memory
} catch (std::bad_alloc& e) {
    std::cout << "Memory allocation failed: " << e.what() << std::endl;
}

If the memory request is too big, new will throw a std::bad_alloc exception, and you can catch it to handle the error.