C：c中分配的空闲内存

Question

suppose i have a struct:

typedef struct{
    char *ID;
    char *name;
    float price;
    int quantity;
} Generic_Properties;

now if i have used malloc to allocate space in the heap for it and saved the address in a pointer, lets call him p1 . now i want to free that specific memory block, is it enough to just declare free(p1) :

free(p1);

or do i need to separately free ID and name pointers, because I used malloc to allocated space for the string they're pointing to?

Answer 1

The rule is, malloc and free should come in pair. Free everything thing that is malloc ed exactly once.

char name[] = "some_name";
Generic_Properties *p1 = malloc(...);  /* 1 */
p1->ID = malloc(...); /* 2 */
p1->name = name;
...
...
/* free(p1->name); Don't do this, p1->name was not allocated with malloc*/
free(p1->ID);  /* 2' */
free(p1); /* 1' */
/* if(p1 && p1->name[0] == '?') {} don't dereference p1 after it is freed. It is dangling now */
...
...
/* free(p1); don't free p1 again as it is already freed and is dangling. */
p1 = NULL;
free(p1); /* OK */

Answer 2

or do i need to separately free ID and name pointers, because I used malloc to allocated space for the string they're pointing to?

As pointed out by Mohit Jain, every call to malloc must be followed by a free call, but in this case (see comments bellow) nothing prevents you to reserve space for everything in a single call:

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

typedef struct{
    char *ID;
    char *name;
    float price;
    int quantity;
} Generic_Properties;

int main(void)
{
    Generic_Properties *x = malloc(sizeof(*x) + 100);
    x->ID = (char *)(x + 1);
    x->name = x->ID + 50;

    strcpy(x->ID, "00001");
    strcpy(x->name, "David");
    printf("%s %s\n", x->ID, x->name);
    free(x);
    return 0;
}

Answer 3

A more object-oriented way of handling this sort of structure is to define functions for both allocating and freeing such structures.

(Improved version of this code)

// Allocate a GP object
Generic_Properties * create_GP()
{
    Generic_Properties *  p;

    p = malloc(sizeof(Generic_Properties));
    memset(p, 0, sizeof(*p));
    return p;
}

// Deallocate a GP object
void free_GP(Generic_Properties *p)
{
    if (p == NULL)
        return;

    free(p->ID);
    p->ID = NULL;

    free(p->name);
    p->name = NULL;

    free(p);
}

Addendum

If you want to combine this approach with @Alter Mann 's approach, you can do something like this:

// Allocate a GP object
Generic_Properties * create_GP2(const char *id, const char *name)
{
    size_t                idLen;
    size_t                nameLen;
    Generic_Properties *  p;

    // Reserve space for GP, GP.ID, and GP.name
    //  all in one malloc'd block
    idLen = strlen(id) + 1;
    nameLen = strlen(name) + 1;
    p = malloc(sizeof(Generic_Properties) + idLen + nameLen);
    memset(p, 0, sizeof(*p));

    // Save the ID
    p->ID = (char *)p + sizeof(Generic_Properties);
    memcpy(p->ID, id, idLen);

    // Save the name
    p->name = p->ID + idLen;
    memcpy(p->name, name, nameLen);
    return p;
}

// Deallocate a GP object
void free_GP2(Generic_Properties *p)
{
    free(p);
}