In a C++ code base I've been working on, they have a bunch of instances of the observer pattern, but it's a little different from the classical pattern. In the classic, the Observer is a specific interface with specific method(s) that are called when the Observable changes or has new data.
Observable Observer register( Observer* ) update( data1, data2 ... )
In our code base, we use a template class that takes the number and type of arguments to the update() method as parameters, and allows you to specify any pointer-to-method as the recipient of the data.
Observable register( Functor<data1, data2> )
Is this an improvement over the original pattern? Here's what I think are the pros of each approach:
- clarity - the interface marks which classes are recipients of observable data
- less code - the boiler plate and ugly template syntax to create the functor are somewhat onerous
- flexibility - I can make any object in my system receive the update (if it has the right method signature) without having to change the original object
As a another option, do I have it all wrong that this is the Observer pattern in practice?