Question

In C++, I have an Object class, from which a number of other classes inherit (ie Ball, Paddle, and Wall). Is there a way to have a static member on the Object class that gets inherited as separate static members by each subclass?

Basically, I want Ball, Paddle, and Wall to each have a static member (used to store images for drawing) that they inherited from Object (since an array to store images is a common requirement across all objects), but the static members are separate for each of Ball, Paddle, and Wall. That way every Ball instance has access to the ball images, every Paddle has access to the paddle images, and so on.

If this isn’t possible, what would be a good way to allow similar functionality?

EDIT:

Some more detail on what I’m actually trying to accomplish:

I’m working on a Breakout Clone. I have an Object class, from which all game objects inherit (Ball, Paddle, Block, and Wall). All of these objects have a handful of images that they need access to in order to draw themselves (which is done by Object* to all objects in a std::list and running the virtual method updateAndDraw() on all of them).

Right now, Ball, Paddle, Block, and Wall each have a static sf::Texture (from SFML) array that stores all the images the object would need. It’s static because all instances of each class can share the images, and it would be a waste of memory to load them separately for each instance. The images are loaded and stored in the array the first time each of the respective game objects are constructed.

The image loading and storing functionality is basically the same for all the game objects, so I wanted to move it off of each individual game object and on to Object. My plan was to have a static member on Object that each game object will inherit, and this static member will be independent for each of Ball, Paddle, Block, and Wall, although it’s looking now like this might not work. I would also have a static method on Object called loadImages(string filenames[]), that would take an array of image filenames and load the images into the static image array for the game object that loadImages() was called on. So in the Ball constructor, if I ran loadImages() and passed it some filenames, it would load the images into the static image array for Ball, and the same (independently) for all the other game objects.

After typing this all up, I’m realizing that it might be better to store the images somewhere else, and just give the game objects pointers to those images. This eliminates the need for the images array to be static, and in the constructor I can just call a function on whatever is storing the images and pass it the object type, and it’ll hand me an array of pointers to the images that game object would need.

Answer 1

No is not possible. You can however redeclare your static variables in each child class.

class A
{
public:
    static int MyStatic;
};

class B : public A
{
public:
    static int MyStatic;
}

class C : public A
{
public:
}

A::MyStatic is the same as C::MyStatic but B::MyStatic is different.
I still don’t understand why you should do something like this.

However, you can also use templates.

template <typename T>
struct MyStaticContainer
{
    static int MyStaticValue;
}

template <typename T>
int MyStaticContainer<T>::MyStaticValue = 0;

Then, you can access your field in this way:

MyStaticContainer<A>::MyStaticValue = 10;
MyStaticContainer<B>::MyStaticValue = 20;
MyStaticContainer<C>::MyStaticValue = 30;

These are actually 3 different static fields.