//if I do a regular old : 
  while(( c = fh.get()) != EOF)
    cout.put(c);
//..it leaves fh with the 'eof' and 'fail' bits set....  I can fix that with:
  fh.clear();

//whch works ok , ...or I could find the current size of the file and use something like: 
   for(i = 0; i < size; i++) 
  {  c = fh.get();
     cout.put(c);   ...

// with no clear() which 'works just as well (?)'  I guess that's my question... 
// Which of those options would be the 'proper' way to go?
// I don't like seeng an 'error code' but going the extra step of finding size may be overkill...
// is this just matter of preference?  

#include <iostream> //  fstream-1.0.0.cpp  (experiments)
#include <fstream>
using namespace std;

int mygetfstat1(fstream * fp);
streamsize mygetsize(fstream * fp);

int main()
{
  char c, i;
  streamsize size;

  // declare and open file for reading and writing (and binary mode for blocks)
  fstream fh("infile", ios_base::in | ios_base::out | ios_base::binary);
  if ( (fh.rdstate() & ios::failbit ) != 0 )
    cerr << "Error opening 'test.txt'\n";

  cout << "--- test fstatus: --- #1: ";
  mygetfstat1( &fh ); //////////  is good

  fh << "Now is the time \nfor all good men \nto come to the aid of their party." << endl;

  cout << "--- test fstatus: --- #2: ";
  mygetfstat1( &fh ); //////////  is good!

  fh.seekp( 0, ios::beg );

  cout << "--- test fstatus: --- #3: ";
  mygetfstat1( &fh ); //////////  is good

  size = mygetsize( &fh );
  //while(( c = fh.get()) != EOF)  //this sets eof and fail errors, must clear()
  for(i = 0; i < size; i++)       // this works ok 
  {
    c = fh.get();
    cout.put(c);
  }

  cout << "--- test fstatus: --- #4: ";
  mygetfstat1( &fh ); //////////  is 'eof fail' if I use get() till EOF method

  //fh.clear();              // This clears any stream error-bits set

  // then I move and overwrite at a desired location...
  // this will not write anything if fh is in error state  
  fh.seekg( 0, ios::beg );
  fh.seekp( 35, ios::beg );
  fh << " ...dude, this gets complicated... "  ;                                 
  cout << "--- test fstatus: --- #5: ";
  mygetfstat1( &fh );  //////////  

  size = mygetsize( &fh );
  for(i = 0; i < size; i++)
  {
    c = fh.get();
    cout.put(c);
  }

  cout << "--- test fstatus: --- #6: ";
  mygetfstat1( &fh );

 fh.close();
  return 0;
}

/*          */
int mygetfstat1(fstream * fp)
{
  bool iostate;

  iostate = fp->rdstate();
  cout << " fp.rdstate() is: " << iostate << " which means: ";
  if( ( iostate ) == 0 )
    cout << "GOOD! ";
  if( ( iostate & ios::badbit  ) == 1 )
    cout << " BAD! ";
  if( ( iostate & ios::eofbit  ) == 2 )
    cout << " EOF! ";
  if( ( iostate & ios::failbit ) == 4 )
    cout << " FAIL! ";
  cout.put(0x0a);
  return iostate;
}

streamsize mygetsize( fstream * fp)
{
  streamsize curr, size;
  curr = fp->tellg();
  cout << "curr= " << curr << endl;
  fp->seekg( 0, ios::end);
  size = fp->tellg();
  cout << "size= " << size << endl;
  fp->seekg( 0, ios::beg);
  return size;
}

/*
[url]http://www.cplusplus.com/reference/iostream/ios/rdstate.html[/url]
Return Value
flag value      indicates
eofbit   End-Of-File reached while performing an extracting operation on an 
          input stream.
failbit  The last input operation failed because of an error related to the 
          internal logic of the operation itself.
badbit   Error due to the failure of an input/output operation on the stream
          buffer.
goodbit  No error. Represents the absence of all the above (the value zero).
*/

    fh.seekp(0, ios::end);