It turned out that I'll be presenting idioms in C++03 this thursday (17.10.2013). Feel free to come.
You can find details here.
See you!
1 template <typename T> class Widget { }; 2 3 class Base 4 { 5 public: 6 virtual void handle(Widget<float> widget) { } 7 virtual void handle(Widget<int> widget) { } 8 }; 9 10 class Derived : public Base 11 { 12 public: 13 virtual void handle(Widget<int> widget) { } 14 }; 15 16 int main(int, char **) 17 { 18 Derived * derived = new Derived(); 19 derived->handle(Widget<float>()); 20 delete derived; 21 }
$ clang++ polym.cpp
polym.cpp:20:21: error: no viable conversion from 'Widget<float>' to 'Widget<int>'
derived->handle(Widget<float>());
^~~~~~~~~~~~~~~
polym.cpp:1:29: note: candidate constructor (the implicit copy constructor)
not viable: no known conversion from 'Widget<float>' to
'const Widget<int> &' for 1st argument;
template class Widget { };
^
polym.cpp:13:37: note: passing argument to parameter 'widget' here
virtual void handle(Widget<int> widget) { }
^
1 error generated.
16 int main(int, char **) 17 { 18 Derived * derived = new Derived(); 19 dynamic_cast<Base*>(derived)->handle(Widget<float>()); 20 delete derived; 21 }
10 class Derived : public Base 11 { 12 public: 13 virtual void handle(Widget<int> widget) { } 14 using Base::handle; 15 };
int handlerA(int param) { return param + 1; } int handlerB(int param) { return param + 2; } int handlerC(int param) { return param + 3; } int handle(int code, int param) { switch(code) { case 0: return handlerA(param); case 1: return handlerB(param); case 2: return handlerC(param); default: assert(!"No handler registered for provided code"); } }
int handle(int code, int param) { static int (*handlers[])(int) = { handlerA, handlerB, handlerC }; static const int numHandlers = sizeof(handlers) / sizeof(handlers[0]); assert(code > 0 && code < numHandlers && "No handler registered for provided code"); return handlers[code](param); }
class Handlers { public: int HandlerA(int param) { return param + 1; } int HandlerB(int param) { return param + 2; } int HandlerC(int param) { return param + 3; } }; int main(int ac, char ** av) { Handlers handlers; std::vector<function<int(int)> > fs; fs.push_back(bind(&Handlers::HandlerA, ref(handlers), _1)); fs.push_back(bind(&Handlers::HandlerB, ref(handlers), _1)); fs.push_back(bind(&Handlers::HandlerC, ref(handlers), _1)); ... }
class IHandler { public: virtual void Handle(void * data) = 0; }; class HandlerA : public IHandler { public: virtual void Handle(void * data) { // Handle data here... } }; class MainHandler { public: void Handle(int code, void * data) { _handlers[code]->Handle(data); } void RegisterHandler(int code, IHandler * handler) { _handlers.insert(make_pair<int, IHandler *>(code, handler)); } private: map<int, IHandler *> _handlers; };
class IHandler { public: virtual void Handle(void * data) = 0; }; class MainHandler { public: static void Handle(int code, void * data) { _handlers[code]->Handle(data); } static void RegisterHandler(int code, IHandler * handler) { _handlers.insert(make_pair<int, IHandler *>(code, handler)); } private: static map<int, IHandler *> _handlers; }; map<int, IHandler *> MainHandler::_handlers; template <typename T> class AutoRegister { public: AutoRegister() { MainHandler::RegisterHandler(T::HANDLED_CODE, new T()); } void fun() const { return; } ~AutoRegister() { // OPT: Unregister here... } }; class HandlerA : public IHandler { public: virtual void Handle(void * data) { // Handle data here... } static int HANDLED_CODE; private: static AutoRegister<HandlerA> _autoRegisterer; }; int HandlerA::HANDLED_CODE = 1; AutoRegister<HandlerA> HandlerA::_autoRegisterer; // Example usage: int main(int ac, char ** av) { MainHandler::Handle(1, NULL); }
class BaseHandler(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def Handle(self, data): pass @abc.abstractproperty def code(self): pass
class ConcreteHandler(BaseHandler): code = 1 def Handle(self, data): pass # Handle here...
class MainHandler(object): def __init__(self): self.__handlers = dict([ (x[1].code, x[1]()) for x in inspect.getmembers(sys.modules[__name__]) if (issubclass(x[1], BaseHandler) and x[1] != BaseHandler) ]) def Handle(self, code, data): try: return self.__handlers[code].Handle(data) except KeyError: raise RuntimeError('No handler registered for code ' + str(code))