Static ctor/dtor observer for arb. C++ classes_问答_开发者

I have a series of classes A, B, ... which have many derived classes which are created inside a module I do not wish to change.

Additionally, I have at least one class Z, which has to be informed whenever an object of type A (or derived classes) is created or destroyed. In the future, there may be more classes, Y, X that want to observe different objects.

I am looking for a convenient way to solve this. At first glance, the problem seemed trivial, but I'm kind of stuck right now.

What I came up with, is two base classes SpawnObserver and SpawnObservable which are supposed to do the job, but I am very unhappy with them for several reasons (see attached simplification of these classes).

When Z is notified, the actual object is either not yet or not anymore existent, due to the order in which base classes are created/destroyed. Although the pointers can be compared when destroying an object (to remove them from some data-structures in Z) this does not work when it is created and it surely does not work when you have multiple inheritance.
If you want to observe only one class, say A, you are always notified of all (A, B, ...).
You have to explicitly if/else through all classes, so you have to know all classes that inherit from SpawnObservable, which is pretty bad.

Here are the classes, which I tried to trim down to the most basic functionality, which you need to know to understand my problem. In a nutshell: You simply inherit from SpawnObservable and the ctor/dtor does the job of notifying the observers (well, at least, this is what I want to have).

#include <list>
#include <iostream>

class SpawnObservable;

class SpawnObserver {
  public:
    virtual void ctord(SpawnObservable*) = 0;
    virtual void dtord(SpawnObservable*) = 0;
};

class SpawnObservable {
  public:
    static std::list<SpawnObserver*> obs;
    SpawnObservable() {
      for (std::list<SpawnObserver*>::iterator it = obs.begin(), end = obs.end(); it != end; ++it) {
        (*it)->ctord(this);
      }
    }
    ~SpawnObservable() {
      for (std::list<SpawnObserver*>::iterator it = obs.begin(), end = obs.end(); it != end; ++it) {
        (*it)->dtord(this);
      }
    }
    virtual void foo() {} // XXX: very nasty dummy v开发者_如何学编程irtual function
};
std::list<SpawnObserver*> SpawnObservable::obs;

struct Dummy {
  int i;
  Dummy() : i(13) {}
};

class A : public SpawnObservable {
  public:
    Dummy d;
    A() : SpawnObservable() {
      d.i = 23;
    }
    A(int i) : SpawnObservable() {
      d.i = i;
    }
};

class B : public SpawnObservable {
  public:
    B() { std::cout << "making B" << std::endl;}
    ~B() { std::cout << "killing B" << std::endl;}
};

class PrintSO : public SpawnObserver { // <-- Z
  void print(std::string prefix, SpawnObservable* so) {
    if (dynamic_cast<A*>(so)) {
      std::cout << prefix << so << " " << "A: " << (dynamic_cast<A*>(so))->d.i << std::endl;
    } else if (dynamic_cast<B*>(so)) {
      std::cout << prefix << so << " " << "B: " << std::endl;
    } else {
      std::cout << prefix << so << " " << "unknown" << std::endl;
    }
  }
  virtual void ctord(SpawnObservable* so) {
    print(std::string("[ctord] "),so);
  }
  virtual void dtord(SpawnObservable* so) {
    print(std::string("[dtord] "),so);
  }
};


int main(int argc, char** argv) {
  PrintSO pso;
  A::obs.push_back(&pso);
  B* pb;
  {
    std::cout << "entering scope 1" << std::endl;
    A a(33);
    A a2(34);
    B b;
    std::cout << "adresses: " << &a << ", " << &a2 << ", " << &b << std::endl;
    std::cout << "leaving scope 1" << std::endl;
  }
  {
    std::cout << "entering scope 1" << std::endl;
    A a;
    A a2(35);
    std::cout << "adresses: " << &a << ", " << &a2 << std::endl;
    std::cout << "leaving scope 1" << std::endl;
  }
  return 1;
}

The output is:

entering scope 1
[ctord] 0x7fff1113c640 unknown
[ctord] 0x7fff1113c650 unknown
[ctord] 0x7fff1113c660 unknown
making B
adresses: 0x7fff1113c640, 0x7fff1113c650, 0x7fff1113c660
leaving scope 1
killing B
[dtord] 0x7fff1113c660 unknown
[dtord] 0x7fff1113c650 unknown
[dtord] 0x7fff1113c640 unknown
entering scope 1
[ctord] 0x7fff1113c650 unknown
[ctord] 0x7fff1113c640 unknown
adresses: 0x7fff1113c650, 0x7fff1113c640
leaving scope 1
[dtord] 0x7fff1113c640 unknown
[dtord] 0x7fff1113c650 unknown

I want to stress, that I am perfectly aware why my solution behaves the way it does. My question is whether you have a better approach of doing this.

EDIT

As an extension to this question (and inspired by the comments below), I'd like to know: Why do you think this is a terrible approach?

As an additional note: What I an trying to accomplish by this is to install a normal Observer in each and every created object.

EDIT 2

I will accept an answer that solves problem 1 (bold one in the enumeration above) or describes why the whole thing is a very bad idea.

Use the curiously recurring template pattern.

