Re: Some questions from a n00b
On Saturday, 18 October 2014 17:32:33 UTC+3, Robert Hutchings wrote:
Given this code:
#include <iostream>
#include <set>
using namespace std;
That line I don't write.
// ---------------- Observer interface -----------------
class Observer {
public:
virtual void Notify() = 0;
};
// ---------------- Observable object -------------------
class Observable {
static Observable* instance;
set<Observer*> observers;
Observable() { };
public:
static Observable* GetInstance();
void AddObserver(Observer& o);
void RemoveObserver(Observer& o);
void NotifyObservers();
void Trigger();
};
Observable* Observable::instance = NULL;
Observable* Observable::GetInstance()
{
if (instance == NULL) {
instance = new Observable();
}
return instance;
}
void Observable::AddObserver(Observer& o)
{
observers.insert(&o);
}
void Observable::RemoveObserver(Observer& o)
{
observers.erase(&o);
}
void Observable::NotifyObservers()
{
set<Observer*>::iterator itr;
for (itr = observers.begin();
itr != observers.end(); itr++)
(*itr)->Notify();
}
// TEST METHOD TO TRIGGER
// IN THE REAL SCENARIO THIS IS NOT REQUIRED
void Observable::Trigger()
{
NotifyObservers();
}
// ------ Concrete class interested in notifications ---
class MyClass : public Observer {
Observable* observable;
public:
MyClass() {
observable = Observable::GetInstance();
observable->AddObserver(*this);
}
~MyClass() {
observable->RemoveObserver(*this);
}
void Notify() {
cout << "Received a change event" << endl;
}
};
void main()
Never write 'void main()' in C or C++ forums without mentioning compiler
that you target. It is compiler-specific extension. Standard only
defines 'int main()'.
{
Observable* observable = Observable::GetInstance();
MyClass* obj = new MyClass();
observable->Trigger();
}
What if I don't to use a SET? What is the advantage of using pointers
with "new", as apposed to NOT using pointers?
'std::set' seems fine. If you want an alternative sorted value container
that performs differently (and often wins 'std::set' in performance) then
you should perhaps try 'boost::flat_set'. Some shops use it always where a
set is needed.
The problem is not in raw pointers (despite I next to never use these in
C++ and all is fine). The problem is that your observer pattern has passed
the responsibility of management of those (raw pointer) bindings to user
classes. You do it probably by some book? Toss it away, it does not discuss
the issues under hand in enough depth.
For example your 'Observer' class does not have capability to know what
(if anything) it observes. As result the knowledge is in 'MyClass' and so
the responsibility to manage the binding between itself and 'Observable'
is given to 'MyClass'. Why? That results in copy-paste implementation
of binding (raw pointer) management in all classes derived from 'Observer'.
Also your design contains some serious constraints.
Your 'Observable' (usually called "Subject" in books) is a first demand
singleton with never ending lifetime in your design. That is seriously
limiting. The 'MyClass' can handle only one thing with its 'Notify()'
from that global single 'Observable'. That is also rather limiting. Such
limits narrow the usefulness of it and so the amount of practical problems
for what it may be is good enough.
'Observable' could have responsibility to call some "detach from me" of all
its observers from its destructor and so have normal life-time that is
not bound to observers. Bindings can be made in lot more generic ways
so different notifications can be received from different subjects thru
different handlers.
Have you considered of looking at existing art? The source code may
be hard to understand for beginner (too generic, too thread-safe) but
reading documentation and examples and trying to use these things may move
you closer to understanding of the power of that important pattern and also
aid to see the volume of problems that it can solve.
For concrete examples take some sigslot by Sarah Thompson from sourceforge http://sigslot.sourceforge.net/ Alternatively Leigh made and published
his 'neosigslot' some time ago here http://i42.co.uk/stuff/neosigslot.htm
Leigh is trolling here as "Mr Flibble", but don't worry, C++ he knows well
and can write finely.
If you want more heavyweight examples (in sense of code size, the
performance is fine) then download Boost libraries and look at
Boost.Signals2 or take GTK and its C++ wrapper contains one. Also it is
may be worth to note that Qt generates such slots and signals binding
code with its 'moc' preprocessor, so there's no point of such classes if
you use Qt framework.