我应该在这里使用 dynamic_cast 吗？

Question

好吧，我有下一个代码：

#include <type_traits>
#include <iostream>
#include <string>
#include <list>
#include <functional>

class base_main
{
public:
    virtual ~base_main()
    {
    }
    // some methods
};

class base_1 : virtual public base_main
{
    // some methods
};

class base_2 : virtual public base_main
{
    // some methods
};

class base_3 : virtual public base_main
{
    // some methods
};

class object : public base_1, public base_2, public base_3
{
    // some methods
};

// in other *hpp file

class object_controller_listener
{
public:
    virtual void object_created( base_main* o )
    {
        // well, i want to work only with base_1 and base_2 interfaces, but not with base_3, and also i don't want to know something about object class in this *hpp
        // is it good code design?
        auto* xxx = dynamic_cast<base_1*>( o );
    }
};

class objects_controller
{
    void create()
    {
        std::unique_ptr<object> obj;

        // ...
        
        for( auto listener : m_listeners )
            listener->object_created( obj.get()  );
    }

    std::list<object_controller_listener*> m_listeners;
};

int main()
{

}

问题是 - 我怎样才能只使用 base_1 和 base_2 接口？我应该为它们创建两个单独的侦听器，并在 create() 函数中发送两个事件，还是应该使用 dynamic_cast 进行向下转换并在 create() 函数中只发送一个事件？这是好的代码设计还是感觉像代码味道？

更新：

例如：base_1 - 是render_base 类，它包含渲染数据，并具有设置和获取该数据的功能 base_2 - 碰撞器基类，它包含对撞机数据，并具有设置和获取该数据的功能 base_3 是物理基类和 object 是所有这些类的继承。当我只想使用渲染类时，我使用创建事件，该事件仅将 render_base 类发送到 render_system，它仅适用于渲染对象并真正使用多态性。但是，如果我想在其他地方使用对撞机和物理对象，而不了解渲染 - 我如何在基类中使用多态性？

Answer 1

很难说应该选择哪种设计，因为这在很大程度上取决于应用程序的整体结构。

通常，我会避免使用签名为 virtual void object_created( base_main* o ) 的函数，在该函数中动态转换为 base_* 并直接在此函数中处理。因为函数签名是 API 文档的一部分。

所以我会为 base_1 和 base_2 创建不同的函数并调用它们。

如何做到这一点再次取决于整体结构。您可以创建一个辅助函数，将调用转发给其他函数（这只是一个快速实现，可能看起来像这样：

template <typename DestT, typename SrcT, typename T>
void forward_if(SrcT obj, T *o, void (T::*f)(DestT)) noexcept {
  if (auto tmp = dynamic_cast<DestT>(obj); tmp != nullptr) {
    (o->*f)(tmp);
  }
}

然后你可以这样使用它：

#include <iostream>
#include <vector>

class base_main {
public:
  virtual ~base_main() {}
};

class base_1 : virtual public base_main {};

class base_2 : virtual public base_main {};

class base_3 : virtual public base_main {};

class object : public base_1, public base_2, public base_3 {};

template <typename DestT, typename SrcT, typename T>
void forward_if(SrcT obj, T *o, void (T::*f)(DestT)) noexcept {
  if (auto tmp = dynamic_cast<DestT>(obj); tmp != nullptr) {
    (o->*f)(tmp);
  }
}

struct listener_base {
  virtual void object_created(base_main *o) = 0;
};

struct specific_listener : public listener_base {
  void object_created(base_main *o) override {
    forward_if<base_1 *>(o, this, &specific_listener::object_created);
    forward_if<base_2 *>(o, this, &specific_listener::object_created);
  }

  void object_created(base_1 *o) {
    std::cout << "object created base_1" << std::endl;
  }

  void object_created(base_2 *o) {
    std::cout << "object created base_2" << std::endl;
  }
};

int main() {
  std::vector<listener_base *> listeners;
  listeners.push_back(new specific_listener());
  object o;

  for (auto listener : listeners) {
    listener->object_created(&o);
  }

  return 0;
}