Administrace komentářů

No, já jsem se k tomuhle vláknu dostal naneštěstí až takhle pozdě, takže už další odpověď asi nikoho nezajímá. Ale mě zase nezajímá, že to nikoho nezajímá, takže si tu zkrátka uprdnu následující:

#include <iostream>
#include <string>

#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

namespace {
class FileOverwriter {
 public:
  FileOverwriter(const std::string& pathname)
      : path{pathname}, fd{[this]() {
          const int result{open(path.c_str(),
                                O_CREAT | O_WRONLY | O_TRUNC,
                                S_IRUSR | S_IWUSR)};
          if (result == -1) throw errno;
          std::cerr << "opened '" << path << "'\n";
          return result;
        }()} {}

  FileOverwriter(FileOverwriter&& old) : path(old.path), fd(old.fd) {
    old.fd = -1;
  }

  ~FileOverwriter() {
    if (fd != -1) {
      if (close(fd) == -1) {
        std::cerr << strerror(errno) << std::endl;
      }
      std::cerr << "still owning '" << path
                << "', closing it for real\n";
    } else {
      std::cerr << "no longer owning '" << path << "', not closing\n";
    }
  }

  FileOverwriter& operator<<(const std::string& what) & {
    write_to_fd(what);
    return *this;
  }

  const FileOverwriter& operator<<(const std::string& what) const& {
    write_to_fd(what);
    return *this;
  }

  FileOverwriter operator<<(const std::string& what) && {
    write_to_fd(what);
    return std::move(*this);
  }

 private:
  void write_to_fd(const std::string& what) const {
    const char* bufpos = what.c_str();
    size_t to_write = what.size();
    for (;;) {
      const ssize_t written = write(fd, bufpos, to_write);
      if (written == -1) throw errno;
      to_write -= written;
      if (!to_write) break;
      bufpos += written;
    }
  }

  const std::string path;
  int fd;
};

void WriteFooterAndClose(FileOverwriter o) {
  o << "this is at the end\n";
}

FileOverwriter WriteSomethingAndGiveItBack(FileOverwriter o) {
  o << "this is somewhere in the middle\n";
  return o;
}

void JustWriteBlahBlah(const FileOverwriter& o) {
  o << "blah\n"
    << "blah\n";
}
}  // namespace

int main() try {
  // A few std::move() experiments on /tmp/first.
  FileOverwriter o{"/tmp/first"};
  o << "o says blah\n";
  FileOverwriter p{std::move(o)};
  p << "p says blah\n";
  FileOverwriter q{WriteSomethingAndGiveItBack(std::move(p))};
  q << "q says blah\n";
  WriteFooterAndClose(std::move(q));

  // A somewhat temporary FileOverwriter on /tmp/second.
  FileOverwriter("/tmp/second") << "cheche\n"
                                << "blabla\n";

  // Full R-value crazinesss on /tmp/third.
  WriteFooterAndClose(
      WriteSomethingAndGiveItBack(FileOverwriter("/tmp/third")
                                  << "first line\n"
                                  << "second line\n")
      << "one more line"
      << "penultimate line; the end is near\n");

  // To also check the const-reference case (on /tmp/forth)...
  FileOverwriter r("/tmp/forth");
  JustWriteBlahBlah(r);
  // And we don't std::move `r` anywhere; let it die naturally.

  return 0;
} catch (int err) {
  std::cout << strerror(err) << std::endl;
  return 1;
}

Tohle^^^ "obaluje" soubor otevřený POSIXovým stylem pro zápis a zavře ho to jenom jednou, i přes různé předávání do/z funkcí a operátorů na všechny možné způsoby a strany.