Question

1. It’s known that big local/global variables may cause to a stack overflow.
   I know that using pointers and allocating space in memory helps to overcome this problem.
   But is it the only option? What happens if I have (or need) too-many pointers in global scope?

2. Regarding the stack space: Is a global struct-type variable takes space in the stack, or acts like a pointer? Do I need to create a pointer of a struct variable type in order to reduce the stack load?

3. Does the following code allocates memory also to the char** variable named BIG?

   // in the header file  
   typedef struct myStruct {  
       BIG[256][256];  
       int baz;  
   } myStruct;
   
   // in the c file  
   myStruct* foo;  
   foo = (myStruct*) malloc( sizeof(*foo) ); 
   

4. How can I easily cast the return value of malloc()? In question #3 I wrote:

   foo = (myStruct*) malloc( sizeof(*foo) );

   But I prefer to write something like:

   foo = (foo) malloc( sizeof(*foo) ); // the compiler reports an error

   Which will ease the pain when editing the code (when changing the type of foo).

English isn’t my native language so sorry for any lack of clarity.

Answer 1

Neil already answered your questions, here are my comments on your 3rd and 4th questions.

Does the following code allocates memory also to the char** variable named BIG?

typdef struct myStruct {
    char BIG[256][256];
    int baz;
} myStruct;

myStruct* foo;

foo = (myStruct*) malloc( sizeof(*foo) );

(I fixed the error in BIG‘s type.) This will allocate space for BIG, although BIG is not of type char **. BIG is of type “array [256] of array [256] of char“. In value contexts, it is equivalent to “pointer to array [256] of char“.

---

How can I easily cast the return value of malloc()? In question #3 I wrote:

foo = (myStruct*) malloc( sizeof(*foo) );

But I prefer to write something like:

foo = (foo) malloc( sizeof(*foo) ); // the compiler reports an error

You’re almost correct in what you want to do, but the right way requires even less typing! The most idiomatic, easy to read, and “type-change safe” way is:

#include <stdlib.h>
foo = malloc(sizeof *foo);

Or more generally,

#include <stdlib.h>
T *foo = malloc(size * sizeof *foo);

No casts are needed, since malloc() returns void *, which can be converted to any pointer type back and forth without any loss of information. Note that this form does not use the type of foo in the malloc() call, so it is type-agnostic. Also, sizeof operator doesn’t need parentheses if it’s used on an object (but they’re needed if it’s used on a type).