[ новости /+++ | форум | теги | ]

                       Standard C++ Library
             Copyright 1998, Rogue Wave Software, Inc.


NAME
     basic_ofstream

      - Supports writing into named files or other devices  asso-
     ciated with a file descriptor.



SYNOPSIS
     #include <fstream>
     template<class charT, class traits = char_traits<charT> >
     class basic_ofstream
     : public basic_ostream<charT, traits>



DESCRIPTION
     The  template  class  basic_ofstream<charT,traits>  supports
     writing  into named files or other devices associated with a
     file descriptor. It uses a basic_filebuf object  to  control
     the associated sequences. It inherits from basic_ostream and
     can therefore use all the formatted and  unformatted  output
     functions.



INTERFACE
     template<class charT, class traits = char_traits<charT> >
     class basic_ofstream
     : public basic_ostream<charT, traits> {

     public:

      typedef charT                       char_type;
      typedef traits                      traits_type;
      typedef typename traits::int_type   int_type;
      typedef typename traits::pos_type   pos_type;
      typedef typename traits::off_type   off_type;

      typedef basic_ios<charT, traits>    ios_type;

      basic_ofstream();
      explicit basic_ofstream(const char *s,
                              ios_base::openmode mode =
                              ios_base::out,
                              long protection = 0666);

      explicit basic_ofstream(int fd);
      basic_ofstream(int fd, char_type* buf, int len);

      virtual ~basic_ofstream();

      basic_filebuf<charT, traits> *rdbuf() const;

      bool is_open();
      void open(const char *s, ios_base::openmode mode =
                ios_type::out, long protection = 0666);

      void close();

     };



TYPES
     char_type


        The type char_type is a synonym for the template  parame-
        ter charT.



     off_type


        The type off_type is a synonym of type traits::off_type.



     ofstream


        The  type  ofstream  is   an   instantiation   of   class
        basic_ofstream on type char:

        typedef basic_ofstream<char> ofstream;



     int_type


        The type int_type is a synonym of type traits::in_type.


     ios_type


        The type ios_type is an instantiation of class  basic_ios
        on type charT.



     pos_type


        The type pos_type is a synonym of type traits::pos_type.



     traits_type


        The type traits_type is a synonym for the template param-
        eter traits.



     wofstream


        The  type  wofstream  is  an   instantiation   of   class
        basic_ofstream on type wchar_t:

        typedef basic_ofstream<wchar_t> wofstream;



CONSTRUCTORS
     basic_ofstream();


        Constructs        an        object        of        class
        basic_ofstream<charT,traits>, initializing the base class
        basic_ostream with the associated file buffer,  which  is
        initialized  by  calling  the  basic_filebuf  constructor
        basic_filebuf<charT,traits>(). After construction a  file
        can  be  attached  to the basic_ofstream_object using the
        open member function.



     basic_ofstream(const char* s,
                   ios_base::openmode mode= ios_base::in,
                   long protection= 0666);

        Constructs        an        object        of        class
        basic_ofstream<charT,traits>, initializing the base class
        basic_ostream with the associated file buffer,  which  is
        initialized  by  calling  the  basic_filebuf  constructor
        basic_filebuf<charT,traits>(). The constructor then calls
        the  open  function  open(s,mode,protection)  in order to
        attach the file whose name is pointed to  by  s,  to  the
        basic_ofstream object. The third argument, protection, is
        used as the file permissions. It does not appear  in  the
        Standard C++ description and is included as an extension.
        It determines  the  file  read/write/execute  permissions
        under  UNIX. It is more limited under DOS since files are
        always readable and do not have special  execute  permis-
        sion.



     explicit basic_ofstream(int fd);


        Constructs        an        object        of        class
        basic_ofstream<charT,traits>, initializing the base class
        basic_ostream with the associated file buffer,  which  is
        initialized  by  calling  the  basic_filebuf  constructor
        basic_filebuf<charT,traits>(). The constructor then calls
        the  basic_filebuf  open  function  open(fd)  in order to
        attach the  file  descriptor  fd  to  the  basic_ofstream
        object.  This  constructor  is  not  described in the C++
        standard, and is included as an  extension  in  order  to
        manipulate pipes, sockets, or other UNIX devices that can
        be accessed through file  descriptors.  If  the  function
        fails, it sets ios_base::failbit.



     basic_ofstream(int fd, char_type* buf,int len);


        Constructs        an        object        of        class
        basic_ofstream<charT,traits>, initializing the base class
        basic_ostream with the associated file buffer,  which  is
        initialized  by  calling  the  basic_filebuf  constructor
        basic_filebuf<charT,traits>(). The constructor then calls
        the  basic_filebuf  open  function  open(fd)  in order to
        attach the  file  descriptor  fd  to  the  basic_ofstream
        object. The underlying buffer is then replaced by calling
        the basic_filebuf member function setbuf with  parameters
        buf and len. This constructor is not described in the C++
        standard, and is included as an  extension  in  order  to
        manipulate pipes, sockets, or other UNIX devices that can
        be accessed through file descriptors. It  also  maintains
        compatibility  with  the  old  iostreams  library. If the
        function fails, it sets ios_base::failbit.



DESTRUCTORS
     virtual ~basic_ofstream();


        Destroys an object of class basic_ofstream.



MEMBER FUNCTIONS
     void
     close();


        Calls the associated basic_filebuf function  close()  and
        if  this  function  fails,  it calls the basic_ios member
        function setstate(failbit).



     bool
     is_open();


        Calls the associated basic_filebuf function is_open() and
        returns its result.



     void
     open(const char* s,ios_base::openmode =
              ios_base::out, long protection = 0666);


        Calls    the    associated     basic_filebuf     function
        open(s,mode,protection) and, if this function fails open-
        ing  the  file,  calls  the  basic_ios  member   function
        setstate(failbit).  The  third  argument,  protection, is
        used as the file permissions. It does not appear  in  the
        Standard C++ description and is included as an extension.
        It determines  the  file  read/write/execute  permissions
        under UNIX, and is more limited under DOS since files are
        always readable and do not have special  execute  permis-
        sion.

     basic_filebuf<charT,traits>*
     rdbuf() const;


        Returns a pointer to the  basic_filebuf  associated  with
        the stream.



EXAMPLE
     See basic_fstream, basic_ifstream  and  basic_filebuf  exam-
     ples.



SEE ALSO
     char_traits(3C++),_ios_base(3C++),          basic_ios(3C++),
     basic_filebuf(3C++),                   basic_ifstream(3C++),
     basic_fstream(3C++)

     Working Paper for Draft Proposed International Standard  for
     Information   Systems--Programming   Language  C++,  Section
     27.8.1.8



STANDARDS CONFORMANCE
     ANSI X3J16/ISO WG21 Joint C++ Committee

Партнёры:

Хостинг: