Why do we need calloc (or malloc)?

Question

After ignoring C for my entire CS career I have decided to give it a look!

When initialising variables, we can have :

int b = 0;

This initialises b, allocates memory for it, and we can later update it with

b = 2;

if needs be.

So, and forgive me for this ridiculously "noob" question but why do we need calls like :

double *b = (double *) calloc(n, sizeof(double));

when initialising the variable would allocate the space for it already?

Why can we not just do

double b = 0;
b* = b.addressOf(b) //or some similar construct.

What is the use of this?

I have tried Googling this to no avail so please forgive me - ufortunately * in Google is a wildcard and so relevant results are hard to find.

Answer 1

Variables declared in the current context end their lifetime at the end of the context.

Allocating memory gives you space to store longer-lived variables.

For example,

double *foo() {
    double d;
    return &d;
}

void bar() {
    double *d = foo();
    *d = 0.0;
}

will try to access a variable that no longer exists, because its lifetime is the foo function.

C and C++ do not keep track of objects. A pointer only points to the object, but does not extend object lifetime, so it is entirely possible for a pointer to be invalid even if it is not NULL.

However, this is valid:

double *foo() {
    return (double *)malloc(sizeof(double));
}

void bar() {
    double *d = foo();
    *d = 0.0;
}

This will allocate memory for a double, and return the pointer to the memory, which remains valid until explicitly returned to the pool using the free function. Not returning it to the pool will create a memory leak.