Allocating and reallocating a struct and its elements - c

Question

I have a few questions about allocating memory to structs and their members.
Suppose I have a struct like this:
struct _MyStruct
{
char *a;
}
typdef struct _MyStruct MyStruct;
I want 'a' to be a dynamic string and I want to allocate memory to it. Should I allocate memory to MyStruct too in this case? Example:
MyStruct *myStr = malloc(sizeof(MyStruct)); //necessary?
MyStruct *myStrCopy = myStr;
myStrCopy->a=malloc(sizeof(char));
//checking for null//
Now suppose I allocated an X amount of memory to the struct (myStr). Now, when I allocate memory to 'a', is the memory allocated within the memory allocated to myStr, or does it get a new block of memory?
Can I allocate more memory to 'a' than I allocated to myStr?
Suppose I want to enlarge 'a' with realloc(). Should I enlarge myStr first? If I do, then by what amount of memory (sizeof(myStr)*size_of_my_string)?

Answer 1

I want 'a' to be a dynamic string and I want to allocate memory to it. Should I allocate memory to MyStruct too in this case?
Well, your MyStruct always needs to exist, but there are several ways to do this and you should go for the simplest one that fits your use case.
Basic approach:
MyStruct myStr;
myStr.a = malloc(N); // "N chars please!"
// You can still get a pointer to this object:
foo(&myStr);
// Don't forget to free the `char` buffer later
free(myStr.a);
Dynamic allocation — valid, but not inherently necessary:
MyStruct* myStr = malloc(sizeof(MyStruct));
myStr->a = malloc(N); // "N chars please!"
// It's already a pointer, so:
foo(myStr);
// Don't forget to free the `char` buffer later
free(myStr->a);
// And then the struct
free(myStr);
Now suppose I allocated an X amount of memory to the struct (myStr). Now, when I allocate memory to 'a', is the memory allocated within the memory allocated to myStr, or does it get a new block of memory?
It's a new block.
Each block of dynamically allocated memory is entirely separate. When you made the member variable a a pointer, you ensured that although a lives within the struct, the thing it points to does not (unless you make it point to itself, lol).
myStr (or *myStr): your malloc'd memory:
0 32 0 8 16 24 32 40 ...
+----------+ +------------------------------+
| char* a——|———————————————————————→| text or whatever here |
+----------+ +------------------------------+
(somewhere in memory) (somewhere else in memory)
The above diagram is valid no matter which way you constructed myStr.
Can I allocate more memory to 'a' than I allocated to myStr?
Yeah, whatever you want. It's separate. You have indirection.
Suppose I want to enlarge 'a' with realloc(). Should I enlarge myStr first? If I do, then by what amount of memory (sizeof(myStr)*size_of_my_string)?
No.

Answer 2

Just for clarification:
myStr and
a are just pointer to some memory location. This does not mean they are sharing the same memory location.
So allocating either myStr or a is not growing the variable it self.
It requests new memory somewhere in the virtual memory space of the process and stores the address in the corresponding pointer..
So to answer you question: Yes you can allocate a memory for a which is larger than myStr.
Update for better illustration:
0x000 | 0x004 | 0x008 | 0x0012 | 0x0016
^ ^
| |
myStr a
So myStr could be located in memory somewhere completly different compared to a.

Answer 3

Not needed to allocate for structure.Just for char* is enough. Say
MyStruct str;
str.a = malloc( sizeof(char)*10);
str will be in stack. Memory pointed by 'a' will be in heap. So when str goes out of scope, the object will be destructed. But not the dynamically allocated one which is pointed by 'a'. We have delete it manually.
The size of structure will be same won't vary with the size of dynamic memory pointed by 'a'.
Just reallocate the memory pointed by 'a'.
str.a = realloc(a, sizeof(char)*20);

Answer 4

First case
MyStruct *myStr = malloc(sizeof(MyStruct)); //necessary?
yes, very much. Without the allocation to myStr first, trying to dereference myStr (to reach a) is undefined behaviour.. Also, FWIW,
myStrCopy->a=malloc(sizeof(char));
allocates only memory for only one char, be sure that is what you actually want. If you really want that, in that case, you can rewrite that as
myStrCopy->a=malloc(1);
as sizeof(char) is guranteed to be 1 in C.
Every allocation through malloc() and family gives you a new memory, if successful.
You can, and you should. There is no relation actually. They are separate variables and need seperate memory allocation.
No, only realloc() on a should suffice.