类的方法正在执行但智能指针删除对象时崩溃。

Question

我在C++内存管理和智能指针方面遇到了问题。我有一个代码来演示这个问题：

#include <memory>

class Closeable
{
 public:
  virtual void Close() = 0;
};

class DisconnectionHandler
{
 public:
  virtual void HandleDisconnection() = 0;
};

class EventHandler
{
 public:
  virtual void HandleEvent() = 0;
};

class Notifier
{
 public:
  virtual void OnDisconnection() = 0;
};

class RemoteSystem : public Closeable
{
 public:
  void SetReceiveDataEventHandler(const std::shared_ptr<EventHandler>& receive_data_event_handler) {
    this->receive_data_event_handler_ = receive_data_event_handler;
  }

  void Close() override { this->receive_data_event_handler_ = nullptr; }

  // In this example to simplify the code I just call this method from the main function.
  void OnDataReceived() { this->receive_data_event_handler_->HandleEvent(); }

 private:
  std::shared_ptr<EventHandler> receive_data_event_handler_;
};

class ReceiveDataEventHandler : public EventHandler
{
 public:
  explicit ReceiveDataEventHandler(const std::shared_ptr<DisconnectionHandler>& disconnection_handler)
      : disconnection_handler_(disconnection_handler) {}

  void HandleEvent() override {
    // Some code of receiving data.
    // But we can find out that connection was closed and we must call the disconnection handler.
    if (this->IsConnectionClosed()) {
      this->disconnection_handler_->HandleDisconnection();
      return;
    }
    // Some other stuff..
  }

 private:
  [[nodiscard]] bool IsConnectionClosed() const {
    // In the example code I just return true.
    return true;
  }

 private:
  const std::shared_ptr<DisconnectionHandler> disconnection_handler_;
};

class RemoteSystemDisconnectionHandler : public DisconnectionHandler
{
 public:
  explicit RemoteSystemDisconnectionHandler(const std::shared_ptr<Closeable>& closeable_remote_system,
                                            Notifier* notifier)
      : closeable_remote_system_(closeable_remote_system), notifier_(notifier) {}

  ~RemoteSystemDisconnectionHandler() { printf("Destructed.\n"); }

  void HandleDisconnection() override {
    this->closeable_remote_system_->Close();
    printf("Closed.\n");
    this->notifier_->OnDisconnection();
    printf("Notified.\n");
  }

 private:
  const std::shared_ptr<Closeable> closeable_remote_system_;
  Notifier* const notifier_;
};

class ClientNotifier : public Notifier
{
 public:
  void OnDisconnection() override { printf("Disconnected.\n"); }
};

int main() {
  ClientNotifier notifier;

  auto remote_system = std::make_shared<RemoteSystem>();

  {
    // Scope for losing references in the main function after SetReceiveDataEventHandler.
    auto disconnection_handler = std::make_shared<RemoteSystemDisconnectionHandler>(remote_system, &notifier);
    auto receive_data_event_handler = std::make_shared<ReceiveDataEventHandler>(disconnection_handler);
    remote_system->SetReceiveDataEventHandler(receive_data_event_handler);
  }

  // Only in the example.
  remote_system->OnDataReceived();

  return 0;
}

您也可以运行此代码。在本例中，程序在行this->notifier_->OnDisconnection()上崩溃。程序的输出：

Destructed.
Closed.
*crash*

这是因为在从ReceiveDataEventHandler调用方法RemoteSystem::Close时丢失了对RemoteSystemDisconnectionHandler的最后一次引用，因此，丢失了对RemoteSystemDisconnectionHandler的引用并删除了该对象。在Close方法和删除类RemoteSystemDisconnectionHandler和ReceiveDataEventHandler的两个对象之后，它返回到RemoteSystemDisconnectionHandler::HandleDisconnection方法并打印'Closed.‘对于输出，但由于对象已经被删除，下一行将发生错误，因为现在this被删除，而对它的任何访问都会发生内存异常。我还尝试在Java上重写这段代码，与C++不同，它工作得很好。那么，我想问你们，在C++社区中是否有解决这个问题的方法？我认为C++在内存管理方面没有问题，因为智能指针是存在的，但显然我错了。希望得到你的帮助！提前感谢！

Answer 1

一个简单的解决方案是在调用shared_ptr上的方法之前复制它：

    void OnDataReceived()
    { 
        auto temp = this->receive_data_event_handler_;
        if (temp)
        {
            temp->HandleEvent();
        }
    }

temp将使指针保持活动状态，直到方法调用完成为止。

但是，请注意，如果在实际代码中使用多个线程，std::shared_ptr并不是线程安全的，因此需要引入互斥锁来保护对receive_data_event_handler_的访问。

class RemoteSystem : public Closeable
{
public:
    void SetReceiveDataEventHandler(const std::shared_ptr<EventHandler>& receive_data_event_handler) {
        this->receive_data_event_handler_ = receive_data_event_handler;
    }

    void Close() override 
    { 
        std::unique_lock lock(mutex);
        this->receive_data_event_handler_ = nullptr;
    }

    // In this example to simplify the code I just call this method from the main function.
    void OnDataReceived()
    { 
        std::shared_ptr<EventHandler> temp;
        {
            std::unique_lock lock(mutex);
            temp = this->receive_data_event_handler_;
        }
        if (temp)
        {
            temp->HandleEvent();
        }
    }

private:
    std::shared_ptr<EventHandler> receive_data_event_handler_;
    std::mutex mutex;
};