declaring large array

Hi I'm fairly new to programming so excuse me if the problem is unclear or if I haven't provided enough info.

I am running windows vista, I have 2gb memory. I'm compiling in dev c++, which uses g++ compiler.

Code:

#define MAX_DSIZE 6000

struct entry
{
   // length of entry
   int points;

   // float to hold wavelength, flux and error
   float wl[MAX_DSIZE];          
   float flux[MAX_DSIZE];  
   float error[MAX_DSIZE];             
};

int main ()
{
   int num_files=450;
   struct entry tdata[num_files];
}

It compiles fine but when I run it I get a windows error
"new2.exe has stopped working..."

It works for num_files <= 27 so I guess it is some kind of memory problem.

Anyone know how I can fix this?

Thanks

Jase
"

You need to use dynamic memory, ie new and delete.
And in C++, we use const instead of define and we skip the "struct" keyword.
Unless you actually posted in the wrong section?

You're trying to declare about 31MB on the stack and the default stack size is 1MB, which is more than enough for basically everything that is written properly.

You can't declare an array based on the value of a variable in C++. It either has to be const or this is actually C code.
Judging by the extra struct keyword, this is C code.
In C++ we'd allocate on the heap like this:

Code:

entry *tdata = new entry[num_files];

and later clean it up with this:

Code:

delete[] tdata;

I'm writing c really but I use c++ compiler.

so I have 31mb of data in ~500 files on the hard drive and they need to be accessed 100s of times.

so is allocating on the heap is the best way? (I don't really understand heap and stack fully but if it is best way I will read up)

Thanks for help,

Jason

Yes allocating these on the heap is the best way.
The stack is really only for variables that have a short lifetime (the life of the function) and are reasonably small.

In this case, it's better to use malloc and free, then. The C way.
The "struct" keyword is necessary in C, and so is the define, so it's best to keep it that way.
Suffice to say about stack vs heap:

Stack:
- Limited to about ~1 MB.
- Cleans up automatically after function ends.
- Faster to allocate on.

Heap:
- Limited to a hard-coded limit of 2/3 GB depending on OS (that which don't fit in memory goes into the page file).
- Does not clean automatically. Data will be there as long as you need it.
- Need to be freed or you will get a memory leak.
- Slower to allocate on.

If you have a huge local variable in main, it almost sounds like it should be a static/global variable.

Also, can I make another suggestion:
Instead of three arrays in a struct, you probably should have a second struct that holds the three values, and make that into an array. Whether this is good or not depends quite a bit on how you use the values, but I'm sort of guessing that you will access wl, flux and error for each index, rather than all wl then all flux then all error. If my guess is right, then a struct within the struct would be the right thing to do, because the access of the second and third value will be "almost free", as opposed to reading the data from three different places in memory.

--
Mats

Thanks for the advice and suggestions.

I got it working using malloc like so:

Code:

#define MAX_DSIZE 6000

struct entry
{
   // length of entry
   int points;

   // float to hold wavelength, flux and error
   float wl[MAX_DSIZE];          
   float flux[MAX_DSIZE];  
   float error[MAX_DSIZE];          
   
};

int main ( int argc, char *argv[] )
{   
   int i;
   struct entry *tdata[439];
   for (i=0 ; i<439 ; i++)
   {
      if ( (tdata[i] = (entry *) malloc(sizeof(entry))) == NULL )
      {
         fprintf(stderr, "\nOut of memory");
         exit(1);
      }
   }
   
   return 0;
}

Don't forget to free all that memory later!

is there a reason you need it to be in all C?

this seems like it could be a lot cleaner in C++.

Code:

class entry
{
   public:
   // length of entry
   unsigned int points;

   // float to hold wavelength, flux and error
   float *wl;          
   float *flux;  
   float *error;          
   entry():
      wl(new float(6000)),
      flux(new float(6000)),
      error(new float(6000))
   {
   }
   ~entry()
   {
      delete[] wl;
      delete[] flux;
      delete[] error;
   }
};

int main ( int argc, char *argv[] )
{
   
   try
   {
      entry *tdata = new entry[439];
   }
   catch(...)
   {
         fprintf(stderr, "\nOut of memory");
         exit(1);         
   }
   
   return 0;
}

Everything is always better and cleaner in C++. That's because C++ was designed to be an extension of C.

A note from GotW #66: Constructor Failures concerning m37h0d's example:

Moral #3: Always perform unmanaged resource acquisition in the constructor body, never in initializer lists. In other words, either use "resource acquisition is initialization" (thereby avoiding unmanaged resources entirely) or else perform the resource acquisition in the constructor body.

Moral #4: Always clean up unmanaged resource acquisition in local try-block handlers within the constructor or destructor body, never in constructor or destructor function-try-block handlers.

Incidentally, the exception to catch is std::bad_alloc.

so any allocations using new should be inside the constructor block, wrapped in the try statement?

so any allocations using new should be inside the constructor block, wrapped in the try statement?

Yes, if there is more than one of them, but you might as well be consistent.

i see. i got quipped for not using initialization lists before, and was pointed to a ref that said (more or less) to always use initialization lists. obviously if you needed to use exception handling, you'd need to make the declarations in the constructor block.

i don't mean to hijack the thread, but can you tell me what is meant by "unmanaged resource"? i am assuming this is anything that is not automatically allocated or deallocated by the default constructor/destructors? is this correct?

thanks