C++ 哪种类型的转换应该与模板类参数一起使用，dynamic\u cast还是reinterpet\u cast？

谁能帮帮我吗

据我所知，应该不惜一切代价避免使用reinterpet_cast，因为它很危险。然而在我目前的情况下，这是唯一一个有效的演员阵容。由于继承性的原因，通常我会使用dynamic_cast，但是模板类专门化不允许我使用dynamic_cast

在目前的情况下，我的程序是这样的

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

类对象{
公众：
virtual~Object（）=默认值；
};
模板
类EventCallback:公共对象{
公众：
typedef void（SenderType:：*回调）（ArgumentType…）；
EventCallback（回调回调，SenderType*sender）
：m_callback{callback}，m_sender{sender}{
}
virtual~EventCallback（）=默认值；
void运算符（）（ArgumentType…args）{
（m_发送方->*m_回调）（args…）；
}
私人：
回调mu回调；
发送者类型*m_发送者；
};
模板
类事件：公共对象{
公众：
virtual~Event（）=默认值；
void运算符+=（事件回调）{
m_回调。安置_回调（回调）；
}
void运算符（）（ArgumentType…args）{
for（自动回调：m_回调）{
回调（args…）；
}
}
私人：
std：：向量m_回调；
};    
类ApplicationView:公共对象{
公众：
事件激活；
无效激活（）{
//激活逻辑。。。
激活（）；
}
};
类应用程序：公共对象{
公众：
应用程序（）{
auto-onViewActivated=EventCallback{&Application:：onViewActivated，this}；
m_view.Activated+=重新解释强制转换（onViewActivated）；
m_view.Activate（）；
}
void OnViewActivated（）{
}
};

如果我将上述代码修改为dynamic_cast，则会出现错误的dynamic_cast异常。如果我使用reinterpet_cast，我的代码运行得很好

---

有什么建议吗？

这不是对所问问题的回答，所以我向拉杰蒙德道歉，我意识到这个“答案”可能会因此而被否决

我试图展示如何摆脱普通的

对象

类，并避免使用强制转换。太长，无法在注释中显示，而且代码段在注释中的格式也不好

应该编译并运行。我用的是C++17。我添加了一些占位符代码，这是Rajmund的代码中假定的。我添加了

cout

，以显示正在发生的事情

我通常不写模板，所以我希望模板代码可以变得更好。特别是，如果依赖代码可以执行

Event

而不是

Event

，那就更好了。。。我将把它作为练习留给读者

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

#包括
#包括
#包括
使用std：：函数；
使用std：：vector；
使用std：：cout；
使用std：：endl；
模板
班级活动
{
公众：
void运算符+=（F回调）
{
m_回调。安置_回调（回调）；
}
模板
void运算符（）（参数类型…参数）
{
//需要一个副本，以防回调添加更多回调或删除自身。
//（我假设将添加删除自身的回调，如C#）
自动临时回调=m_回调；
难道我不同意不惜一切代价避免重新解释强制转换吗？重新解释强制转换可能是一种最后手段，但确实有些时候你必须使用它。不编译。缺少
对象和
事件。这只是一个代码段。对象和事件是声明的。
事件
不是从
事件
。如果可以将前者转换为后者，则应编写自己的转换运算符。
reinterpret\u cast
正常工作，明天可能会自动停止工作。此处不需要重新解释\u cast或动态\u cast（或任何其他cast）。