How to make an object that can be referenced by everything?

Question

I am trying to make a class ShapeManager which is instantiated only once, and have a base class Shape(and all of its children) have access to it. This would result in a structure that looks like this:

ShapeManager
Shape
└Square
└Triangle
└Circle

---

#include "Shape.h" // so that i can use Shape in the vector

// This is instantiated once in main
class ShapeManager {
public:
    typedef std::vector<std::unique_ptr<Shape>> VecShape;
    typedef std::default_random_engine          DRE;

private:
    VecShape&   m_shapes;
    b2World&    m_world;
    DRE&        m_gen;

public:
    ShapeManager(VecShape& vectorShapes, b2World& world, DRE& gen) 
        : m_shapes(vectorShapes), m_world(world), m_gen(gen) {}

    VecShape& getShapeList() { return m_shapes; }
    b2World& getWorld() { return m_world; }
    DRE& getDRE() { return m_gen; }
};

---

#include "ShapeManager.h" // so that i can access it's member functions

class Shape {
protected:
    std::string m_name;

public:
    Shape() : m_name("Shape") {}
    std::string getName() { return m_name; }
};

I simplified my code a lot to keep it relevant to my question. If it's unclear what i'm asking i will try to explain it further! Basically i just want to have a class that manages my shape objects & holds data that Shape's children will use such as m_gen and m_world.

EDIT 1: My main motivation to creating a ShapeManager is to store a reference to m_shapes, m_world, and m_gen, but i don't want every shape object to have those 3 reference variables. That would mean creating a Circle would have to have those 3 parameters in the ctor, along with the parameters relevant to the circle.

EDIT 2: Singleton and/or Dependency Injection are the two design patterns that, when implemented, solve my issue. Here is some info on it. Thank you all!

Answer 1

Don't try and make a global variable accessible through all your code. Make a certain object accessible only to who needs it. Thus, make a private ShapeManager in Shape and pass it through Shapes constructor.

But it's still strange that Shape has to have access to ShapeManager.

EDIT - Comment by the author: My main motivation to creating a ShapeManager is to store a reference to m_shapes, m_world, and m_gen, but i didn't want every shape object to have those 3 reference variables.

You can have a struct that stores your 3 reference variables and each object that needs access to them would have a private struct.

Some other file:

struct myManagers {
ShapeManager *shapeMan;
WorldManager *worldMan;
GenManager *genMan;
}

Shape.h:

#ifndef H_SHAPE // Include guards to avoid circular dependency
#define H_SHAPE
#include "ShapeManager.h" // so that i can access it's member functions

class Shape {
protected:
    std::string m_name;
    myManagers *myMan = nullptr;

public:
    Shape(myManagers *myManager) : m_name("Shape"), myMan(myManager) {}
    std::string getName() { return m_name; }
};

#endif

and usage would be something like:

int main() {
myManagers GlobalManager;
GlobalManager.shapeMan = &ShapeManager;
// ... fill in other 2 managers

Shape myBall(&GlobalManager);
// this way myBall has access to all 3 references
}

ps: include guards are pretty much the only occasion where macros are acceptable

Answer 2

What you are looking for is Singleton Design Pattern. See the code below:

class ShapeManager
{
public:
static ShapeManager& instance()
{
    static ShapeManager *instance = new ShapeManager();
    return *instance;
}

private:
    ShapeManager(){}

/*
    use this space to fill in your code
    */
}

You can access the class members as:

ShapeManager::instance().getDRE();

This limits to a single instance of the class. There's no need to instantiate an object of this class, in fact, you can not and can be accessed from anywhere.