Printable View
I was wondering if it was possible to change (add or subtract) the elements in a multi-dimensional array, without using the new tag. I also can't change the array's name.
For example, I want to change:
to something like:Code:int array[10][10]
Or:Code:int array[13][12]
Code:int array [2][7]
Once an array is created you can't change it's size. What you can do however is use a vector which will grow and shrink as you need
You'll have to grab some more memory from somewhere if one or both of the array bounds are increasing. Using new (or malloc/realloc/calloc) is the only way I know to do this.
expanding on what pianorain just said, consider using pointers. in C++, you can declare a pointer to an array, and then deallocate that array and reallocate a bigger or smaller array. for example, consider this code and tailor it to your needs:Code:#include<iostream>
int main()
{
int*arr; //an integer pointer
int count; //the amount of integers
do
{
std::cout<<"Enter the amount of values: ";
std::cin>>count;
std::cout<<"Enter the values:\n";
arr=new int[count]; //create (allocate) a new array of size count
for(int i=0;i<count;++i) //loop through the entire array
{
std::cout<<"> "; //prompt for input
std::cin>>arr[i]; //recieve input
}
for(int i=0;arr[i];++i) //loop through the actual array
std::cout<<arr[i]<<", "; //output everything in the array
std::cout<<std::endl; //nice formatting
delete[]arr; //deallocate the memory for the array
}while(count>0);
return 0;
}
So, how would that work with a multi-dimensional array? When I tried, I got a compiler error.
I have it declared like:Code:cannot convert `TILE (*)[((rows - 1) + 1)]' to `TILE*' in assignment
What is it that I'm doing wrong.Code:typedef struct TILE
{
int tile;
int collision;
}TILE;
int columns = 25; // Number Of Columns
int rows = 19; // Number Of Rows
TILE *map; // The Map
map = new TILE[columns][rows];
(all that junk in main...)
delete []map;
map = new TILE[columns][rows];
you are assining a 2 dimensional array to a one dimensional one.
declare map as:
TILE *map[];
Here's a quick, untested, schema to change size of an array dynamically. Considering all the places where mishaps can occur, you should do something like this only if you don't know how or aren't allowed to use containers in STL.
Code://declare map
Tile** map;
//declare memory for map
map = new Tile*[rows];
for(i = 0; i < rows; ++i)
map[i] = new Tile[columns];
//fill map here
//decide to expand maps size here
//declare tempMap to hold contents of map pending changes in map.
Tile ** tempMap;
//declare memory for tempMap as above for map. Use same rows and columns.
//copy data in map to tempMap. I use loops, but there may be other ways
for(i = 0; i < rows; ++i)
for(j = 0; j < columns; ++j)
tempMap[i][j] = map[i][j];
//delete memory in map
for(i = 0; i < rows; ++i)
delete map[i];
delete map[];
//determine new size for rows and columns of map
//declare new memory for map
map = new Tile*[newRows];
for(i = 0; i < newRows; ++i)
map[i] = new Tile[newColumns];
//copy tempMap back into map
for(i = 0; i < rows; ++i)
for(j = 0; j < columns; ++j)
map[i][j] = tempMap[i][j];
//delete memory for tempMap like above for map
NOTE: be sure that the data in the old map will fit in the size of the new map to prevent overwrite errors
What compiler are you using?Quote:
Originally Posted by Raven Arkadon
oops...
that only works with pointers to fixed size arrays.. :D
e.g.
TILE (*blah)[5] = new TILE[4][5];
sry
Thank you so very much. It's working now. However, I'm curious to know whyQuote:
Originally Posted by elad
has two asterisks (*) in it. I know that it needs them, but why.Code:TILE **map;
Well, it's a pointer to a pointer. Since depending on what a pointer points to, it can be used as an array, in this case both pointer-levels act as arrays, so it's an array of arrays, i.e. a 2D array.
Err ok, so that doesn't make so much sense. Let me try again:
It isn't really a 2D array, but it looks and acts like one ;)Code:TILE *map; //TILE pointer called 'map'
map = new TILE[5]; //allocate an array of 5 tiles and assign to 'map'
//So now 'map' refers to a dynamic array of TILE
TILE **2Dmap; //Pointer to a TILE pointer, called '2Dmap'
2Dmap = new TILE*[10]; //Allocate an array of 10 tile pointers, assign to '2Dmap'
//So now '2Dmap' refers to a dynamic array of TILE pointers
for(int i = 0; i < 10; ++i)
2Dmap[i] = new TILE[5]; //Allocate an array of 5 tiles, assign to this element of '2Dmap'
//So now each TILE pointer in '2Dmap' refers to an array of 4 tiles.
//In other words, we have made '2Dmap' into a "2D array" of TILE.