malloc and pointers to pointers

Question

I'm trying to understand when I need to use malloc when using multiple levels of pointers. For example,

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    typedef struct {
        char first[10];
        char last[10];
    } Person;

    Person *p;

    p = malloc(sizeof(Person));
    strcpy(p->first, "John");
    strcpy(p->last, "Doe");

    printf("First: %s Last:%s\n", p->first, p->last);

    return 0;
}

In this first version I'm using Person *p and I only use malloc to allocation space for type Person. In the 2nd version, I'll change Person *p to Person **p

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    typedef struct {
        char first[10];
        char last[10];
    } Person;

    Person **p;

    *p = malloc(sizeof(Person));
    strcpy((*p)->first, "John");
    strcpy((*p)->last, "Doe");

    printf("First: %s Last:%s\n", (*p)->first, (*p)->last);

    return 0;
}

I'm still using only one malloc even though there is now another pointer.

In this third version, I'll use Person ***p

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    typedef struct {
        char first[10];
        char last[10];
    } Person;

    Person ***p;

    *p = malloc(sizeof(void));
    **p = malloc(sizeof(Person));
    strcpy((**p)->first, "John");
    strcpy((**p)->last, "Doe");

    printf("First: %s Last:%s\n", (**p)->first, (**p)->last);

    return 0;
}

My questions:

1) Why do I need to malloc space for **p in the 3rd version, but I don't need to malloc space for *p? They are both pointers to pointers?

2) Also, why don't I need to malloc space for p in either the 2nd or 3rd version?

3) In the third version, what is the right size to malloc for *p? On my 64 bit Mac the sizeof(void) is 1, and the sizeof(void*) is 8, and both seem to work but what is the right one?

Recompile with warnings enabled and you will find a few problems with your code. — August Karlstrom, Dec 26 '15 at 11:19
You don't understand pointers. Do yourself a favor and *learn*. — Amit, Dec 26 '15 at 11:22
the right one is void*. void* is a pointer which means its size is enough to contain every memory address in your 64 bit computer. It could be smaller if your computer was using a 32bit system. Also Amit is right, your second version is wrong and you need to allocate memory for the first pointer (p). If you compile with warning flags (-Wall -Wextra) you'll get this : `warning: ‘p’ is used uninitialized in this function [-Wuninitialized] *p = malloc(sizeof(Person));` — loginn, Dec 26 '15 at 11:24
I turned on the warnings and see what you are saying. So for v3, is the right thing to do `p = malloc(sizeof(void*)); *p = malloc(sizeof(void*)); **p = malloc(sizeof(Person));` or is there a better way to do it? — Idr, Dec 26 '15 at 11:32
@Idr That's correct. Although it would be even better to use `malloc(sizeof(Person*));` instead of `malloc(sizeof(void*));`since you already know the type you're going to use. It doesn't change anything computer wise but makes the code clearer. — loginn, Dec 26 '15 at 11:36
@ldr trial and error is not a good way to learn C, you can't tell whether your code is correct, or if it is broken but happening to produce the correct output this time — M.M, Dec 26 '15 at 22:18
`*p = malloc(sizeof(void));` should fail to compile, you meant `sizeof (Person*)` or more simply `sizeof **p` — M.M, Dec 26 '15 at 22:19

alk · Accepted Answer · 2015-12-26T21:46:42.767

Dereferencing a pointer (*p) which had not been initialised provokes undefined behaviour in any case.
When allocating space to a pointer you mostly ever want to allocate to it memory with the size of what is it pointing to by typically using the sizeof operator. This latter case is the one and only exception to 1. that allows coding *p.

So the 3rd example could look like this

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
        char first[10];
        char last[10];
} Person;

int main(void) {
    Person ***p;

    p = malloc(sizeof *p); 
    *p = malloc(sizeof **p);
    **p = malloc(sizeof ***p);
    strcpy((**p)->first, "John");
    strcpy((**p)->last, "Doe");

    printf("First: %s Last:%s\n", (**p)->first, (**p)->last);

    free(**p);
    free(*p);
    free(p);

    return 0;
}

Really great demonstration of pointer-to-pointer-to-p... Thanks! — ProfNandaa, Jan 28 '20 at 17:16

score 5 · Answer 2 · edited Dec 26 '15 at 13:25

I'm just going to put this here to summarize :

1) You do need to allocate space for *p. If you run your second program with valgrind, you'll see an error for alloc size (1 instead of 8); *p is a pointer to pointer, but **p isn't, it's a pointer to a structure.

2) You do need to allocate space in both cases and if you turn on the warnings (which you should never turn off anyway), you'll get this warning :

warning: ‘p’ is used uninitialized in this function [-Wuninitialized] *p = malloc(sizeof(Person));

3) The right one is void*. void* is a pointer which means its size is enough to contain every memory address in your 64 bit computer. It could be smaller if your computer was using a 32bit system. Although it would be even better to use

malloc(sizeof(Person*)); instead of malloc(sizeof(void*));

Since you already know the type you're going to use. It doesn't change anything computer wise but makes the code clearer.

malloc and pointers to pointers

2 Answers2