c++ - 哪个转换应该与模板类参数一起使用，dynamic_cast 还是 reinterpet_cast？

Question

有人可以帮帮我吗？

据我所知，应该不惜一切代价避免 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() {
  }
};

如果我将上面的代码修改为 dynamic_cast，我会得到 bad dynamic_cast 异常。如果我使用 reinterpet_cast，我的代码运行得很好。

有什么建议吗？

Answer 1

这不是所提问题的答案，所以我向 Rajmund 道歉，我意识到这个“答案”可能因此而被否决。

我正在尝试展示如何摆脱常见的 Object类，并避免完全使用强制转换。太长而无法在评论中显示，而且代码片段在评论中的格式也不好。

应该编译并运行。我用的是 C++17。我添加了一些占位符代码，这是在 Rajmund 的代码中假定的。我添加了 cout显示正在发生的事情。

我平时不写模板，所以希望模板代码可以做得更好。特别是，如果依赖代码可以执行 Event<void()> 就更好了而不是 Event<function<void()>> ...我将把它留给读者作为练习。

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