Re: design opinions requested

From:

"Daniel T." <daniel_t@earthlink.net>

Newsgroups:

comp.lang.c++

Date:

Sun, 03 Jun 2007 21:22:17 GMT

Message-ID:

<daniel_t-8FD173.17221703062007@news.west.earthlink.net>

Tim H <thockin@gmail.com> wrote:

Most of the time Stuff will be handled in one of two patterns.

    for each item in stuff.big_list {
        if item is_foo()
            handle_foo()
        else if item is_bar()
            handle_bar()
        else
            handle_bat()
    }

or

    for each item in stuff.big_list {
        if item is_foo()
            handle_foo
    }

The above looks like two perfect candidates for polymorphism.

To make matters more complicated, there are actually three different
Stuff containers, and each can hold a subset of the total things. For
example a Stuff container can hold Foo, Bar, or Bat. A Junk container
can hold Bar or Bat, but not Foo. A Mess container can hold Foo or
Bat, but not bar.

So you might end up with several different contexts in which to use
"stuff". Each context should be a pure virtual class. Foo, Bar and Bat
will all derive from StuffContext. Bar, and Bat will derive from
JunkContext. Foo and Bat will derive from MessContext.

class StuffContext {
public:
   virtual void handleStuff() = 0;
};

class Stuff {
   typedef vector< pair< string, StuffContext* > > Container;
   Container stuff;
public:
   void handle() {
      for ( Container::iterator it = stuff.begin();
         it != stuff.end();
         ++it )
      {
         it->second->handleStuff();
      }
   }
};