How to define a static array without a contant size in a constructor of a class? (C++)

Question

I have a class defined as:

class Obj {
public:
    int width, height;
    Obj(int w, int h);
}

and I need it to contain a static array like so:

int presc[width][height];

however, I cannot define within the class, so it it possible to create a pointer to a 2D array (and, out of curiosity, 3, 4, and 5D arrays), have that as a member of the class, and intitalize it in the constructor like:

int ar[5][6];
Obj o(5, 6, &ar);

EDIT: The idea here is that every object will have a different width and height, so the array I use to represent that object will be unique to the object, but once that array is defined (preferably in the constructor), it will not change. And the values of width and height for a particular object are known at compile time.

EDIT: The arrays are for collision detection by superimposing the presc arrays of two objects onto one large array, and seeing where the overlap, declarations like so:

Obj player1(32, 32); //player with a width of 32 px and height of 32 px, presc[32][32]
Obj boss(500, 500); //boss with a width of 500 px and height of 500 px, presc[500][500]

Answer 1

If, by "dynamic", you mean "heap-allocated", then no, there is no way to this with the current Obj. OTOH, if you know w and h at compile time:

template <int W, int H>
class Obj {
public:
    // ...
private:
    int presc[W][H];
}

Answer 2

No. The size of the class needs to be known at compile time.

If you don't know the size of the array until run time, you can't have that array as a class member (you'll need to dynamically allocate the array and store a pointer to it in the class or, preferably, use a std::vector).

Answer 3

boost::array and std::tr1::array both provide constant-size arrays. Understand that these create whole new types; not using a dynamic array will probably make a lot of your code harder to write than it needs to be. You'll have to parameterize your class, as well as any functions that work on these objects. And all you'll be saving is a single heap allocation.