std::calloc(3)

💖 std::calloc(3) 💖

okay bestie, welcome to the C++ Standard Libary manual page for std::calloc 🫶 yes, that manual name is exactly how it shows up here. this is the whole vibe: allocate a zeroed block, get a pointer, and don’t forget to free it, periodt.

---

✨ NAME ✨

std::calloc - std::calloc — yes, this page is literally named after itself, iconic 💅

🌸 Synopsis 🌸

Defined in header <cstdlib>:

void* calloc( std::size_t num, std::size_t size );

Allocates memory for an array of num objects of size size, initializes it to all bits zero (implicitly creating objects in the destination area). ✨

If allocation succeeds, returns a pointer to the lowest (first) byte in the allocated memory block that is suitably aligned for any object type. 🎀

If size is zero, the behavior is implementation defined: a null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage. 🙈

The following functions are required to be thread-safe:

• the library versions of operator new and operator delete
• user replacement versions of global operator new and operator delete
• std::calloc, std::malloc, std::realloc (since C++11), std::aligned_alloc (since C++17), std::free

Calls to these functions that allocate or deallocate a particular unit of storage occur in a single total order, and each such deallocation call happens-before the next allocation (if any) in this order. 👑

🌼 Parameters 🌼

• num — number of objects
• size — size of each object

🦋 Return value 🦋

On success, returns the pointer to the beginning of newly allocated memory. To avoid a memory leak, the returned pointer must be deallocated with std::free() or std::realloc(). 💖

On failure, returns a null pointer. 💀

🎀 Notes 🎀

Due to the alignment requirements, the number of allocated bytes is not necessarily equal to num * size. no cap.

Initialization to all bits zero does not guarantee that a floating-point or a pointer would be initialized to 0.0 and the null pointer value, respectively (although that is true on all common platforms). 😭

Originally (in C89), support for zero size was added to accommodate code such as:

OBJ *p = calloc(0, sizeof(OBJ)); // "zero-length" placeholder
...
while (1)
{
    p = realloc(p, c * sizeof(OBJ)); // reallocations until size settles
    ... // code that may change c or break out of loop
}

✨ Example ✨

// Run this code

#include <cstdlib>
#include <iostream>

int main()
{
    int* p1 = (int*)std::calloc(4, sizeof(int)); // allocate and zero out an array of 4 int
    int* p2 = (int*)std::calloc(1, sizeof(int[4])); // same, naming the array type directly
    int* p3 = (int*)std::calloc(4, sizeof *p3); // same, without repeating the type name

    if (p2)
        for (int n = 0; n < 4; ++n) // print the array
            std::cout << "p2[" << n << "] == " << p2[n] << '\n';

    std::free(p1);
    std::free(p2);
    std::free(p3);
}

Output:

p2[0] == 0
p2[1] == 0
p2[2] == 0
p2[3] == 0

👀 See also 👀

C documentation for calloc — that’s the C version, iykyk 🫶

---

and that’s the whole page, bestie. it came from source http://cppreference.com, dated 2024.06.10, and the footer says std::calloc(3) — now go free your pointers and slay 💅💖