Multi-dimensional arrays using variables

Hi all

I'm wondering if it's possible to define a mutli-dimensional array using variables, such as the following:

Code:

int CustomCheckersBoard[a][b];

It doesn't seem anything usual but C++ seems to refuse to accept anything except constant integers when it comes to multi-dimensional arrays. It won't even accept a and b if they're constants.

Any suggestions about how I might get round this? The context, as you may have guessed, is to allow the user to define the size of a custom checkers board.

Cheers :-)

it will accept it if they're static const or #defined.

otherwise, you have to implement it as a linked list.

The compiler has to be told how large this array, memory to set aside, has to be, so any variables you implement must have an initialized variable of a given size.

Originally Posted by Know_Your_Role

Any suggestions about how I might get round this? The context, as you may have guessed, is to allow the user to define the size of a custom checkers board.

If by user you mean a programmer using your checkerboard library, then you could go with something like this:

Code:

#include <cstddef>

template<std::size_t N, std::size_t M>
class Checkerboard
{
public:
    // ...

private:
    int board[N][M];
};

// ...

int main()
{
    Checkerboard<8, 8> customCheckersBoard;
    // ...
}

But if by user you mean a user of your program, then you might consider using a std::vector<std::vector<int> > or Boost.MultiArray.

You would do well to avoid sufoode's advice since sufoode cannot even demonstrate a 2D dynamic array correctly

the stl isn't a separate library.

Originally Posted by sufoode

take laserlight's advice and go download a whole seperate library just to use dynamic arrays

Indeed you should, if you are interested in the memory savings available over a std::vector of std::vectors. That said, another possibility is to just implement it yourself using a single std::vector<int>... but it also means writing more code when you can just use an existing library.

@ OP:

consider the following:

Code:

  const unsigned int size = 8;
  int s = 4;  
  const unsigned int size2 = s;
  int arr[size]; // ok
  int arr2[size2]; // compile time error

do you understand the difference?

Originally Posted by sufoode

how about just declare a giant array like [1024][1024].

now the user can sepecify the width and height. problem solved.

That would be a good solution, except for the potential problem of the giant array being too large to fit into the given memory, e.g., on the stack, or possibly being too small for the desired custom checkerboard. Even if you find the right balance, there would likely be space wastage.

both of those are really terrible solutions imo.

i don't share the memory-management-phobia of many on here, but really, suggesting overallocation and/or fileio is just a bad idea.

Originally Posted by sufoode

The array can be stored on disk and you can seek to file positions to retrieve a value.

I think that that would defeat the purpose of your suggestion to use a giant array: code would have to be written to implement this functionality, upon which one might as well just use my std::vector<int> suggestion, which is likely to be considerably more efficient anyway.

This all depends on the amount of memory to consume. Vectors, IMO, will be the best solution, up to the point when excessive reallocation of memory is called for against the vector.

Originally Posted by slingerland3g

Vectors, IMO, will be the best solution, up to the point when excessive reallocation of memory is called for against the vector.

Making a guess at the problem domain, I suspect that reallocation is not necessary: once the user has decided on the size, the size of a checkerboard should be fixed.

Originally Posted by laserlight

Making a guess at the problem domain, I suspect that reallocation is not necessary: once the user has decided on the size, the size of a checkerboard should be fixed.

I think we covered how to dynamically address their memory usage for the array, the tougher question, that plagues everyone, is what amount of memory is optimal to use for a particular aspect of code. ( No silver bullet there!)