哪个转换应与模板类参数dynamic_cast或reinterpet_cast一起使用？

Question

Could someone please help me?

As far as I know, reinterpet_cast should be avoided at all cost, because it is dangerous. However in my current situation it is the only cast that is working. Normally I would use dynamic_cast, because of inheritence, but the template class specialization does not let me to use dynamic_cast.

In the current situation, my program looks like this.

class Object {
public:
  virtual ~Object() = default;
};

template<typename SenderType, typename ...ArgumentType>
class EventCallback : public Object {
public:
  typedef void(SenderType::*Callback)(ArgumentType...);

  EventCallback(Callback callback, SenderType *sender)
    : m_callback{ callback }, m_sender{ sender } {
  }

  virtual ~EventCallback() = default;

  void operator()(ArgumentType ...args) {
    (m_sender->*m_callback)(args...);
  }
private:
  Callback m_callback;
  SenderType *m_sender;
};

template<typename SenderType, typename ...ArgumentType>
class Event : public Object {
public:
  virtual ~Event() = default;

  void operator+=(EventCallback<SenderType, ArgumentType...> callback) {
    m_callbacks.emplace_back(callback);
  }

  void operator()(ArgumentType ...args) {
    for (auto callback : m_callbacks) {
      callback(args...);
    }
  }

  private:
    std::vector<EventCallback<SenderType, ArgumentType...>> m_callbacks;
};    

class ApplicationView : public Object {
public:
  Event<Object> Activated;
  void Activate() {
    // activation logic ...
    Activated();
  }
};


class Application : public Object {
public:
  Application() {
    auto onViewActivated = EventCallback<Application>{&Application::OnViewActivated, this };
    m_view.Activated += reinterpret_cast<EventCallback<Object>&>(onViewActivated);
    m_view.Activate();
  }
  void OnViewActivated() {
  }
};

If I modify the above code to dynamic_cast, I get bad dynamic_cast exception. If I use reinterpet_cast, my code runs just fine.

Any suggestions?

Answer 1

This is not an answer to the questions asked, so my apologies to Rajmund, and I realize that this "answer" will likely be downvoted because of it.

I'm trying to show how to get rid of having the common Object class, and avoid using casts altogether. Too long to show in a comment, and code snippets do not format well in a comment anyway.

Should compile and run. I used C++17. I added some placeholder code, which was assumed in Rajmund's code. I added cout to show what is happening.

I do not normally write templates, so I'm expected that the template code could be made nicer. In particular, it could be nice if the dependent code could do Event<void()> instead of Event<function<void()>> ... I'll leave that as an exercise for the reader.

#include <functional>
#include <vector>
#include <iostream>

using std::function;
using std::vector;
using std::cout;
using std::endl;

template<typename F>
class Event
{
public:
  void operator+=(F callback)
  {
    m_callbacks.emplace_back(callback);
  }

  template <typename ...ArgumentTypes>
  void operator()(ArgumentTypes ...args)
  {
    // Need a copy, in case a callback adds more callbacks, or removes itself.
    // (I assume callbacks removing themselves, like C#, will be added.)
    auto temp_callbacks = m_callbacks;
    cout << "Event callback list has " << m_callbacks.size() << endl;
    for (auto callback : temp_callbacks)
    {
      cout << "Calling Event callback..." << endl;
      callback(args...);
    }
  }

private:
  vector<F> m_callbacks;
};

class ApplicationView final
{
public:
  Event<function<void()>> Activated;
  void Activate()
  {
    cout << "ApplicationView::Activate has just been called." << endl;
    Activated();
  }
};

class ApplicationViewProvider final
{
public:
  static ApplicationView CreateView();
};

ApplicationView ApplicationViewProvider::CreateView()
{
  return ApplicationView{};
}

class Application final
{
  friend int main();
  ApplicationView m_view;
public:
  Application() :
    m_view{ ApplicationViewProvider::CreateView() }
  {
    auto onViewActivated = [this]() { this->OnViewActivated(); };
    m_view.Activated += onViewActivated;
    m_view.Activate();
  }

  void OnViewActivated()
  {
    cout << "HURRAY! Application::OnViewActivated has been notified." << endl;
  }
};

int main()
{
  cout << "Making Application\n + hooks up OnViewActivated callback\n + calls view's Activate" << endl;
  Application application;
  cout << "\nCalling the view's Activate again, in main" << endl;
  application.m_view.Activate();
}