Re: Some questions from a n00b

From:

Paavo Helde <myfirstname@osa.pri.ee>

Newsgroups:

comp.lang.c++

Date:

Sat, 18 Oct 2014 09:49:02 -0500

Message-ID:

<XnsA3CAB5406B549myfirstnameosapriee@216.196.109.131>

Robert Hutchings <rm.hutchings@gmail.com> wrote in news:m1ttlj$3m3$1
@dont-email.me:

Given this code:

#include <iostream>
#include <set>

using namespace std;

// ---------------- 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()
{
     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?

Whic pointers exactly? You have a lot of them here.

"MyClass* obj = new MyClass()" is not needed (and you have a memory leak
caused by it), you could do equally well

MyClass obj;

Dynamic allocation is needed only if the lifetime of the object is not
bound to a single scope.

You also have a lot of pointers to Observable. Most of them could be
replaced by a reference for a bit better syntax.

You don't need the member variable MyClass::observable, instead you can
call Observable::GetInstance() whenever needed.

But inside the Observable, you need a std::set or some other container of
pointers though (because you cannot put references into a container, as
they are not objects, unlike pointers).

hth
Paavo