Класс содержащий объект типа ofstream - не компилится!

#include <fstream>
 
    class Monstr
    {
        private:
            std::ofstream out;
        public:
            Monstr() : out("test", std::ios::app | std::ios::out){}
            ~Monstr();
    };
 
 
int main(void)
{
    Monstr Y;
    Monstr X(Y);
    system("pause");
    return 0;
}

#include <iostream>
#include <fstream>
 
    class Monstr
    {
        private:
 
           int age;
 
        public:
 
            Monstr() : age ( 0 ){}
            Monstr( int age_ ) : age ( age_ ){}
            ~Monstr(){};
            void fileWork ( std::ofstream & f );
 
    };
 
     void Monstr::fileWork ( std::ofstream & f )
          {
                  f << age << std::endl;
          }
 
 
int main(void)
{
 
   Monstr obj ( 33 );
   Monstr obj2 ( 56 );
 
   std::ofstream out;
   out.open ( "C:\\test.txt"  );
 
   obj.fileWork ( out );
   obj2.fileWork ( out );
 
   out.close();
 
    system("pause");
    return 0;
}

#include <iostream>
#include <fstream>
 
    class Monstr
    {
        private:
 
           int age;
           char *fname;
           std::ofstream out;
           std::ifstream in;
 
    private:
 
        Monstr& operator=( const Monstr& src );
        Monstr( const Monstr& src );
 
    public:
 
         void 
               writeFile() 
           {
                out.open ( fname );
                 if ( ! out )
                 {
                     std::cerr << "Error in opening file for writing.";
                       exit ( -1 );
                 }
            
               out << age << std::endl;
               out.close();
           }
 
          void 
               readFile()
           {
                 in.open ( fname );
                 if ( ! in )
                 {
                     std::cerr << "Error in opening file for reading.";
                       exit ( -1 );
                 }
               int val = 0;
                        
                   in >> val ;
                   std::cout << val << std::endl; 
                   in.close();
           }
 
        public:
 
            Monstr( const char *fname_ = "C:\\file1.txt" , int age_ = 23 ) :
              age ( age_)
            {
                fname = new char [ strlen ( fname_) + 1 ];
                strcpy( fname, fname_);
            }
 
            ~Monstr()
            {
               delete[] fname;
            }    
 
    };
 
int main(void)
{
   Monstr obj ( "C:\\file1.txt" );
   Monstr obj2 ( "C:\\file2.txt" , 53 );
 
   obj.writeFile();
   obj.readFile();
 
   obj2.writeFile();
   obj2.readFile();
 
    system("pause");
    return 0;
}

Monstr obj; 
Monstr obj2 = obj; < ------ запрет 
Monstr obj3 (obj); < ------ запрет

std::ofstream out = std::ofstream out;  <  --------------- НЕЛЬЗЯ!!!!!

#include <fstream>
 
    class Monstr
    {
        private:
            std::ofstream * out;
        public:
            Monstr(){out = new std::ofstream ("test", std::ios::app | std::ios::out);}
            Monstr(const Monstr &);
            ~Monstr(){*out << "destructor" << std::endl; *out.close(); }
    };
 
    Monstr::Monstr(const Monstr & monstr)
    {
        out = monstr.out;
        *out << "constructor_copy" << std::endl;
    }
 
 
int main(void)
{
    Monstr Y;
    Monstr X(Y);
    system("pause");
    return 0;
}

private:
            std::ofstream  out;

   void    writeFile() 
        {
          std::ofstream  out;
       out.open ( "file.txt" , std::ios::app );
                if ( ! out )
                {
                     std::cerr << "Error in opening file.";
                      exit ( -1 );
                }
         
              out << age << std::endl;
               out.close();
         }

bool Monstr::writeFile(std::string filename) 
  {
    std::ofstream out(filename.c_str());
    if ( ! out ) return false;
    out << age << std::endl;
    return true;
  }

Monstr Obj;
if(! Obj.writeFile("1.txt") ) std::cerr<<"Error!!!"<<std::endl;

#include <boost/shared_ptr.hpp>

// tesssst.cpp: определяет точку входа для консольного приложения.
//
 
#include "stdafx.h"
//#include <boost/shared_ptr.hpp>
#include <fstream>
#include <memory>
 
    class Monstr
    {
        private:
 
            static int count;
            std::string file_name;
            std::shared_ptr<std::ofstream>out;
        public:
            Monstr(std::string file_name = "test") : out(new std::ofstream(file_name, std::ios::app | std::ios::out))
            {
                this->file_name = file_name;
            //  std::ofstream out(file_name, std::ios::app | std::ios::out);
                *out << "constructor" << std::endl;
                //(*out).close();
            }
            Monstr(const Monstr &);
            ~Monstr()
            {
                //std::ofstream out("test", std::ios::app | std::ios::out);
                *out << "destructor" << std::endl;
                (*out).close();
            }
            void OUT()const{ 
                //std::ofstream out("test", std::ios::app | std::ios::out); 
                count++; 
                (*out) << "count = " << count << std::endl;
            //  out.close();
            }   
    };
 
    int Monstr::count;
 
    Monstr::Monstr(const Monstr & monstr)
    {
        this->file_name = monstr.file_name;
        //std::ofstream out("test", std::ios::app | std::ios::out);
        out = monstr.out;
        (*out) << "constructor_copy" << std::endl;
    //  (*out).close();
    }
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    Monstr Y;
    Monstr X(Y);
    X.OUT();
    Y.OUT();
    system("pause");
    return 0;
}