如何优雅解决含引用结构体的重新赋值问题？

我希望实现一个带有特定状态的消息处理类Handler。当准备消息时，需要创建一个引用新y数据的state_t结构体实例，并能通过同一个state变量访问该新对象。以下是使用指针实现的极简示例：

class Handler {
  int x;  // something config for the handler
  struct state_t {
    int *y;
    state_t(int *y) : y(y) {}
  };

  std::optional<state_t> state;

  Handler(int x) : x(x), state(std::nullopt) {}

  void prepare_message(int *y) {
    state = state_t(y);
  }

  void handle_state() {
    // do something with the y e.g. send it over a socket
  }

};

想知道是否有合适的方法用引用替代y的指针。直接替换会导致编译失败，因为结构体的拷贝赋值操作被隐式删除，能否通过优雅的方式解决这个问题？

因为C++的引用成员会导致类/结构体的默认拷贝赋值运算符被删除，而std::optional的赋值操作依赖于对象的拷贝或移动能力，直接用普通引用行不通，以下是几种实用优雅的解决思路：

方案1：用std::reference_wrapper包裹引用 #

std::reference_wrapper是标准库提供的可拷贝、可赋值的引用包装类，能完美适配std::optional的赋值需求，同时保留引用语义。修改后的代码如下：

#include <functional>
#include <optional>

class Handler {
  int x;
  struct state_t {
    std::reference_wrapper<int> y;
    state_t(int& y_ref) : y(y_ref) {}
  };

  std::optional<state_t> state;

public:
  Handler(int x_val) : x(x_val), state(std::nullopt) {}

  void prepare_message(int& y) {
    state = state_t(y);
  }

  void handle_state() {
    // 通过.get()获取原始引用
    int& y_ref = state->y.get();
    // 示例操作：使用y_ref处理数据
  }
};

方案2：为state_t实现移动赋值（仅需移动场景） #

如果不需要state_t的拷贝能力，只需要支持移动，可以手动实现移动构造和移动赋值运算符，让std::optional能正常完成赋值：

#include <optional>

class Handler {
  int x;
  struct state_t {
    int& y;
    // 移动构造函数
    state_t(state_t&& other) noexcept : y(other.y) {}
    // 移动赋值运算符
    state_t& operator=(state_t&& other) noexcept {
      // 引用绑定后无法更改，这里仅替换std::optional中存储的state_t实例
      return *this;
    }
    state_t(int& y_ref) : y(y_ref) {}
    // 显式删除拷贝相关操作（可选，让语义更清晰）
    state_t(const state_t&) = delete;
    state_t& operator=(const state_t&) = delete;
  };

  std::optional<state_t> state;

public:
  Handler(int x_val) : x(x_val), state(std::nullopt) {}

  void prepare_message(int& y) {
    state = std::move(state_t(y));
  }

  void handle_state() {
    int& y_ref = state->y;
    // 示例操作：使用y_ref处理数据
  }
};

方案3：简化结构，直接用std::optional<std::reference_wrapper<int>> #

如果state_t仅用于持有y的引用，没必要单独定义结构体，直接让state变量持有std::reference_wrapper<int>的optional即可，代码最简洁：

#include <functional>
#include <optional>

class Handler {
  int x;
  std::optional<std::reference_wrapper<int>> state;

public:
  Handler(int x_val) : x(x_val), state(std::nullopt) {}

  void prepare_message(int& y) {
    state = y;  // 自动构造std::reference_wrapper
  }

  void handle_state() {
    int& y_ref = state->get();
    // 示例操作：使用y_ref处理数据
  }
};

内容的提问来源于stack exchange，提问作者Materia Gravis