Quote:
2) Instead of a direct type-query like GetItemType(), create capability queries, like isWieldable() which might return true for Weapons and false for all other Items. This gives you extra flexibility, because you could e.g. make Potions, Wands and Scrolls - but not Armor or Weapons - be isHoldable(). Sometimes, this points to a need to add a level to the inheritance hierarchy (i.e. HoldableItem), but sometimes it's not that clear-cut. But if you can avoid this approach (in favour of a better-designed inheritance scheme and/or the build-in RTTI with dynamic_cast), then you probably should avoid it. It often quickly degenerates into implementing your own RTTI instead of letting the language do it for you, and anyway you usually want member functions to do stuff(TM) when possible.

Quote:Original post by Deyja
Of course it does. It's in header '<list>', and it's called 'std::list'.

class A // polymorphic type{public:  virtual void poo();};class B{  std::vector<A*> list_of_A;  virtual void do_sthg_with_a_A(A *polymorphic_object);  public:  void do_sthg_with_the_list_of_A()  {    for(size_t i=0; i<list_of_A.size(); ++i)    {      do_sthg_with_a_A(list_of_A);    }  }};class A1: public A{ // blah blah};class A2: public A{ // blah blah}class B1: public B{ // blah blah}class B2: public B{ // blah blah}

// forward declarationsclass A1;class A2;// visitor classclass Visitor{public:  virtual void accept(A1 *a) = 0;  virtual void accept(A2 *a) = 0;  // and so on...};

class A{public:  virtual void visit(Visitor *visitor) = 0;};class A1: public A{public:  virtual void visit(Visitor *visitor)  {    // the "magic" is here. The compiler knows that the type of this    // is A1*, and thus will call the correct Visitor::accept() function.    visitor->accept(this);  }}class A2: public A{public:  virtual void visit(Visitor *visitor)  {    visitor->accept(this);  }}

class VisitorA1: public Visitor{public:  virtual void accept(A1 *a)   {     // we know we are handling a A1 object, let's call it's poo() function    a->poo();   }  virtual void accept(A2 *a)   {     // do nothing!  };};class B1: public B{  virtual void do_sthg_with_a_A(A *a)  {    VisitorA1 visitor;    a->visit(&visitor);  }};

class ItemVisitor{public:  virtual void accept(Weapon *w) = 0;  virtual void accept(Armor *a) = 0;  virtual void accept(Potion *p) = 0;  // ...};class Item{public:  virtual void visit(ItemVisitor* v) = 0;};class Weapon: public Item{public:  virtual void visit(ItemVisitor* v) { v->accept(this); }};class Inventory{  std::vector<Item*> items;public:  void equip_all_armors()  {    // this special visitor only implements accept(Armor*)    // and is used to equip all armors in the item list.     ItemVisitorEquipArmor visitor;    for (size_t i=0; i<items.size(); ++i)    {      items->visit(&visitor);    }  }};

Quote:Actually, it's in <slist> and is called std::slist. std::list is a doubly linked list (with reverse iterators and so on). While most people use it, slist is still preferable in most cases (less overhead).

Quote:Original post by Deyja

Quote:Actually, it's in <slist> and is called std::slist. std::list is a doubly linked list (with reverse iterators and so on). While most people use it, slist is still preferable in most cases (less overhead).

He asked for a 'linked list', not a 'singly linked list'.

slist is not standard, and thus is not preferable.