Question

I am trying to implement an observer pattern with a template subject class. The observers don’t (need to) know the subjects type, so I made an interface for the attach method without this type. This is my implementation:

SubjectInterface.h

#ifndef SUBJECTINTERFACE_H_
#define SUBJECTINTERFACE_H_
#include <list>
#include "Observer.h"
// Template-independant interface for registering observers
class SubjectInterface
{
public:
  virtual void Attach(Observer*) = 0;
}; // class SubjectInterface
#endif // SUBJECTINTERFACE_H_

Subject.h

#ifndef SUBJECT_H_
#define SUBJECT_H_
#include <list>
#include "Observer.h"
#include "SubjectInterface.h"
template <class T>
class Subject : public SubjectInterface
{
public:
  Subject();
  ~Subject();
  void Attach(Observer*);
private:
  T                        mValue;
  std::list<Observer*> mObservers;
}; // class Subject
#include "Subject.cpp"
#endif // SUBJECT_H_

Subject.cpp

template <class T>
Subject<T>::Subject()
{
}
template <class T>
Subject<T>::~Subject()
{
}
template <class T>
void Subject<T>::Attach(Observer* test)
{
  mObservers.push_back(test);
}

Observer.h

#ifndef OBSERVER_H_
#define OBSERVER_H_
#include "SubjectInterface.h"
#include <iostream>
class Observer
{
public:
  Observer(SubjectInterface* Master);
  virtual ~Observer();
private:
  SubjectInterface* mMaster;
}; // class Observer
#endif // OBSERVER_H_

Observer.cpp

#include "Observer.h" // include header file
Observer::Observer(SubjectInterface* Master)
{
  Master->Attach(this);
}
Observer::~Observer()
{
}

When I compile this using the gcc 4.3.4, I get the following error message:

SubjectInterface.h:10: error: ‘Observer’ has not been declared

I don’t understand this, because the Observer is included just a few lines above. When I change the pointer type from Observer* to int*, it compiles OK. I assume that there is a problem with the template subject and the non-template interface to it, but that is not what gcc is telling me and that doesn’t seem to be the problem when using int*.

I searched for template/observer, but what I found (e.g. Implementing a Subject/Observer pattern with templates) is not quite what I need.

Can anyone tell me, what I did wrong or how I can call the templated attach-method from a non-template observer?

Answer 1

You have a circular include chain, SubjectInterface.h includes Observer.h which in turns includes SubjectInterface.h.

This means that the include guards will prevent Observer from being visible. To fix it instead forward declare Observer.

// SubjectInterface.h
#ifndef SUBJECTINTERFACE_H_
#define SUBJECTINTERFACE_H_
#include <list>
class Observer; //Forward declaration
// Template-independant interface for registering observers
class SubjectInterface
{
public:
  virtual void Attach(Observer*) = 0;
}; // class SubjectInterface
#endif // SUBJECTINTERFACE_H_