Module: Standard C++ Library Library: Input/output
basic_ostream
|
basic_fstream() char_type close() |
fd() int_type is_open() |
off_type open() pos_type |
rdbuf() traits_type ~basic_fstream() |
Class that supports reading and writing of named files or devices associated with a file descriptor
#include <fstream>
namespace std {
template<class charT, class traits = char_traits<charT> >
class basic_fstream;
}
The class template basic_fstream supports reading and writing to 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_iostream and can therefore use all the formatted and unformatted input and output functions.
namespace std {
template<class charT, class traits = char_traits<charT> >
class basic_fstream
: public basic_iostream<charT, traits> {
public:
typedef charT char_type;
typedef traits traits_type;
typedef typename traits_type::int_type int_type;
typedef typename traits_type::pos_type pos_type;
typedef typename traits_type::off_type off_type;
basic_fstream();
explicit basic_fstream(const char*,
ios_base::openmode = ios_base::in | ios_base::out);
// extensions:
explicit basic_fstream(const char*,
ios_base::openmode,
long);
explicit basic_fstream(int, char_type* = 0,
streamsize = /* default size */);
explicit basic_fstream(FILE*, char_type* = 0,
streamsize = /* default size */);
virtual ~basic_fstream();
basic_filebuf<char_type, traits_type> *rdbuf() const;
bool is_open() const;
void open(const char*, ios_base::openmode = ios_base::in);
// extensions:
int fd() const;
void open(const char*, ios_base::openmode, long);
void open(int, char_type* = 0,
streamsize = /* default size */);
void open(FILE*, char_type* = 0,
streamsize = /* default size */);
void close();
};
}
char_type
The type char_type is a synonym for the template parameter charT.
int_type
The type int_type is a synonym of type traits_type::in_type.
off_type
The type off_type is a synonym of type traits_type::off_type.
pos_type
The type pos_type is a synonym of type traits_type::pos_type.
traits_type
The type traits_type is a synonym for the template parameter traits.
fstream
The type fstream is an instantiation of class basic_fstream on type char:
typedef basic_fstream<char> fstream;
wfstream
The type wfstream is an instantiation of class basic_fstream on type wchar_t:
typedef basic_fstream<wchar_t> wfstream;
basic_fstream();
Constructs an object of class basic_fstream, initializing the base class basic_iostream with the associated file buffer. This buffer is initialized by calling the basic_filebuf constructor:
basic_filebuf<char_type, traits_type>(rdbuf())
After construction, a file can be attached to the basic_fstream object by using the open() member function.
basic_fstream(const char* s,
ios_base::openmode mode =
ios_base::in | iosw_base::out);
Constructs an object of class basic_fstream, initializing the base class basic_iostream with the associated file buffer. This buffer is initialized by calling the constructor:
basic_filebuf<char_type, traits_type>(rdbuf())
The constructor then calls open(s, mode) in order to attach the file, whose name is pointed to by s, to the basic_fstream object.
basic_fstream(const char* s, ios_base::openmode mode,
long protection);
Constructs an object of class basic_fstream, initializing the base class basic_iostream with the associated file buffer. This buffer is initialized by calling the basic_filebuf constructor:
basic_filebuf<char_type, traits_type>(rdbuf())
The constructor then calls:
rdbuf()->open(s, mode, protection)
in order to attach the file, whose name is pointed to by s, to the basic_fstream object.
The third argument, protection, holds file permissions. It determines the file read/write/execute permissions under UNIX, but is more limited elsewhere.
NOTE -- The protection argument is not part of the C++ Standard, but is included here as a convenience extension. See Appendix B for a complete list of Rogue Wave extensions.
basic_fstream(int fd, char_type *buf, streamsize n);
Constructs an object of class basic_fstream, initializing the base class basic_iostream with the associated file buffer. This buffer is initialized by calling the basic_filebuf constructor:
basic_filebuf<char_type, traits_type>(rdbuf ())
The constructor then calls:
rdbuf()->open (fd, buf, n)
in order to attach the file descriptor fd to the basic_fstream object. If the function fails, it sets ios_base::failbit.
NOTE -- This function is not part of the C++ Standard, but is included here as an extension in order to manipulate pipes, sockets, or other UNIX devices that can be accessed through file descriptors. See Appendix B for a complete list of Rogue Wave extensions.
basic_fstream(FILE *fp, char_type* buf, streamsize n);
Constructs an object of class basic_fstream, initializing the base class basic_iostream with the associated file buffer. This buffer is initialized by calling the basic_filebuf constructor:
basic_filebuf<char_type, traits_type>(rdbuf ())
The constructor then calls:
rdbuf()->open (fp, buf, n)
in order to attach the file pointer fp to the basic_fstream object. If the function fails, it sets ios_base::failbit.
NOTE -- This function is not part of the C++ Standard, but is provided here as a convenience extension. See Appendix B for a complete list of Rogue Wave extensions.
virtual ~basic_fstream();
Destroys an object of class basic_fstream.
void close();
Calls rdbuf()->close(). If this function fails, it calls setstate(failbit).
int fd() const;
Returns the file descriptor associated with the stream.
NOTE -- This function is not part of the C++ Standard, but is provided here as a convenience extension. See Appendix B for a complete list of Rogue Wave extensions.
bool is_open() const;
Returns rdbuf()->is_open().
void
open(const char* s,
ios_base::openmode = ios_base::in | ios_base::out);
Calls rdbuf()->open(s, mode). If this function fails to open the file, it calls the basic_ios member function setstate(failbit).
void
open(const char* s,
ios_base::openmode, long protection);
Calls rdbuf()->open (s, mode, protection). If this function fails to open the file, it calls setstate(failbit).
The third argument, protection, holds file permissions. 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 permission.
NOTE -- The protection argument does not appear in the C++ Standard C++, but is included here as a convenience extension. See Appendix B for a complete list of Rogue Wave extensions.
void
open(int fd, char_type *buf = 0,
streamsize n = /* default size */);
Calls rdbuf()->open (fd, buf, n). If this function fails to open the file, it calls setstate(failbit).
NOTE -- This function is not part of the C++ Standard, but is provided here as a convenience extension. See Appendix B for a complete list of Rogue Wave extensions.
void
open(FILE *fp, char_type *buf = 0,
streamsize n = /* default size */);
Returns open(fileno (fp), buf, n). If this function fails to open the file, it calls setstate(failbit).
fileno is a UNIX98 function declared in <cstdio>.
NOTE -- This function is not part of the C++ Standard, but is provided here as a convenience extension. See Appendix B for a complete list of Rogue Wave extensions.
basic_filebuf<charT_type,traits_type>* rdbuf() const;
Returns a pointer to the basic_filebuf associated with the stream.
//
// fstream.cpp
//
#include <fstream> // for fstream
#include <iostream> // for cout, endl
#include <string> // for string
int main ( )
{
// create a bi-directional fstream object
std::fstream inout ("test_fstream.out",
std::ios::in | std::ios::out |
std::ios::trunc);
// write out three lines to the file
inout << "Dieses ist die Geschichte eines Mannes.\n"
<< "C'est l'histoire d'un homme.\n"
<< "This is the story of a man." << std::endl;
std::string line;
// seek back to the beginning of the file
inout.seekg (0);
// extract the first line
std::getline (inout, line);
// output the first line to standard output
std::cout << "\nDeutsch:\n" << line << std::endl;
// obtain current position in file
std::fstream::pos_type pos = inout.tellg ();
// extract the second line
std::getline (inout, line);
// output the second line to standard output
std::cout << "Français:\n" << line << std::endl;
// extract the third line
std::getline (inout, line);
// output the third line to standard output
std::cout << "English:\n" << line << std::endl;
// move the put sequence before the second line
inout.seekp (pos);
// replace the second and third lines
inout << "This is the story of a man.\n"
<< "C'est l'histoire d'un homme.";
// seek to the beginning of the file
inout.seekg (0);
// output the all content of the fstream object to stdout
std::cout << "\n" << inout.rdbuf () << std::endl;
return 0;
}
Program Output:
Deutsch: Dieses ist die Geschichte eines Mannes. Francais: C'est l'histoire d'un homme. English: This is the story of a man. Dieses ist die Geschichte eines Mannes. This is the story of a man. C'est l'histoire d'un homme.
char_traits, ios_base, basic_ios, basic_filebuf, basic_ifstream, basic_ofstream
ISO/IEC 14882:1998 -- International Standard for Information Systems --Programming Language C++, Section 27.8.1.11
Copyright (c) 1994-2006 Rogue Wave Software, a Quovadx Division.
Licensed under the Apache License, Version 2.0.
Contact Rogue Wave about documentation or support issues. You can also seek help from other developers through the Apache stdcxx community (see below).