Allocation of memory for char array

Don't assume that the memory storing the pointer for name is the same as the memory storing the data for name. Assuming a 4 byte word size, you have the following:

• char * (4 bytes)
• int (4 bytes)
• int (4 bytes)
• int (4 bytes)
• ================
• total: 16 bytes

which is: sizeof(char*) + sizeof(int) + sizeof(int) + sizeof(int). C knows the size because you've told it the size of the elements in the struct definition.

I think what you are confused about is the following:

The contents at the char * will be a memory location (e.g. 0x00ffbe532) which is where the actual string will be stored. Don't assume that the struct contents are contiguous (because of the pointer). In fact, you can be pretty sure that they won't be.

So, to reiterate, for an example struct Person (this is just an example, the locations won't be the same in a real program.)

• location : [contents]
• 0x0000 : [0x00ffbe532]
• 0x0004 : [10]
• 0x0008 : [3]

• 0x000C : [25]

• 0x00ffbe532 : [I am a string\0]

The name member is just a pointer. The size of a pointer varies with the underlying architecture, but is usually 4 or 8 bytes nowadays.

The data that name can point to (if assigned later) should be laid out in an area that does not coincide with the struct at all.

At the language level, the struct doesn't know anything about the memory that the name member is pointing to; you have to manage that manually.

It allocates memory for the just the pointer to a char. You need to do a separate allocation for the contents.

There are other options although:

If you are OK with having a fixed sized maximum length, you can do:

struct Person {
    char name[PERSON_NAME_MAX_LENGTH+1];
    int age;
    int height;
    int weight; 
 };

And allocate it as in your example.

Or you can declare a variable sized struct, but I wouldn't recommend this as it is tricky and you cannot have more than one variable size array per struct:

struct Person {
    int age;
    int height;
    int weight; 
    char name[]; /*this must go at the end*/
 };

and then allocate it like:

struct Person *who = malloc(sizeof(struct Person) + sizeof(char)*(name_length+1));

It will allocate 4 bytes for the name pointer, but no space for the "real" string. If you try to write there you will seg fault; you need to malloc (and free) it separately.

Using string (in C++) can save you some headache

For pointers the struct is allocated enough memory just for the pointer. You have to create the memory for the char* and assign the value to the struct. Assuming you had char* name somewhere:

struct Person *who = malloc(sizeof(struct Person));
who->name = malloc((strlen(name)+1) * sizeof(char));
strcpy(who->name, name)

It doesn't. You have to do that too.

struct Person *who = malloc(sizeof(struct Person));
who->name = malloc(sizeof(char) * 16); /* for a 15+1 character array */

You have a pointer to a name character array in your struct, ie. it will consume that much bytes that are needed to represent a memory address.

If you want to actually use the field, you must allocate additional memory for it.

Pointer members occupy one word in my experience (the address on witch the data actually resides) so the size will probably be 16 bytes (assuming one word is 4 bytes)

As the man said above you need to separately allocate memory for *name witch will free memory someplace else for the size you desire

I think you should also need to allocate memory for the name attribute