Managing application with shared library - c++

Question

I'm working on an application that can be managed with a shared library. I've created an interface class, in this class there are some virtual methods/members. For example there is a method named Initialize(), if you want to implement something at the start, you should override this method.
Now I want to make a event/callback like system for managing application. How? If you want to log a message to console+log file, you'll call a method like Log("Failed to initialize MySQL") but I can't do it with a interface. I've tried something like that but I've failed;
//ManagerBase Header
class ManagerBase
{
public:
virtual void Initialize();
void Log(char* message);
}
//Manager Library
class Manager : public ManagerBase
{
public:
void Initialize() { Log((char*)"Manager's initialize!"); }
}
Can anybody help me improve this implementation?
EDIT1: I've implemented "Log()" function in my application. (like printf("%s", message);) When I compile Manager Library, compiler says "Log() method not implemented!"
EDIT2: Here is my codes, if someone wants to look them inside.
EDIT3: I'm getting this error while I'm trying to compile Manager library: undefined reference to `ManagerBase::Log(char)' [in Manager.cpp]*

Answer 1

I think the better fit for this is composition. Rather than attempting to define the variable behaviour in your base class (ManagerBase), you can have Manager define when the behaviour should occur, and pass that behaviour into Manager as its own object. ManagerBase is no longer needed.
// *** Behaviour interfaces ***
// ILogger.h
class ILogger
{
public:
~ILogger(){};
virtual void Log( const char *pMessage ) = 0;
};
//*******************************
// IDatabse.h
class IDatabase
{
public:
~IDatabase(){}
virtual void CreateDB( const char *pDBName ) = 0;
};
//*******************************
// ** Manager **
// Manager.h
class ILogger;
class IDatabase;
class CManager
{
public:
CManager(
ILogger &logger,
IDatabase &db );
void Initialise( const char *pDBName );
private:
ILogger &m_logger;
IDatabase &m_db;
};
// Manager.cpp
#include "ILogger.h"
#include "IDatabase.h"
#include "Manager.h"
CManager::CManager( ILogger &logger, IDatabase &db )
: m_logger(logger) // this is like registering a Log callback
, m_db(db) // and a (set of) db callback/s
{
}
void CManager::Initialise( const char *pDBName )
{
m_logger.Log( "Initialising" ); // this is akin to raising a log 'event'
m_db.CreateDB( pDBName ); // and a create DB event.
}
//*******************************
// ** Application **
// Application.h
#include "ILogger.h"
#include "IDatabase.h"
#include "Manager.h"
class CApp : public ILogger, public IDatabase
{
/* You don't have to have your main app inherit the interface. You could
implement them as their own objects, owned by CApp, or at least
something that is reachable when contructing CManager */
public:
CApp()
: m_Manager( *this, *this )
{
m_Manager.Initialise("MyAwesomeDatabaseOfDoom");
}
// implement overrides for Log and CreateDB here.
void Log( const char* pMessage ){}
void CreateDB( const char *pDBName ){}
private:
CManager m_Manager;
};
//*******************************
// ** Application **
// main.cpp
int main()
{
CApp();
return 0;
};
This is just a quick mock up, so apologies if it doesn't compile. I hope it at least illustrates the idea.
If you want to be able to change your behaviour at runtime, you can use ILogger/IDatabase member pointers rather than references in CManager, and expose setters so that you can set whatever behaviour defining object you like. This lets you do interesting things like, for example, changing what you log to based on a config file setting, by implementing a CFileLogger and a CDatabaseLogger version of ILogger and setting them appropriately.