Re: Dynamic array advice.
John Harrison wrote:
JoeC wrote:
I am crating a new version of my map game and my map will be a 2d
array. I had problems trying to create a 2d array dynamically, in
fact C++ won't let me do it. My question is how to create the size of
array I need at run time without using too much memory or going over
the allotted size if I choose to use this object for a different
game.
One idea I have is to create space * spaces = new space[len*with];
then have all my accessors just convert x and y to:
void place(int x, int y){spaces[x*len+y;}
You might want to put that into a class with an overloaded operator():
int & operator( std::size_t row, std::size_t col ) {
return ( the_data [ col_size * row + col ] );
}
and you could add a const version too:
int const & operator( std::size_t row, std::size_t col ) const {
return ( the_data [ col_size * row + col ] );
}
You also might make the member the_data a std::vector<int>. In that case,
you would not even have to take care of your own assignment operator, copy
constructor and destructor. E.g:. [code not tested/compiled]
template <typename T>
class array2d {
std::size_t the_row_size;
std::size_t the_col_size;
std::vector<T> the_data;
public:
array2d ( std::size_t r, std::size_t c, T const & val = T() )
: the_row_size ( r )
, the_col_size ( c )
, the_data ( the_row_size * the_col_size, val )
{}
T & operator( std::size_t row, std::size_t col ) {
return ( the_data [ the_col_size * row + col ] );
}
T const & operator( std::size_t row, std::size_t col ) const {
return ( the_data [ the_col_size * row + col ] );
}
std::size_t row_size ( void ) const {
return ( the_row_size );
}
std::size_t col_size ( void ) const {
return ( the_col_size );
}
};
That would work. There are other lots of other approaches.
The classic is (and simplest) to use double pointers
space** spaces = new space*[width];
for (int i = 0; i < width; ++i)
spaces[i] = new space[length];
then you can just say
space[i][j] = whatever;
and when you want to free the memory, do the reverse
for (int i = 0; i < width; ++i)
delete[] spaces[i];
delete[] spaces;
I doubt that this is the _simplest_ approach. Once you want an exception
safe version, you will find that it is not that simple at all. Any new in
the for-loop might throw. In order not to leak, you need to keep track of
that and delete the previously allocated rows. The idea of the OP is much
easier to implement properly.
Best
Kai-Uwe Bux