Thank you guys. Problem solved :-).
"syang8" <syang8@gmail.com> wrote:
hi, Alf, sandy and Robbie,
The suggestions that you gave to me is really helpful. Now I have a
better understanding of local variables and stacks. However, I still
have a problem. I don't know exactly what the size of the array should
be. Therefore, "N" is designed as a parameter in the function call as
fuction(int N, ...)
{
int big_array[N];
}
I cannot change the array to be static. Maybe a good way is to
allocated the array dynamically, any other suggestions?
Yes. I have 3 suggestions for you, in descending order of
advisibility:
Suggestion #1 (the "C++" way):
Use "std::vector".
If you want the vector to still exist between calls to the function
in which it is declared, then you'll have to declare it "static":
#include <vector>
class MyClass {/* stuff */};
MyClass& MyFunction(int ContainerSize)
{
static std::vector<MyClass> MyContainer (ContainerSize);
// ... a bunch of code ...
return MyContainer;
} // MyContainer still exists at this point.
But if MyContainer doesn't need to exist between calls to
your function, then you can leave off the "static":
#include <vector>
class MyClass {/* stuff */};
int MyFunction(int ContainerSize)
{
std::vector<MyClass> MyContainer (ContainerSize);
// ... a bunch of code ...
return 0;
} // MyContainer dies here.
Suggestion #2 (a more-dangerous "C++" way):
Use "new[]" and "delete[]".
This is dangerous. Memory leaks can result if you "new[]" some
memory and forget to "delete[]" it, and program crashes can
result if you "delete[]" some memory which you didn't "new[]".
But on the other hand, it is a very flexible way of handling
memory.
// Make a dynamic array of MyClass objects:
MyClass* Ptr = new MyClass[ContainerSize];
// Assign stuff to the memory you now own:
Ptr[3756] = Whatever;
// Free-up the memory, later:
delete[] Ptr;
Suggestion #3 (the "C" way):
Dynamically allocate a block of raw memory using malloc().
When you're done with it, free it using free().
Warning: this is VERY dangerous. If you do it wrong, you'll
cause bugs, memory leaks, system crashes, etc.
But it's conceptually the simplest, lowest-level way of handling
memory, so it's alluring because of that:
// Get memory block to hold N copies of MyClass:
MyClass* Ptr = (MyClass*)malloc(ContainerSize * sizeof(MyClass));
// Assign stuff to the memory you now own:
Ptr[3756] = Whatever;
// Free-up the memory, later:
free(Ptr);
--
Cheers,
Robbie Hatley
Tustin, CA, USA
lonewolfintj at pacbell dot net
(put "[usenet]" in subject to bypass spam filter)
http://home.pacbell.net/earnur/