Question

假设我有一个对象列表，objA。现在objA可以创造更多的objA，它们将彼此完全无关 - 它们并不关心最轻微的其他objA存在。我怎么能得到另一个objA创建的objA而不将objA存储在它的spawner中？我不想使用单例来表示objA列表。

示例：

class Container
{  
     list<Monster*> listOfMonsters;

     void UpdateAllMonsters()
     {
          foreach(Monster monster in listOfMonsters)
          {
              monster.Update();
          }
     }         

};

class Monster
{
    void Update()
    { 
         new Monster();
    }
};

我怎样才能在Update（）方法中创建Monster并将其粘贴在Containers listOfMonsters中？我只想要一个Container对象的实例浮动，并且怪物不应该对容器对象做任何事情。

我想到的一个解决方案是在Container和Monster之间创建一个中间对象，这样就只有一个Container对象的实例，而且怪物基本上只能访问Container对象的一个方法（添加到listOfMonsters）。

IE;

class Container
{  
     list<Monster*> listOfMonsters;

     void UpdateAllMonsters()
     {
          foreach(Monster monster in listOfMonsters)
          {
              monster.Update();
          }
     }         

     void AddToList(Monster* monster)
     {
         listOfMonsters.add(monster);
     }


};


class ContainerLiason
{
     private __Container*;

     AddToContainer(Monster* monster)
     {
         __Container.AddToList(monster);
     }
};

class Monster
{

    private ContainerLiason* __liason;
    void Update()
    { 
         __liason.AddToContainer(new Monster());
    }
};

还有其他想法或设计模式吗？另外一件事，上面的例子是一种设计模式，如果是这样的话会被调用什么？我只是问，因为在我知道他们被称为甚至是什么之前我曾经使用过单身人士。

Answer 1

工厂模式应该做你需要的。让容器（也就是工厂）不仅保存已创建对象的列表，还要处理对象创建本身：

class Factory {  
  list<shared_ptr<Monster>> listOfMonsters;
public:
  void UpdateAllMonsters() {
    for(auto pMonster : listOfMonsters)  {
      monster->Update();
    }
  }         

  shared_ptr<Monster> createMonster() {
    auto newMonster = make_shared<Monster>();
    listOfMonsters.push_back(newMonster);
    return newMonster;
  }
};

class Monster {
  shared_ptr<Factory> theFactory;
public:
  void Update() { 
    auto newMonster = theFactory->createMonster();
    // ...
  }
};

另请注意，您在C ++标记下询问 - 您的代码看起来并不像它

Answer 2

您的解决方案似乎就是那个，您只需要确保所有怪物在ContainerLiaison上都有相同的指针，如果需要，可以使用引用。

另一个解决方案是在每个怪物中有一个关于Containter的参考，但我认为你的ContainerLiason更好。

最后一个解决方案是静态元素和函数，但我不喜欢它。

我建议您保留解决方案

Answer 3

好的，所以你绝对不需要在这里使用单身。最简单的选择就是Update对MonsterContainer的引用作为参数。

class Container
{  
     using MonsterList = list<Monster*>; // you should use a shared container or shared_ptrs here instead I think.
     MonsterList listOfMonsters;

     void UpdateAllMonsters()
     {
          foreach(Monster monster in listOfMonsters)
          {
              monster.Update(listOfMonsters);
          }
     }         

};

class Monster
{
    // You should change the name of your function here. Update does not imply
    // creation to me. I would call it "CreateMonsterInList"
    void Update(MonsterList& monsterContainer)
    { 
         monsterContainer.add( new Monster() );
    }
}

跟踪其他对象创建的对象？

3 个答案: