Can I use CreateFile, but force the handle into a std::ofstream?

Is there any way to take advantage of the file creation flags in the Win32 API such as FILE_FLAG_DELETE_ON_CLOSE or FILE_FLAG_WRITE_THROUGH as described here http://msdn.microsoft.com/en-us/library/aa363858(VS.85).aspx , but then force that handle into a std::ofstream?

The interface to ofstream is obviously platform independent; I'd like to force some platform dependent settings in 'under the hood' as it were.

From stackoverflow

• It is possible to attach a C++ std::ofstream to a Windows file handle. The following code works in VS2008:

  HANDLE file_handle = CreateFile(
      file_name, GENERIC_WRITE,
      0, NULL, CREATE_ALWAYS,
      FILE_ATTRIBUTE_NORMAL, NULL);
  
  if (file_handle != INVALID_HANDLE_VALUE) {
      int file_descriptor = _open_osfhandle((intptr_t)file_handle, 0);
  
      if (file_descriptor != -1) {
          FILE* file = _fdopen(file_descriptor, "w");
  
          if (file != NULL) {
              std::ofstream stream(file);
  
              stream << "Hello World\n";
  
              // Closes stream, file, file_descriptor, and file_handle.
              stream.close();
  
              file = NULL;
              file_descriptor = -1;
              file_handle = INVALID_HANDLE_VALUE;
          }
  }
  

  This works with FILE_FLAG_DELETE_ON_CLOSE, but FILE_FLAG_WRITE_THROUGH may not have the desired effect, as data will be buffered by the std::ofstream object, and not be written directly to disk. Any data in the buffer will be flushed to the OS when stream.close() is called, however.

  Steve Folly : Excellent (also works in VS2005)! One scenario I have is for writing some accounting information to a file on a USB with write-through. Because it'll be a quick open-write-close sequence, the call to close should ensure ofstream's buffer is flushed to the OS, right?

  ChrisN : Yes. I've updated the answer to mention this.

• Some of these flags are also available when using _fsopen / fopen:

  FILE* pLockFile = _fsopen(tmpfilename.c_str(), "w", _SH_DENYWR );
  if (pLockFile!=NULL
  {
     // Write lock aquired
     ofstream fs(pLockFile);
  }
  

  Here we open the file so when doing a flush, then it writes through (And it is deleted when closed):

  FILE* pCommitFile = fopen(tmpfilename.c_str(), "wcD");
  if (pCommitFile!=NULL)
  {
     // Commits when doing flush
     ofstream fs(pCommitFile);
  }