template<typename T> class watcher {
    typename std::list<T>::iterator it;
    watcher();
    ~watcher();
    void ctord(T*);
    void dtord(T*);    
};
template<typename T> class Observer {
public:

    typedef std::list<T*> ptr_list;
    static ptr_list ptrlist;
    typedef typename ptr_list::iterator it_type;
    it_type it;

    typedef std::list<watcher<T>*> watcher_list;
    static watcher_list watcherlist;
    typedef typename watcher_list::iterator watcher_it_type;

    Observer() {
       ptrlist.push_back(this);
       it_type end = ptrlist.end();
       end--;
       it = end;
       for(watcher_it_type w_it = watcherlist.begin(); w_it != watcherlist.end(); w_it++)
           w_it->ctord(this);
    }
    ~Observer() {
        ptrlist.erase(it);
       for(watcher_it_type w_it = watcherlist.begin(); w_it != watcherlist.end(); w_it++)
           w_it->ctord(this);
    }
};
class A : public Observer<A> {
};
class B : public Observer<B> {
};
class C : public A, public B, public Observer<C> {
    // No virtual inheritance required - all the Observers are a different type.
};
template<typename T> watcher<T>::watcher<T>() {
    Observer<T>::watcherlist.push_back(this);
    it = watcherlist.end();
    it--;         
}
template<typename T> watcher<T>::~watcher<T>() {
    Observer<T>::watcherlist.erase(it);
}
template<typename T> void watcher<T>::ctord(T* ptr) {
    // ptr points to an instance of T that just got constructed
}
template<typename T> void watcher<T>::dtord(T* ptr) {
    // ptr points to an instance of T that is just about to get destructed.
}

Not just that, but you can inherit from Observer multiple times using this technique, as two Observer<X> and Observer<Y> are different types and thus doesn't require diamond inheritance or anything like that. Plus, if you need different functionality for Observer<X> and Observer<Y>, you can specialize.

Edit @ Comments:

class C DOES inherit from Observer<A> and Observer<B> through A and B, respectively. It doesn't need to know or care whether or not they're being observed. A C instance will end up on all three lists.

As for ctord and dtord, I don't actually see what function they perform. You can obtain a list of any specific type using Observer::ptrlist.

Edit again: Oooooh, I see. Excuse me a moment while I edit some more. Man, this is some of the most hideous code I've ever written. You should seriously consider not needing it. Why not just have the objects that need to be informed about the others do their creation?

Issue 1 isn't easily solved (in fact I think it's impossible to fix). The curiously recurring template idea comes closest to solving it, because the base class encodes the derived type, but you'll have to add a base to every derived class, if you really insist on knowing the derived type when the base is being constructed.

If you don't mind performing your actual operations (other than the bookkeeping, I mean) or examining the list outside the constructor or destructor of each object, you could have it (re)build the minimal list only when the operation is about to be performed. This gives you a chance to use the fully-constructed object, and makes it easier to solve issue 2.

You'd do this by first having a list of objects that have been constructed, but aren't on the 'full' list. And the 'full' list would contain two pointers per constructed object. One is the pointer to the base class, which you'll store from the Observable constructor, possibly multiple times during the construction of a single object. The other is a void *, pointing to the most derived part of the object -- use dynamic_cast<void *> to retrieve this -- and is used to make sure that each object only appears once in the list.

When an object is destroyed, if it has multiple Observable bases, each will try to remove itself from the lists, and when it comes to the full list, only one will succeed -- but that's fine, because each is equally good as an arbitrary base of that object.

Some code follows.

Your full list of objects, iterable in as straightforward a fashion as std::map will allow. (Each void * and each Observable * is unique, but this uses the Observable * as the key, so that it's easy to remove the entry in the Observable destructor.)

typedef std::map<Observable *, void *> AllObjects;
AllObjects allObjects;

And your list of objects that have been constructed, but aren't yet added to allObjects:

std::set<Observable *> recentlyConstructedObjects;

In the Observable constructor, add the new object to the list of pending objects:

recentlyConstructedObjects.insert(this);

In the Observable destructor, remove the object:

// 'this' may not be a valid key, if the object is in 'allObjects'.
recentlyConstructedObjects.erase(this);

// 'this' may not be a valid key, if the object is in 'recentlyConstructedObjects',
// or this object has another Observable base object and that one got used instead.
allObjects.erase(this);

Before you're about to do your thing, update allObjects, if there've been any objects constructed since last time it was updated:

if(!recentlyConstructedObjects.empty()) {
    std::map<void *, Observable *> newObjects;
    for(std::set<Observable *>::const_iterator it = recentlyConstructedObjects.begin(); it != recentlyConstructedObjects.end(); ++it)
        allObjectsRev[dynamic_cast<void *>(*it)] = *it;

    for(std::map<void *, Observable *>::const_iterator it = newObjects.begin(); it != newObjects.end(); ++it)
        allObjects[it->second] = it->first;

    recentlyConstructedObjects.clear();
}

And now you can visit each object the once:

for(std::map<Observable *,void *>::const_iterator it = allObjects.begin(); it != allObjects.end(); ++it) {
    // you can dynamic_cast<whatever *>(it->first) to see what type of thing it is
    //
    // it->second is good as a key, uniquely identifying the object
}

Well... now that I've written all that, I'm not sure whether this solves your problem. It was interesting to consider nonetheless.

(This idea would solve one of the problems with the curiously recurring template, namely that you have lots of base objects per derived object and it's harder to disentangle because of that. (Unfortunately, no solution to the large number of base classes, sorry.) Due to the use of dynamic_cast, of course, it's not much use if you call it during an object's construction, which is of course the advantage of the curiously recurring thing: you know the derived type during the base's construction.

(So, if your'e going with that style of solution, AND you are OK with performing your operations outside the construction/destruction stage, AND you don't mind the (multiple) base classes taking up space, you could perhaps have each base's constructor store some class-specific info -- using typeid, perhaps, or traits -- and merge these together when you build the larger list. This should be straightforward, since you'll know which base objects correspond to the same derived object. Depending on what you're trying to do, this might help you with issue 3.)

Take a look at Signals and Slots especially Boost Signals and Slots