I'll provide a comprehensive comparison of these memory allocation functions with advanced details, tricky scenarios, and gotchas.

Core Comparison: malloc vs calloc vs new

malloc

void* malloc(size_t size);

Returns: Pointer to uninitialized memory
Language: C (also available in C++)
Initialization: No - contains garbage values
Failure: Returns NULL
Use case: When you don't need initialization

int* arr = (int*)malloc(10 * sizeof(int));
// Memory contains garbage - MUST initialize before use

calloc

void* calloc(size_t num, size_t size);

Returns: Pointer to zero-initialized memory
Language: C (also available in C++)
Initialization: Yes - all bits set to 0
Failure: Returns NULL
Use case: When you need zero-initialized memory

int* arr = (int*)calloc(10, sizeof(int));
// All elements guaranteed to be 0

new

Type* ptr = new Type;
Type* arr = new Type[n];

Returns: Pointer to constructed object(s)
Language: C++ only
Initialization: Calls constructor
Failure: Throws std::bad_alloc exception (or returns nullptr with std::nothrow)
Type-safe: No casting needed

MyClass* obj = new MyClass(args);  // Calls constructor
int* arr = new int[10];            // Default initialization

Free vs Delete Comparison

free

void free(void* ptr);

Deallocates memory from malloc/calloc/realloc
Does NOT call destructors
Setting ptr to NULL after free is manual

delete

delete ptr;      // For single object
delete[] arr;    // For arrays

Calls destructor before deallocation
Must match allocation type (new → delete, new[] → delete[])

Advanced Details & Tricky Questions

1. Zero-initialization Differences

Tricky Question: Is calloc(n, sizeof(int)) the same as malloc + memset?

// These are USUALLY the same, but not always
int* a = (int*)calloc(10, sizeof(int));
int* b = (int*)malloc(10 * sizeof(int));
memset(b, 0, 10 * sizeof(int));

Answer: For integers, yes. But for floating-point and pointers, NO!

calloc sets all bits to 0
On some systems, NULL pointer ≠ all bits zero
Floating-point 0.0 might not be all bits zero

2. Overflow Protection

Tricky Question: What happens with calloc(1000000000, 1000000000)?

// calloc checks for overflow in size computation
int* arr = (int*)calloc(SIZE_MAX/sizeof(int) + 1, sizeof(int));
// calloc will likely return NULL (overflow detected)

// malloc doesn't check - wraps around!
int* arr2 = (int*)malloc((SIZE_MAX/sizeof(int) + 1) * sizeof(int));
// Might allocate tiny amount due to overflow - DANGEROUS

Answer: calloc is safer because it checks for num * size overflow.

3. Constructor/Destructor Gotchas

class MyClass {
public:
    MyClass() { cout << "Constructor\n"; }
    ~MyClass() { cout << "Destructor\n"; }
    int data[100];
};

// WRONG - doesn't call constructor!
MyClass* obj1 = (MyClass*)malloc(sizeof(MyClass));
free(obj1);  // Doesn't call destructor

// CORRECT
MyClass* obj2 = new MyClass();
delete obj2;

Tricky Question: What happens here?

MyClass* obj = new MyClass();
free(obj);  // UNDEFINED BEHAVIOR! Destructor not called

4. Array Deletion Mismatch

Critical Tricky Question:

int* arr = new int[10];
delete arr;     // WRONG! Should be delete[]

MyClass* objs = new MyClass[5];
delete objs;    // WRONG! Memory leak + undefined behavior

What happens:

delete on an array: Only first object's destructor called, rest leaked
delete[] on single object: Reads bogus array size, crashes
In practice, often causes heap corruption

5. Mixing Allocation/Deallocation

// ALL OF THESE ARE UNDEFINED BEHAVIOR:
int* p1 = (int*)malloc(sizeof(int));
delete p1;  // ❌ malloc with delete

int* p2 = new int;
free(p2);   // ❌ new with free

int* p3 = new int[10];
delete p3;  // ❌ new[] with delete

int* p4 = (int*)calloc(10, sizeof(int));
delete[] p4;  // ❌ calloc with delete[]

6. Alignment Requirements

Tricky Question: Does malloc guarantee alignment for any type?

struct __attribute__((aligned(32))) AlignedStruct {
    char data[32];
};

// malloc guarantees alignment for standard types
AlignedStruct* s = (AlignedStruct*)malloc(sizeof(AlignedStruct));
// May NOT be 32-byte aligned!

// C11 solution:
void* ptr = aligned_alloc(32, sizeof(AlignedStruct));

// C++ solution:
AlignedStruct* s2 = new AlignedStruct;  // Respects alignment

7. Exception Safety

void riskyFunction() {
    int* p = (int*)malloc(100);
    // If exception thrown here, memory leaked!
    throw std::runtime_error("error");
    free(p);  // Never reached
}

void saferFunction() {
    int* p = new int[100];
    // Exception thrown - still leaked!
    throw std::runtime_error("error");
    delete[] p;  // Never reached
}

// BEST: Use RAII
void bestFunction() {
    std::unique_ptr<int[]> p(new int[100]);
    throw std::runtime_error("error");
    // Destructor called automatically, no leak!
}

8. Reallocation

Tricky Question: Can you reallocate memory from new?

int* arr = (int*)malloc(10 * sizeof(int));
arr = (int*)realloc(arr, 20 * sizeof(int));  // ✅ OK

int* arr2 = new int[10];
arr2 = (int*)realloc(arr2, 20 * sizeof(int));  // ❌ UNDEFINED!
// No realloc equivalent for new in standard C++

9. Double Free

int* p = (int*)malloc(sizeof(int));
free(p);
free(p);  // UNDEFINED BEHAVIOR - double free

// Detection:
int* p2 = (int*)malloc(sizeof(int));
free(p2);
p2 = NULL;  // Good practice
if (p2) free(p2);  // Safe

10. Placement New

Advanced Question: How to use memory without allocating?

char buffer[sizeof(MyClass)];
MyClass* obj = new (buffer) MyClass();  // Placement new
obj->~MyClass();  // Must manually call destructor
// Don't delete - no allocation happened!

Performance Considerations

// calloc might be faster for large allocations
// OS may use copy-on-write zero pages
char* big1 = (char*)calloc(1000000, 1);  // Fast - kernel trick

char* big2 = (char*)malloc(1000000);     // Regular allocation
memset(big2, 0, 1000000);                // Actually writes zeros

Common Interview Questions

Q: Why can't you use delete with malloc? A: Different heap managers, internal bookkeeping differs, no constructor/destructor pairing.

Q: When would you prefer malloc over new? A: C compatibility, variable-sized arrays, when working with C APIs, realloc needed.

Q: What's the difference between delete and delete[]? A: delete[] calls destructor for each array element and deallocates array; delete assumes single object.

Q: Can new ever return NULL? A: Not by default (throws exception), but new (std::nothrow) returns NULL on failure.

This covers the essential advanced details and tricky scenarios you'll encounter with these memory management functions!