Question

I’m writing a small plugin system for a program. Some parts of it are done already, loading the file and calling the constructor function works.

In one of the functions I need to pass some (class-)pointers back to the handler, that’s where I get a seg-fault.

in program:

class RenderInterface {
    public:
        RenderInterface();
        virtual ~RenderInterface();

        void RegisterBufferInterface(BufferInterface* interface)
        {
             bInterface = interface; // <---- this is where segfault occurs
        }
        void RegisterCameraInterface(CameraInterface* interface){}
        void RegisterRenderInterface(RenderInterface* interface){}

        static RenderInterface* GetSingletonPtr()
        {
            return _singleton;
        }

    private:
        static RenderInterface* _singleton;

        BufferInterface* bInterface;
        CameraInterface* cInterface
        RenderInterface* rInterface;
};

RenderInterface::_singleton is set to 0 elsewhere.

in registration function (in dll):

class BInterface : public BufferInterface {
    public:
        ... various stuff ....
}

class GLPlugin : public Plugin {
    public:
        Plugin() : bInterface(0) {}
        ~Plugin(){}

        void Initialize() // <--- is called after dll has been loaded
        {
            bInterface = new BInterface();

            InterfaceManager::GetSingletonPtr()->RegisterBufferInterface(bInterface); // segfault
            // register other stuff
        }
    private:
        BufferInterface* bInterface;
};

What am I missing for this to work? Is there another way to do it?

Edit: missed the * after BufferInterface while simplifying the code, thanks Luchian

Answer 1

Well, it crashes because you never initialize your singleton:

static RenderInterface* GetSingletonPtr()
{
    return _singleton;
}

I’m assuming you initialize _singleton to NULL in your implementation file, in which case you’d need:

static RenderInterface* GetSingletonPtr()
{
    if ( !_singleton )
        _singleton = new RenderInterface;
    return _singleton;
}

Some other hints:

• asses other options before using singletons
• implementing a destructor usually means you also need a copy constructor and an assignment operator (the rule of three)
• if your class truly is a singleton, shouldn’t the constructor be private?
• bInterface = new BInterface(); is illegal, since bInterface is an object, not a pointer.