Thread: Making a static function which iterates every class instance

Maybe I'm too pessimistic, but I don't think a static member function will help: it operates at class level, but here you want to operate at object level, but for all objects.

Storing objects, or perhaps smart pointers to objects, in a container seems like the most viable solution.

If you really want a static member function that would invoke a specific member function on all objects of the class when it is called, then maybe what you could do is have a create() static member function serve as a "constructor", with the actual constructor declared private. This create() static member function creates a shared_ptr, storing a weak_ptr in a static member container, and returns the shared_ptr for the "outside world" to use. When the foo static member function is called, it then loops over this static member container, locking the weak_ptrs into shared_ptrs: if the result is that the weak_ptr is still valid, it then calls the bar member function of the object via the shared_ptr obtained from the weak_ptr, otherwise it removes the weak_ptr from the container. I don't really like this solution as it could be unnecessarily expensive to deal with shared_ptrs if you don't actually need them, but if you really want this mechanism then it might work for you.

EDIT:
Running with your sprite draw mention, this is a rough proof of concept of what I had in mind:

Code:

#include <algorithm>
#include <iostream>
#include <ostream>
#include <memory>
#include <vector>

class Sprite
{
public:
    static void drawAll(std::ostream& out)
    {
        clean_sprites();

        for (const auto& sprite : sprites)
        {
            auto shared_sprite = sprite.lock();
            if (shared_sprite)
            {
                shared_sprite->draw(out);
            }
        }
    }

    virtual ~Sprite() = default;
    virtual void draw(std::ostream& out) const = 0;
protected:
    Sprite() = default;

    static void add_sprite(std::weak_ptr<Sprite> sprite)
    {
        sprites.push_back(sprite);
    }
private:
    static std::vector<std::weak_ptr<Sprite>> sprites;

    static void clean_sprites()
    {
        sprites.erase(
            std::remove_if(
                sprites.begin(), sprites.end(),
                [](const auto& sprite) { return sprite.expired(); }
            ),
            sprites.end()
        );
    }
};

std::vector<std::weak_ptr<Sprite>> Sprite::sprites;

class CatSprite : public Sprite
{
public:
    static auto create()
    {
        auto sprite = std::shared_ptr<CatSprite>(new CatSprite());
        add_sprite(sprite);
        return sprite;
    }

    virtual void draw(std::ostream& out) const override
    {
        out << "meow\n";
    }
private:
    CatSprite() = default;
};

class DogSprite : public Sprite
{
public:
    static auto create()
    {
        auto sprite = std::shared_ptr<DogSprite>(new DogSprite());
        add_sprite(sprite);
        return sprite;
    }

    virtual void draw(std::ostream& out) const override
    {
        out << "woof\n";
    }
private:
    DogSprite() = default;
};

int main()
{
    auto dog = DogSprite::create();
    auto cat = CatSprite::create();
    {
        auto puppy = DogSprite::create();
        Sprite::drawAll(std::cout);
    }
    std::cout << "---\n";
    Sprite::drawAll(std::cout);
}

As you can see, it looks a bit cumbersome: it's akin to an extended singleton pattern, but is fundamentally different since it doesn't provide a single point of access (and you may need to disable copy construction, perhaps replacing it with a clone member function). It may be simpler to just maintain an external container of smart pointers (in which case you might even just need unique_ptr instead of shared_ptr).