Kompositum Pattern + Collection

Zickedi

Ich möchte alle Aufrufe meiner Childklassen in einer zentralen Klasse sammeln. Der Aufruf soll erst mal nur ein string sein oder zurückgeben.

Folgendes Schema:

class Base {

  public:
    virtual void write() = 0;
    virtual ~Base() {};
  };

class Child: public Base{

  public:
    void write() {

      cout << "Child";
    }
  };

class Parent: public Base{

  private:
    std::set<Child*> childList;

    typedef std::set<Child*>::iterator childIter;

  public:
    void write() {
      cout << "Parent";
      for (childIter it = childList.begin(); it != childList.end(); it++)
      {
        Child* component = *it;
        component->insert();
      }
    }

    void add(Child* component)
    {
      childList.insert(component);
    }

    void remove(Child* component)
    {
      childList.erase(component);
    }
  };

class Collector {

private:
std::string getAllCoutsFromChilds; // Lösung?

public:
void run() {
  Parent* p = new Parent();
  p->add(new Child);

  p->write();

  delete p;
}
};

int main() {
  Collector c;
  c.run();
}

finix

Was ist jetzt deine Frage, bzw. dein Problem?

Btw, in deinem Code ist weit und breit nichts vom Composite Pattern zu sehen. Und ganz so klar was du mit "Collection" meinst ist auch nicht klar.

Zickedi

Frage ist wie ich am besten die "write"-Methode in der Klasse "Collector" sammle. Die Methode ist nur ein Beispiel, am Ende sollte sie einfach einen string in die Klasse "Collector" schreiben. Damit meine ich jeder Aufruf der Methode (Der Parent und Childklassen).

Das Kompositum hab ich von hier:
http://de.wikipedia.org/wiki/Kompositum_(Entwurfsmuster)

Hab ich das jetzt so stark abgeändert, dass kein Kompositum mehr zu sehen ist?
Habs im Grunde nur etwas genauer typisiert.

finix

Hm. Der WP-Artikel scheint tatsächlich nicht allzu erhellend. Composite ist im Prinzip nichts anderes als das in einer Vererbungshierarchie die "inneren Knoten" und die "Blätter" ein gemeinsames Interface haben. Wobei oftmals das Streben nach einheitlicher Behandlung im Vordergrund steht, z.B.

class node
{
public:
  virtual ~node() { }
  virtual void operation1() = 0;
  virtual void operation2() { } // do nothing by default
  virtual std::ostream& print( std::ostream& os ) const = 0;
};

std::ostream& operator<<( std::ostream& os, node const& obj )
{
  return obj.print(os);
}

std::ostream& operator<<( std::ostream& os, node const* obj_ptr )
{
  return obj_ptr->print(os);
}

class container : public node
{
public:
  virtual void operation1()
  {
    // perform operation1
  }

  virtual void operation2()
  {
    // perform operation2
  }

  virtual std::ostream& print( std::ostream& os ) const
  {
    os << "container, content:\n";
    std::for_each(children_.begin(), children_.end(), boost::bind2nd(boost::mem_fun(&node::print), os));
    // oder auch:
    // std::copy(children_.begin(), children_.end(), std::ostream_iterator<node*>(os, " "));
    return os;
  }

private:
  std::list<node*>  children_;
};

class leaf : public node
{
public:
  virtual void operation1()
  {
    // perform operation1
  }

  // operation2 makes no sense for *leaf*

  virtual std::ostream& print( std::ostream& os ) const
  {
    return os << "leaf";
  }
};

edit:

// dein "Collector"

std::string collect( node const* n )
{
  std::ostringstream ss;
  n->print(ss);
  return ss.str();
}