• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            C++研究

            C++細節深度探索及軟件工程

              C++博客 :: 首頁 :: 新隨筆 :: 聯系 :: 聚合  :: 管理 ::
              37 隨筆 :: 0 文章 :: 74 評論 :: 0 Trackbacks



            Like C, C++ does not have built-in input/output capability. All C++ compilers, however, come bundled with a systematic, object-oriented I/O package, known as the iostream classes. The stream is the central concept of the iostream classes. You can think of a stream object as a smart file that acts as a source and destination for bytes. A stream's characteristics are determined by its class and by customized insertion and extraction operators.

            Through device drivers, the disk operating system deals with the keyboard, screen, printer, and communication ports as extended files. The iostream classes interact with these extended files. Built-in classes support reading from and writing to memory with syntax identical to that for disk I/O, which makes it easy to derive stream classes.


            Chang Xinglong , Computer Sci & tec
            TianJin university , 300072
            TianJin ,China

            Msn: cxl82116@msn.com QQ:286259397

            OutputStreams

            An output stream object is a destination for bytes. The three most important output stream classes are ostream, ofstream, and ostrstream.

            The ostream class, through the derived class basic_ostream, supports the predefined stream objects:

            • cout   standard output

            • cerr   standard error with limited buffering

            • clog   similar to cerr but with full buffering

            Objects are rarely constructed from ostream; predefined objects are generally used. In some cases, you can reassign predefined objects after program startup. The ostream class, which can be configured for buffered or unbuffered operation, is best suited to sequential text-mode output. All functionality of the base class, ios, is included in ostream. If you construct an object of class ostream, you must specify a streambuf object to the constructor.

            The ofstream class supports disk file output. If you need an output-only disk, construct an object of class ofstream. You can specify whether ofstream objects accept binary or text-mode data when constructing the ofstream object or when calling the open member function of the object. Many formatting options and member functions apply to ofstream objects, and all functionality of the base classes ios and ostream is included.

            If you specify a filename in the constructor, that file is automatically opened when the object is constructed. Otherwise, you can use the open member function after invoking the default constructor.

            Like the run-time function sprintf, the ostrstream class supports output to in-memory strings. To create a string in memory using I/O stream formatting, construct an object of class ostrstream. Because ostrstream objects are write-only, your program must access the resulting string through a pointer to char.

            You can construct an output file stream in one of two ways:

            Use the default constructor, and then call the open member function.

            ofstream myFile; // Static or on the stack
            myFile.open( "filename" );

            ofstream
            * pmyFile = new ofstream; // On the heap
            pmyFile->open( "filename" );
             
            //Specify a filename and mode flags 
            in the constructor call. 

            ofstream myFile( 
            "filename", ios_base::out);
             


            To construct an output string stream, you can use one of two ostrstream constructors. One dynamically allocates its own storage, and the other requires the address and size of a preallocated buffer.

            The dynamic constructor is used in the following way:

            char* sp;
            ostrstream myString;
            mystring 
            << "this is a test" << ends;
            sp 
            = myString.str();  // Get a pointer to the string


            The ends "manipulator" adds the necessary terminating null character to the string.

            The constructor that requires the preallocated buffer is used in the following way:

            char s[32];
            ostrstream myString( s, 
            sizeof( s ) );
            myString 
            << "this is a test" << ends; // Text stored in s


            Input Streams :

            An input stream object is a source of bytes. The three most important input stream classes are istream, ifstream, and istrstream.

            The istream class is best used for sequential text-mode input. You can configure objects of class istream for buffered or unbuffered operation. All functionality of the base class, ios, is included in istream. You will rarely construct objects from class istream. Instead, you will generally use the predefined cin object, which is actually an object of class ostream. In some cases, you can assign cin to other stream objects after program startup.

            The ifstream class supports disk file input. If you need an input-only disk file, construct an object of class ifstream. You can specify binary or text-mode data. If you specify a filename in the constructor, the file is automatically opened when the object is constructed. Otherwise, you can use the open function after invoking the default constructor. Many formatting options and member functions apply to ifstream objects. All functionality of the base classes ios and istream is included in ifstream.

            Like the library function sscanf, the istrstream class supports input from in-memory strings. To extract data from a character array that has a null terminator, allocate and initialize the string, then construct an object of class istrstream.

            If you are using an input file stream (ifstream), you must associate that stream with a specific disk file. You can do this in the constructor, or you can use the open function. In either case, the arguments are the same.

            You generally specify an ios_base::openmode flag when you open the file associated with an input stream (the default mode is ios::in). For a list of the open_mode flags, see The open Function. The flags can be combined with the bitwise OR ( | ) operator.

            To read a file, first use the fail member function to determine whether it exists:

             

            istream ifile( "FILENAME" );
            if ( ifile.fail() )
            // The file does not exist ...


            The Get Function:

            The unformatted get member function works like the >> operator with two exceptions. First, the get function includes white-space characters, whereas the extractor excludes white space when the skipws flag is set (the default). Second, the get function is less likely to cause a tied output stream (cout, for example) to be flushed.

            A variation of the get function specifies a buffer address and the maximum number of characters to read. This is useful for limiting the number of characters sent to a specific variable, as this example shows:

            / ioo_get_function.cpp
            // compile with: /EHsc
            // Type up to 24 characters and a terminating character. 
            // Any remaining characters can be extracted later.
            #include <iostream>
            using namespace std;

            int main()
            {
               
            char line[25];
               cout 
            << " Type a line terminated by carriage return\n>";
               cin.
            get( line, 25 );
               cout 
            << line << endl;
            }

             

            Input
              
            1234
             

            Sample Output

            1234
             


            The getline Function
            The getline member function is similar to the get function. Both functions allow a third argument that specifies the terminating character for input. The default value is the newline character. Both functions reserve one character for the required terminating character. However, get leaves the terminating character in the stream and getline removes the terminating character.

            The following example specifies a terminating character for the input stream:

             

            // getline_func.cpp
            // compile with: /EHsc
            #include <iostream>
            using namespace std;

            int main( )
            {
               
            char line[100];
               cout 
            << " Type a line terminated by 't'" << endl;
               cin.getline( line, 
            100't' );
               cout 
            << line;
            }

             

            Input
              
            test
             

            The close Function for Input Streams

            The close member function closes the disk file associated with an input file stream and frees the operating system file handle. The ifstream destructor closes the file for you, but you can use the close function if you need to open another file for the same stream object.


            [reference:  MSDN & Some other books about C++ Basic]

            posted on 2007-06-20 03:09 常興龍 閱讀(6899) 評論(3)  編輯 收藏 引用 所屬分類: STL

            評論

            # re: C++ streams (How to use ostream & istream ?) 2007-06-21 17:29 pass86
            英文比較好啊。  回復  更多評論
              

            # re: C++ streams (How to use ostream & istream ?) 2007-09-24 03:54 Gavin
            The article is good. But it lacks of some in-depth discussions, such as how buffered/unbuffered stream constructed/used/typical usage, what's the relationship/ownership between stream and streambuf,..., etc.

            Futher, I doubt that:
            ostrstream myString;
            mystring << "this is a test" << ends;
            sp = myString.str(); // Get a pointer to the string

            The ends "manipulator" adds the necessary terminating null character to the string.

            Is above conclusion is correct? and why??  回復  更多評論
              

            # re: C++ streams (How to use ostream & istream ?) 2008-07-22 12:12 踏雪赤兔
            C++ streams is too slow in my opinion~   回復  更多評論
              

            > hi的博客
            久久久久久久久久久久久久| 久久久噜噜噜久久熟女AA片| 亚洲国产精品久久久久| 久久综合九色综合97_久久久| 精品久久久久久中文字幕| 国产精品午夜久久| 亚洲精品午夜国产va久久| 99久久国语露脸精品国产| 久久久久99精品成人片牛牛影视 | 天天爽天天狠久久久综合麻豆| 久久午夜伦鲁片免费无码| 久久夜色tv网站| 亚洲av日韩精品久久久久久a| 亚洲国产精品久久久久网站 | 久久人人超碰精品CAOPOREN| 色综合久久久久无码专区| 国产精品成人99久久久久91gav| 日本五月天婷久久网站| 青青青国产精品国产精品久久久久| 亚洲日本va午夜中文字幕久久| 国产V亚洲V天堂无码久久久| 一本久道久久综合狠狠躁AV| 久久亚洲欧美日本精品| 久久久久久九九99精品| 久久久这里有精品| 久久久久无码精品国产app| 久久久久女人精品毛片| 午夜精品久久久久久中宇| 婷婷久久综合九色综合绿巨人| 亚洲欧美精品伊人久久| 国产成人久久精品激情| 色婷婷综合久久久久中文一区二区| 久久夜色撩人精品国产| 国产精品xxxx国产喷水亚洲国产精品无码久久一区 | 久久艹国产| 国产免费福利体检区久久| 99精品伊人久久久大香线蕉| 99久久国产亚洲高清观看2024| 国产午夜精品久久久久免费视| 国产欧美久久久精品| 久久99亚洲网美利坚合众国|