In a recent post of Scott Wheeler's - C and C++ are not the same language. He talked about differences between C and C++, and applications of different programming languages (C, C++, Java, Ruby) in his company.

In the post, Wheeler implemented observer pattern in C, C++ and Java, demonstrating some of his points - including how C and C++ are different from each other, and how C++ and Java are actually more alike.

Though I do agree with Wheeler's conclusion for the most part, I failed to share his view in C, C++ and Java comparison. IMHO, his observer implementation in C++ is rather old school, or should I say it's so Java.

In C++, oftentimes, there are more than one way to get you from point A to point B, while OO (inheritance) is the one feature that expresses coupling the most. In modern C++, when there is a way to do something without involving inheritance (read "tight coupling"), it is usually appreciated. One such way to implement the subject in observer pattern is:

Listing 1
PLAIN TEXT
C++:
1. class subject
2. {
3. public:
4.   void register_observer(
5.     const boost::function<void ()>& observer)
6.   {
7.     observers_.connect(observer);
8.   }
9.  
10.   void notify_observers() const
11.   {
12.     observers_();
13.   }
14.  
15. private:
16.   boost::signal<void ()> observers_;
17. };

With help from Boost, nothing from subject, (or the Listener interface used in Wheeler's implementation) except the signature of expected observers, are exposed to Observers (actually, the signature is exposed mostly to programmers). They are decoupled from each other. Next, let's see what types of observers can be utilized with this subject implementation:

Listing 2
PLAIN TEXT
C++:
1. class foo_observer
2. {
3. public:
4.   void notify()
5.   {
6.     cout <<__PRETTY_FUNCTION__ <<endl;
7.   }
8. };
9.  
10. class bar_observer
11. {
12. public:
13.   bar_observer(unsigned int id)
14.   : id_(id)
15.   {}
16.  
17.   void operator()()
18.   {
19.     cout <<__PRETTY_FUNCTION__ <<'[' <<id_ <<']' <<endl;
20.   }
21. private:
22.   unsigned int id_;
23. };
24.  
25. void free_observer()
26. {
27.   cout <<__PRETTY_FUNCTION__ <<endl;
28. }

And how are they put together:

Listing 3
PLAIN TEXT
C++:
1. int main()
2. {
3.   subject sub;
4.   foo_observer foo;
5.   bar_observer bar1(1);
6.  
7.   sub.register_observer(
8.     boost::bind(&foo_observer::notify, &foo));
9.   sub.register_observer(bar1);
10.   sub.register_observer(bar_observer(2));
11.   sub.register_observer(&free_observer);
12.  
13.   sub.notify_observers();
14.  
15.   return 0;
16. }

This subject implementation can be used with general objects (e.g. foo_observer), functional objects (e.g. bar_observer), and of course free functions (e.g. free_observer) and more.

Don't be mistaken, though his C++ observer implementation is not among the best I've seen, Wheeler's post is nevertheless a good read. Enjoy.

Full source code: observer.cpp