I need to create an array like this
double grid [15000][40];
but the stack in Visual Studio 2012 is only of 1MB. How can I use variables like this or bigger? This mean that if I create a
std::vector<int>
and I push_back 600 000 times it goes in stack overflow? This seems a big limitation, how can be solved? Thank you in advance.
Large objects should have either static or dynamic storage duration.
Static:
int a[1000000];
void f()
{
a[3] = 12; // fine
}
Beware of shared, concurrent accesses to the static memory, though.
Dynamic (but managed properly by a suitable class):
void f()
{
std::vector<int> a(1000000); // dynamic objects managed by std::vector
a[3] = 12;
}
Here each function call will create and manage its own dynamic allocation (and the complexities of concurrency are delegated to the memory allocator, so you don't have to think about those).
There is no problem here.
This mean that if I create a std::vector and I push_back 600 000 times it goes in stack overflow? This seems a big limitation
No, because vectors elements do not have automatic storage duration (they don't "live on the stack"). They couldn't.
how can be solved
There is nothing to solve. Vector elements are dynamically allocated.
static object, but I still wouldn't.
vector<vector<double>> grid; and grid.resize(15000);, then for(i = 0; i < 15000; i++) grid[i].resize(4);.
You can define this array as
static double grid [15000][40];
As for std::vector then it allocates memory for its elements in the heap not in the stack.
memory of vector is heap allocated, you don't have to worry about the stack. Instead of doing push_back, you can use the member function resize :
std::vector<int> grid;
grid.resize(15000*40);
or even better, you can use a unique pointer if the grid has a fixed size
If you don't want to use std::vector for whatever reason, an alternative solution is:
int main()
{
int (*grid)[40] = new int[15000][40];
// work with grid
grid[0][0] = 0.0;
grid[14999][39] = 42;
delete [] grid;
}
The usual caveats apply about raw pointers to dynamic storage causing memory leaks if the scope is terminated by an exception, so that the delete never executes.
std::vectordon't live on the stack.