当 Base 构造函数依赖于 Derived 的引用时构造函数初始化顺序

Question

我有一个基类，它通过缓冲将对象写入 std::ostream 。我想用 来调用它，

  Obj obj;
  flat_file_stream_writer<Obj> writer(std::cout);
  writer.write(obj);
  writer.flush();

但也用 来

  Obj obj;
  flat_file_writer<Obj> writer("filename.bin");
  writer.write(obj);
  writer.flush();

调用它。后一个调用必须建立一个 std::ofstream 实例，并在编写期间保持它，然后可以调用前一个版本。

我认为简单的非虚拟继承在这里就可以了。但我有构造函数初始化顺序问题。

warning: field 'ofstream_' will be initialized after base
      'flat_file_stream_writer<hibp::pawned_pw>' [-Wreorder-ctor]

因为基类依赖于对派生所持有的对象的引用，这看起来就像是先有鸡还是先有蛋，无法解决？

继承在这里只是错误的抽象吗？一个干净的替代品？

template <typename ValueType>
class flat_file_stream_writer {

  public:
    explicit flat_file_stream_writer(std::ostream& os, std::size_t buf_size = 100)
        : db_(os), buf_(buf_size) {}

    void write(const ValueType& value) {
        if (buf_pos_ == buf_.size()) flush();
        std::memcpy(&buf_[buf_pos_], &value, sizeof(ValueType));
        ++buf_pos_;
    }

    void flush() {  // could also be called in destructor?
        if (buf_pos_ != 0) {
            db_.write(reinterpret_cast<char*>(buf_.data()), // NOLINT reincast
                      static_cast<std::streamsize>(sizeof(ValueType) * buf_pos_));
            buf_pos_ = 0;
        }
    }

  private:
    std::ostream&          db_;
    std::size_t            buf_pos_ = 0;
    std::vector<ValueType> buf_;
};

template <typename ValueType>
class flat_file_writer : public flat_file_stream_writer<ValueType> {
  public:
    explicit flat_file_writer(std::string dbfilename)
        : dbfilename_(std::move(dbfilename)), dbpath_(dbfilename_),
          ofstream_(dbpath_, std::ios::binary), flat_file_stream_writer<ValueType>(ofstream_) {
        if (!ofstream_.is_open())
            throw std::domain_error("cannot open db: " + std::string(dbpath_));
    }

  private:
    std::string                        dbfilename_;
    std::filesystem::path              dbpath_;
    std::ofstream                      ofstream_;
};

Answer 1

您可以将 std::ofstream ofstream_; 放在单独的结构中，然后让 flat_file_writer 使用 private 从该结构继承。基类按照声明的顺序进行初始化，因此请确保在 flat_file_stream_writer 之前从该结构继承。现在，您可以在基类 flat_file_stream_writer 之前初始化 ofstream_。

经过仔细检查，我认为您可能希望将所有 3 个成员放入结构中。

请参阅下面的更新代码。

因此，这实际上意味着 ofstream_holder 中的 3 个成员现在位于 flat_file_writer 布局中的 flat_file_stream_writer 之前。

这似乎是正确的解决方案，不仅因为它“消除了编译器警告”，而且因为现在我们确实获得了正确的初始化顺序，即构造 std::ofstream first 和 then 将对它的引用传递给flat_file_stream_writer。在销毁期间，std::ofstream 将被销毁最后。

上面的原始代码完全是错误的，因为我们在派生构造函数初始值设定项中编写的顺序被忽略，而实际实现的顺序是布局顺序，即声明成员的顺序。

（尽管原始代码存在缺陷，但它对我来说“运行良好”，带有消毒剂等......但可能是UB？）。

template <typename ValueType>
class flat_file_stream_writer {

  public:
    explicit flat_file_stream_writer(std::ostream& os, std::size_t buf_size = 100)
        : db_(os), buf_(buf_size) {}

    void write(const ValueType& value) {
        if (buf_pos_ == buf_.size()) flush();
        std::memcpy(&buf_[buf_pos_], &value, sizeof(ValueType));
        ++buf_pos_;
    }

    void flush() {
        if (buf_pos_ != 0) {
            db_.write(reinterpret_cast<char*>(buf_.data()), // NOLINT reincast
                      static_cast<std::streamsize>(sizeof(ValueType) * buf_pos_));
            buf_pos_ = 0;
        }
    }

  private:
    std::ostream&          db_;
    std::size_t            buf_pos_ = 0;
    std::vector<ValueType> buf_;
};

struct ofstream_holder {
    explicit ofstream_holder(std::string dbfilename)
        : dbfilename_(std::move(dbfilename)), dbpath_(dbfilename_),
          ofstream_(dbpath_, std::ios::binary) {}

    std::string           dbfilename_;
    std::filesystem::path dbpath_;
    std::ofstream         ofstream_;
};

template <typename ValueType>
class flat_file_writer : private ofstream_holder, public flat_file_stream_writer<ValueType> {
  public:
    explicit flat_file_writer(std::string dbfilename)
            : ofstream_holder(std::move(dbfilename)), flat_file_stream_writer<ValueType>(ofstream_) {
        if (!ofstream_.is_open())
            throw std::domain_error("cannot open db: " + std::string(dbpath_));
    }
};