c - Malloc of arrays and structs within a struct -

How is a structure that is inside a different structure?

I would also like to malloc an array of objects inside a straight and then when needed, bring this array back, how is it done properly?

Can you please give an example of declaring a straight and then the above version.

I'm a little uncertain about the order of things.

Will the array inside a straight line be freed and then the structure itself should be structured, should the structure be made malkod and its fields should be declared maloccoded / declared? /

a struct The second is included in struct , so you do not have to silk it separately if there is an indicator on struct on any other struct So you can consider dynamically allocation of memory on it.

  struct point 2d {float x; Float Y; }; Structure rect {structure point 2Da; Structure point 2DB; }; Struct LinkedListNode {struct LinkedListNode * Next; Intestine value; }; In   
 the format is inserted in the form rect ,  struct point2d  element  struct rect  and you do not do it Dynamically assigning memory to them is referred to by an indicator on the contrary in  struct LinkedListNode  and memory should be dynamically allocated to me.  
 Both versions are useful on the basis of status, both. There is no right way to manage memory, it will depend on your usage.  
 In the case of an array, this is the same condition, either your arrays are shaped steady, and then it can be either directly in the  struct  You may be included or its size may vary, in this case you have to store in the indicator in the  struct .  
  straight headers {core magic [4]; Unsigned full width; Unsigned intense height; }; Structure buffer {char * data; Unsigned full size; Unsigned int capacity; }; Structure buffer * buffer_init () {struct buffer * buffer = (strip buffer *) molk (form (buffer structured)); Buffer- & gt; Data = 0; Buffer-> size = 0; Buffer-> capacity = 0; } Void buffer_grow (struct buffer * buffer, size_ty capacity) {if (capacity> buffer-> capacity) {buffer-> data = reel (buffer-> data, capacity); Buffer-> capacity = capacity; }} Zero buffer _append (structure buffer * buffer, const char * data, unsigned int transaction) {if (data lane + buffer-> size> buffer-> capacity) buffer_griv (max (data LAN + buffer-> size, Buffer -> capacity * 2)); Memcpy (buffer-> data + buffer-> size, data, data-LAN); Buffer-> size + = data lane; }   
  the realloc  function creates only a shallow copy, which indicates that the price is copied, but the pointing object is not. Once again, how will you deal with it will depend on your application.