The OpenNET Project / Index page

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

Интерактивная система просмотра системных руководств (man-ов)

 ТемаНаборКатегория 
 
 [Cписок руководств | Печать]

basic_ofstream (3)
  • >> basic_ofstream (3) ( Solaris man: Библиотечные вызовы )
  • 
                           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
    
    
    
    


    Поиск по тексту MAN-ов: 




    Партнёры:
    PostgresPro
    Inferno Solutions
    Hosting by Hoster.ru
    Хостинг:

    Закладки на сайте
    Проследить за страницей
    Created 1996-2024 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру