我应该在这里使用 dynamic_cast 吗？

Question

Well, i have next code:

#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()
{

}

The question is - how can i work only with base_1 and base_2 interfaces? Should i create two separate listeners for them, and send two events in create() function, or should i use dynamic_cast for downcasting and send only one event in create() function? Is this good code design or is this feels like code smell?

UPD:

For example: base_1 - is render_base class, which contains render data, and have functions for set and get this data base_2 - collider base class which contains collider data, and have functions for set and get this data base_3 is physic base class and object is inheritance of all this classes. And when i want work only with render class i use create event which send only render_base class to the render_system, which works only with renders objects and truly use polymorphism. But if i want in some other place work with collider and physic objects, without knowledge about render - how can i use polymorphism here in base classes?

Answer 1

It is hard to tell what design you should choose as this heavily depends on the overall structure of the application.

Generally, I would avoid having a function with the signature virtual void object_created( base_main* o ) in which you dynamically cast to base_* and work on that directly in this function. Because the function signature is part of the documentation of the API.

So I would create distinct functions for base_1 and base_2 and call those.

How to do that depends again on the overall structure. You could create a helper function, that forwards the call to the other functions (this is just a fast implementation how that could look like:

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);
  }
}

And then you could use it like this:

#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;
}