it''s my understanding that you can only create 1 dimetion dynamic arrays, so you might have to do a things[x*y] and loop through the array by useing the y value as an offset. i could be wrong, and i hope i am because doing that way gets verry tiresome. anyway, hope that helps.

-------------------------------------------------
Don''t take life too seriously, you''''ll never get out of it alive. -Bugs Bunny

quote:

I have this declared in my class
Example:

class{

int numthingsX,numthingsY;

thing *things;
}

when I initialize this class I want to take the values inputed for the size of the array and allocate that array so it will work like this

things[x][y]

I tried a few different methods but it doesn''t seem to work the same as a 1D array....

Correct, it doesn''t work the same way as a 1D array, so you need to do it differently. When you index into a 1D array, eg things[ 3 ], the program generates the pointer to things[ 3 ] by calculating ( things + 3 ).

When you declare a 2D array statically such as:

Thing SomeThing[ 10 ][ 20 ];

The compiler knows how wide the array is, so when you try to index into the array, ie access a particular element, to something with that element eg

  for( x=0 ; x< 10 ; x++ ){    for( y=0 ; y<20 ; y++ )    {       SomeThing[ x ][ y ].DoSomething();    }}  

The compiler knows to translate the SomeThing[ x ][ y ] into SomeThing[ x * 20 + y ] into ( SomeThing + x*20 + y ), to generate the correct pointer for the element you''re trying to access.

When you declare a dynamic 2d array, the compiler has _no idea_ how wide your array is going to be so it can''t use this method to calculate the correct pointer when you try to index into the array.

What you have to do is declare an array of pointers to pointers to create the array dynamically, which is not as scary as it sounds ;-).


class{

int numthingsX,numthingsY;

Thing **m_Thing;
}

Okay so m_Thing is a pointer to an array of pointers, so in the constructor do;

m_Thing = new *Thing[ numThingsX ]; //This creates an array of pointers.

for( x=0 ; x{
m_Thing[ x ] = new Thing[ numThingsY ];
}

//This creates numThingsX 1D arrays of ''Thing'' and stores the pointer to each 1D array in the correct entry in m_Thing[].

Your program can calculate the pointer correctly, such as

m_Thing[ x ][ y ]

pointer to array of pointers = m_Thing
pointer to array of things = m_Thing + x
pointer to thing (x, y ) = pointer to array of things + y

Hope that helps, (and makes sense).

cheers
Dan

ps That is how you new an array of pointers (new *Thing[ numThingsX ]) isn''t it ? I''m in an Internet cafe and can''t double-check....





Game production:
Good, quick, cheap: Choose two.