code refactoring: fix memory leaks, code style, etc.

observer/Observer.cpp

@@ -18,10 +18,13 @@ class Subject;
  * defines an updating interface for objects that should be notified
  * of changes in a subject
  */
-class Observer {
+class Observer
+{
 public:
+  virtual ~Observer() {}
+  
   virtual int getState() = 0;
-  virtual void update(Subject *subject) = 0;
+  virtual void update( Subject *subject ) = 0;
   // ...
 };
 
@@ -30,16 +33,20 @@ public:
  * stores state of interest to ConcreteObserver objects and
  * sends a notification to its observers when its state changes
  */
-class ConcreteObserver : public Observer {
+class ConcreteObserver : public Observer
+{
 public:
-  ConcreteObserver(int state)
-    : observer_state(state) {}
-
-  int getState() {
+  ConcreteObserver( const int state ) :
+    observer_state( state ) {}
+  
+  ~ConcreteObserver() {}
+  
+  int getState()
+  {
     return observer_state;
   }
-
-  void update(Subject *subject);
+  
+  void update( Subject *subject );
   // ...
 
 private:
@@ -52,28 +59,35 @@ private:
  * knows its observers and provides an interface for attaching
  * and detaching observers
  */
-class Subject {
+class Subject
+{
 public:
-  void attach(Observer *observer) {
+  virtual ~Subject() {}
+  
+  void attach( Observer *observer )
+  {
     observers.push_back(observer);
   }
-
-  void detach(int index) {
-    observers.erase(observers.begin() + index);
+  
+  void detach( const int index )
+  {
+    observers.erase( observers.begin() + index );
   }
-
-  void notify() {
-    for (unsigned int i = 0; i < observers.size(); i++) {
-      observers.at(i)->update(this);
+  
+  void notify()
+  {
+    for ( unsigned int i = 0; i < observers.size(); i++ )
+    {
+      observers.at( i )->update( this );
     }
   }
-
+  
   virtual int getState() = 0;
-  virtual void setState(int s) = 0;
+  virtual void setState( const int s ) = 0;
   // ...
 
 private:
-  std::vector<Observer *> observers;
+  std::vector<Observer*> observers;
   // ...
 };
 
@@ -81,23 +95,29 @@ private:
  * Concrete Subject
  * stores state that should stay consistent with the subject's
  */
-class ConcreteSubject : public Subject {
+class ConcreteSubject : public Subject
+{
 public:
-  int getState() {
+  ~ConcreteSubject() {}
+  
+  int getState()
+  {
     return subject_state;
   }
-
-  void setState(int s) {
+  
+  void setState( const int s )
+  {
     subject_state = s;
   }
   // ...
-
+  
 private:
   int subject_state;
   // ...
 };
 
-void ConcreteObserver::update(Subject *subject) {
+void ConcreteObserver::update( Subject *subject )
+{
   observer_state = subject->getState();
   std::cout << "Observer state updated." << std::endl;
 }
@@ -105,21 +125,22 @@ void ConcreteObserver::update(Subject *subject) {
 
 int main()
 {
-  ConcreteObserver observer1(1);
-  ConcreteObserver observer2(2);
-
+  ConcreteObserver observer1( 1 );
+  ConcreteObserver observer2( 2 );
+  
   std::cout << "Observer 1 state: " << observer1.getState() << std::endl;
   std::cout << "Observer 2 state: " << observer2.getState() << std::endl;
-
-  Subject *subject = new ConcreteSubject;
-  subject->attach(&observer1);
-  subject->attach(&observer2);
-
-  subject->setState(10);
+  
+  Subject *subject = new ConcreteSubject();
+  subject->attach( &observer1 );
+  subject->attach( &observer2 );
+  
+  subject->setState( 10 );
   subject->notify();
-
+  
   std::cout << "Observer 1 state: " << observer1.getState() << std::endl;
   std::cout << "Observer 2 state: " << observer2.getState() << std::endl;
-
+  
+  delete subject;
   return 0;
-}
+}