Dynamic 2D array allocation

[grumpymonkey]

I'm workin on a class which uses 2D arrays for storing information, but I need to be able to change the size of the arrays during runtime. for example:
this is my array of size 0:

Code: Select all

numbers[0][0];

then lets say I wanted to add 1 slot to index 0, and 1 slot at index 1:

Code: Select all

numbers[0][1]=5;
numbers[1][1]=10;

how would I be able to do that? I tried creating the arrays before like this:

Code: Select all

int numbers[10][10];

which gives me a maximum of 10x10, but idk if I will have to add more, and not to mention the risk of stack overflow

[Dorth]

Oy, std::vector or any similar vector class. Else, do the same, make your class, allocate and deallocate memory all the time while copying stuff around and hope to do it as efficiently as a vector.

[grumpymonkey]

well how would I use an std vector, or allocate/deallocate the array?

[vitek]

If you really had to do it, you'd do something like this...

Code: Select all

std::vector< std::vector<int> > v;

v.resize(10);
for (size_t i = 0; i < 10; ++i)
  v [i].resize (10);

But I wouldn't do it. I suggest you read this and this and then reconsider.

Travis

[grumpymonkey]

oh I already solved this after like the first post. I used an array of arrays

Code: Select all

array<array<std::string>> Strings;

[Dark_Kilauea]

One thing you need to note. Using an std::vector (or equivalent like irrlicht's array) for 2d dynamic arrays is a mistake. A vector cannot handle its contents resizing themselves. You need to use an std::deque or pass pointers to the second dimension of arrays to the first level.

For example:

Code: Select all

std::deque< std::vector<int> > my2Darray; //Works
std::vector< std::vector<int> > my2Darray; //Will fail if the 2nd dimension is resized
std::deque< std::deque< int > > my2Darray; //Also works
std::vector< std::vector< int >* > my2Darray; //Should work as well 

I learned this lesson the hard way, the bugs this causes have symptoms that are not very obvious.

[JP]

tbh all that reallocation is probably a really bad idea. could you not just allocate a 2d array of sufficient size at the start and then use as much of it as you need at each stage? You shouldn't really need to be resizing it I wouldn't think...

and obviously don't create a 2d array of like 1024x1024 or something just because you're not sure how big it might need to be. put realistic limitations on your application as memory don't come fo' free!

[Halifax]

JP is correct. What are you exactly doing anyways?

If I were to do this, why not just dynamically allocate a 1D array (one allocation) and use it as a 2D array by operator overloading? Rather than doing 1024 allocations of such small sizes. That will really fragment your heap.

[grumpymonkey]

allocating the array before will take up a lot of memory and will cause a stack overflow error

@Dark_Kilauea
interesting, I never knew about an std::deque, I'll look it up.

btw, im using it like this:

Code: Select all

array<array<int>*> data

[Halifax]

allocating the array before will take up a lot of memory and will cause a stack overflow error

Well if definitely shouldn't be overflowing the stack since you are allocating on the heap...

[Dorth]

You can not only redefine a vector contained in another vector, if you do it "right", it should be transparent to the user. The head of a std vector is normally only a pointer. That is what is contained in the first vector. If you resize from there, it will work fine. Just don't carry pointers around when you resize memory, it's always a dangerous game.