C编程，使用内存

Question

I have a main function and it has global array

unsigned int    MainArray [800];

then the program calls function which has local

unsigned int    FunctionArray [400];

and I have not enough space in memory.

However the MainArray is not used while the function is called and inside data is not important, also FunctionArray is not required after function is used.

Is any way how FunctionArray can be declared over same memory allocation that the MainArray uses? When I declare MainArray [800]; inside main then later on other functions can't access the data.

Answer 1

If you declare a variable inside main() , this doesn't make it a global variable, it's a variable local to main() . Unless you pass a pointer to it around, other functions can't access it.

You seem to ask for a global array. Just declare it outside main() and every function can access it.

Global variables, however, should be carefully considered since they vulnerate the rule of information hiding/encapsulation (that may be the reason nobody taught you they exist), nevertheless there are sometimes good reasons to use them (especially on devices where memory is a scarce resource which seems to be the case for you).

Answer 2

If you want the data from the mainArray on the later state of the program, ie, after the execution of the function , then, you can't say the "data of the mainArray is not important while the function is called" because it's important afterwards.

If you are thinking of a way for "FunctionArray can be declared over same memory allocation that the MainArray uses", then even if there WOULD HAVE BEEN a way, the data of mainArray would have been destroyed which you will be needing in later program as you said.

If you don't need the data of main in later state, you can do one thing,

define the array as a pointer outside the main() ,

unsigned int * MainArray;

then allocate it dynamically with required size in main() . When the need of the array is finished, just free the memory. The space will be available for farther allocations.

If you need the mainArray after the execution of the function having the functionArray ,and not before; just allocate the memory for the mainArray after the function has been executed. and use the local functionArray as the pointer as well, in the function and free the memory before the control gets back from the function. This way your program doesn't occupy the space for the mainArray while executing that function, and when the function is done executing, functionArray is not occupying any space.

But if you need mainArray, both before and after the function execution, I think there is no way you could solve the memory problem..

Answer 3

you can use the arrays base pointer to access the array's memory space in other functions.
you declare a array

unsigned int    MainArray [800];

Then if you pass MainArray as parameter to function and receive it as,

returnType somefunction(unsigned int   * FunctionArray, ...)
{

}

Then you can use the same memory in both main function and array. but in function make sure that you access FunctionArray only within its size limit of 400. This will enable you to access same memory in both functions as array.
You can even allocate memory to arrays dynamically, if they are needed in program in sequence and not at same time. you can use malloc or alloca .