在此示例中，dynamic_cast是解决方案吗？

Question

The Problem

I have different classes that are some sort of Manager , ie, they manage classes called Entities . There may be a lot of different Manager classes, but they all have one method in common, addEntity .

Example:

class AManager
{
    addEntity(Entity e, AContract contract);
}

class BManager
{
    addEntity(Entity, BContract contract);
}

 ...

Now I want at any given time have the possibility to add a Entity to any of this classes, given that I also give the classe's Contract (class with only data) as well. Note that up until now there is no kind of inheritance whatsoever.

This classes should not be directly accessible to the user as well, so they are accessible from another class called ComponentManager , which stores references to this XManagers . So in the class ComponentManager I want to add this method.

enum class ManagerType
{
    A, B, // ...
}

class ComponentManager
{
public:
    addEntityToManager(Entity e, XContract, ManagerType type);
private:
    // References to all manager classes
} 

The reason I want to do that, is that it is not practical to create one different method for each Manager ( addEntityToXManager ), because there may be a lot of them. So it would be nice to just pass an Enum , and the correct method is called for me.

One solution that I though of was using dynamic_cast , where each XContract inherits from a BaseContract class:

class AManager
{
    addEntity(Entity e, BaseContract contract);
}

class BManager
{
    addEntity(Entity, BaseContract contract);
}

Now I could pass the contract to any of this classes, so I think I would have to use dynamic_cast to the correct contract so I can work with them.

• Is this a good solution?

Somehow this seems to me more like a hack than an actual solution, because any kind of Contract would be accepted.

Answer 1

如果我正确地理解了您的问题，就像您有多种管理器类型，而这些用户都不知道下层管理器类，那么为什么不使用工厂方法设计模式以便您可以轻松地插入新管理器呢？

Answer 2

I'm not sure if dynamic_cast is a good idea and how you decide what type to cast to? you can try template the method addEntityToManager and addEntity , for example something like this:

class   ContractA
{
public:
  std::string add()
  {
    return std::string("adding to contract A");
  }
};

class   ContractB
{
public:
  std::string add()
  {
    return std::string("adding to contract B");
  }
};

class   ManagerA
{
public:
  template<typename T>
  void  addEntity(T contract)
  {
    std::cout << "Manager A " << contract.add() << std::endl;
  }
};

class   ManagerB
{
public:
  template<typename T>
  void  addEntity(T contract)
  {
    std::cout << "Manager B " << contract.add() << std::endl;
  }
};

class   ComponentManager
{
public:
  template<typename T, typename U>
  void  addEntityToManager(T contract, U manager)
  {
    manager.addEntity(contract);
  }
};

and this test,

int     main()
{
  ManagerA manA;
  ManagerB manB;
  ContractA contA;
  ContractB contB;
  ComponentManager compM;

  compM.addEntityToManager(contA, manA);
  compM.addEntityToManager(contA, manB);
  compM.addEntityToManager(contB, manA);
  compM.addEntityToManager(contB, manB);

  return 0;
}

will produce output:

Manager A adding to contract A
Manager B adding to contract A
Manager A adding to contract B
Manager B adding to contract B

you can add template specializations where is needed :)