C++ Stream I/O-优快云博客

本文介绍了C++中的Stream输入输出概念及其应用，包括标准输入输出、格式化与非格式化I/O操作、字符串处理等内容，并详细探讨了浮点数精度控制及数值格式化方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C++ Stream I/O

1. Stream Input/Output

Standard Outputcout,cerr
Standard Inputcin
Formatting
Error handling
File I/O (later)

2. Stream I/O Applications

network communication
encryption
data compression
persistent storage of objects
character-oriented input and output

3. Stream Output Concept


    std::cout << "HELLO";
    std::cout << '\n';
    std::cout << 123;

Output stream buffer:

...

4. Stream Input Concept

Input stream buffer:

...


    int one;
    int two;
    std::cin >> one;
    std::cin >> two;

5. Using C++ Objects

Objects are C++variablesofuser-defined types. They are declared as
```
    typename object_name;
```

For example, ifShape3Dis a user-defined type, then we could try


    Shape3D widget;               // create object named "widget"

    widget.display( parameters ); // call member function with parameters

    widget.reset( );              // call member function without parameters

Dot-notation is used to access functions built into objects.

Alternatively, some objects may allow use of arithmetic operators. For example,


    std::cout << widget;          // display widget on console output device

6. Standard Output Stream


    typename      object name
    ------------  -----------
    std::ostream  std::cout;  // cout is a predefined object

Usage example:


    #include <iostream> // C++ standard library header

    using std::cout;    // cout declared inside std namespace

    int main()
    {
        int x = 65;
        cout << x;      // display value of number 65
        cout.put( x );  // display character 'A'
        return 0;
    }

    /* This program prints:
    65A
    */

7. Standard Output Stream, Cont.

std::coutis a pre-defined object
We need to
```
    #include <iostream>
```
to bringstd::coutinto our program
std::coutis attached to thestandard output device, which can be console display, file, or printer.
I/O redirection to file or printer is made easy:
```
CMD> myprogram > myfile.txt
```
The above command sends standard output tomyfile.txt

8. Formatted Output

C++ data types have OS- and hardware-specific internal representations...
- ...If we display anumeric valueusingformatted output, its value is properlyconvertedto a corresponding sequence of characters.
- ...If we display abool, we couldconvertits value to words"true"or"false".
Formatted Outputhandles value-to-text conversions for us:

7 8 9 ; 0 . 5 ; t r u e

For example,


#include <iomanip>
#include <iostream>
using std::cout;
using std::boolalpha;

int main( )
{
     int i = 789;
     double d = 0.5;
     bool b = true;

     cout << i;
     cout << ';';
     cout << d;
     cout << ';';
     cout << boolalpha << b;
     return 0;
}
/* Program output:
789;0.5;true
*/

9. Standard Input Stream


    typename      object name
    ------------  -----------
    std::istream  std::cin;    // cin is a predefined object

Usage:


    // formatted input of C++ variables
    int x;
    cin >> x;

    // unformatted input of single characters
    char x = cin.get( );

    // line-based input of text strings
    string text;
    getline( cin, text );

10. Standard Input Stream, Cont.

std::cinis a pre-defined object
We need to have
```
    #include <iostream>
```
to bringstd::cininto our program
std::cinis attached to astandard input device
Example of I/O redirection from file or another device:
```
    CMD> myprogram < myfile.txt
```
The above command gets standard input frommyfile.txt

11. Formatted Input

Formatted inputmeans

reading expected type and format
automatic whitespace processing


        #include <iostream>

        int main( )
        {
            int one;
            int two;
            std::cout << "Please enter two integers: ";
            std::cin >> one >> two;
            return 0;
        }

12. Unformatted I/O Example

Unformatted inputmeans

reading individual characters
discovering data type and format as you read


        #include <iostream>

        int main()
        {
            int onechar; // using int because char cannot represent EOF

            while ( ( onechar = std::cin.get() ) != EOF ) {
                std::cout.put( onechar );
            }

            return 0;
        }

13. What is EOF?

AcronymEOFstands for condition known asend of file.
When reading from a file, the condition occurs naturally at the end of file.
To keep things consistent, the condition is also triggered when user enters
```
    CTRL+Z (on Windows machine)

    CTRL+D (on Unix machine)
```
on the keyboard.
EOFis asymbolthat becomes defined after
```
    #include <iostream>
```

14. Unformatted I/O Summary

Unformattedis typically viewed as
- low-level I/O
- highest efficiency
- individual character processing
Input normally finishes atend-of-filemarker,EOF
Input proceeds regardless of multiple lines of text
Input has no automatic whitespace recognition


// Unformatted output
std::ostream std::cout;     // predefined

cout.put( c );              // single byte

cout.write( array, count ); // array of bytes



// Unformatted input
std::istream std::cin;      // predefined

c = cin.get( );             // single byte

cin.read( array, count );   // array of bytes

15. Formatted I/O

Floating-point values by default use fixed-point notation:


    #include <iostream>
    int main()
    {
      const double PI = 3.1415926;
      std::cout << PI << '\n';
      return 0;
    }
    /*
    Output: 3.14159
    */

16. Floating-point Precision

Floating-point values are printed withexact fraction part,as specified by theprecision.
Indefault notationformat, the precision specifiesmax number of meaningful digitsto display bothbefore and afterthe decimal point.
Thedefault precisionis 6 digits.
This means that the value is rounded to the best approximation while using 6 digits.
If necessary, the default format may change to scientific notation to preserve most accurate representation.

Precision can be changed by callingprecision()member function of the stream to improve data accuracy:


#include <iostream>
void main()
{
  const double PI = 3.1415926;
  std::cout.precision( 7 );
  std::cout << PI << '\n';
}
/*
Output: 3.141593
*/

17. Floating-point Manipulators

There are three possible ways to format floating point values:


    cout << value // default

    cout << fixed << value

    cout << scientific << value

Infixedandscientificnotations precision specifies exactlyhow many digits to displayafter the decimal point, even if they are trailing decimal zeros.

18. Floating-point Example


    #include <iostream>
    using namespace std;
    int main()
    {
        const double PI = 3.1415926;
        cout.precision( 7 );
        cout << fixed << "fixed format: " << PI << '\n';
        cout << scientific << "scientific format: " << PI << '\n';
        // back to default format:
        cout.unsetf( ios_base::fixed );
        cout.unsetf( ios_base::scientific );
        cout << "default format: " << PI << '\n';
        return 0;
    }
    /*
    Output:
    fixed format: 3.1415926
    scientific format: 3.1415926e+000
    default format: 3.141593
    */

19. C++ String

std::stringstores and manipulates text data
Add
```
    #include <string>
```
to bringstd::stringtype into our program


#include <iostream>
#include <string>
using namespace std;

int main()
{
    int qty;
    string units;

    // Formatted input of text:
    cout << "Qty and units: ";
    cin >> qty;
    cin >> units;

    cout << "You entered: ";
    cout << qty;
    cout << ' ';
    cout << units;
    cout << '\n';
    return 0;
}

20. Line-based Input, std::getline


    #include <iostream>
    #include <string>
    using namespace std;

    int main()
    {
        string text_line;

        // Line-based input of text:
        cout << "Type something: ";
        getline( cin, text_line );

        cout << "You typed: ";
        cout << text_line;
        cout << '\n';

        return 0;
    }

21. String Stream


    #include <cassert>
    #include <string> 
    #include <sstream> 
    int main()
    {
        const double PI = 3.1415926;
        double value;
        std::stringstream  buffer;  // text buffer
        buffer.precision( 8 );      // increase default precision (*)
        buffer << PI;               // formatted output  
        buffer >> value;            // formatted input
        assert( PI == value );
        std::string text; 
        text = buffer.str( );  // returns std::string  
        buffer.str( "" );      // clear buffer  
        return 0;
    }

(*) try commenting out precision change and see what happens

22. Low-level I/O using String Stream


    #include <cassert>
    #include <iostream>
    #include <sstream>
    using namespace std;
    int main()
    {
        stringstream buffer;
        int onechar; // because char cannot represent EOF
        cout << "Enter some text: ";
        while ( ( onechar = cin.get() ) != EOF ) {
            if ( onechar == '\n' ) {
                break; // exit loop at the end of the line

            } else if ( isalpha( onechar ) ) {
                buffer << "alpha: " << char( onechar ) << '\t' << onechar <<'\n';

            } else if ( isdigit( onechar ) ) {
                buffer << "digit: " << char( onechar ) << '\t' << onechar <<'\n';

            } else {
                buffer << "other: " << char( onechar ) << '\t' << onechar <<'\n';
            }
        }
        cout << buffer.str() << '\n'; // str() returns string
        return 0;
    }

23. Field Width

Manipulatorstd::setw( n )determines minimum output widthn.
Requires header
```
    #include <iomanip>
```

If output is shorter than thefield widthn, the output is padded withfill characters.


    #include <iostream>
    #include <iomanip>
    using namespace std;
    int main () {
        cout << setw( 40 ) << "Hello";
        return 0;
    }
    /*
    Output:
                                     Hello
    */

24. Fill Character

Fill charactercan be changed bysetfillmanipulator:


    #include <iostream>
    #include <iomanip>
    using namespace std;
    int main () {
        cout << setfill( '?' ) << setw( 40 ) << "Hello";
        return 0;
    }
    /*
    Output:
    ???????????????????????????????????Hello
    */

25. Field Alignment

leftappends fill characters at the end.

rightinserts fill characters at the beginning.


    #include <iostream>
    #include <iomanip>
    using namespace std;
    int main () {
        cout << left << setfill( '?' ) << setw( 40 ) << "Hello";
        return 0;
    }
    /*
    Output:
    Hello???????????????????????????????????
    */

26. Alignment of Numeric Fields

Adjusting numeric fields:


    #include <iostream>
    #include <iomanip>
    using namespace std;
    int main() {
      int x = -1234;
      cout << setw( 10 ) << internal << x << '\n';
      cout << setw( 10 ) << left     << x << '\n';
      cout << setw( 10 ) << right    << x << '\n';
      return 0;
    }
    /*
    Output:
    -     1234
    -1234
       -1234
    */

27. Scientific Notation

Scientific notation(exponential notation) adjusts specifieddecimal pointto the left or to the right according to the specified value of exponente.

Thee-suffix representstimes ten raised to the power. For example,

        1e-2 ==   0.01 == 1×10^-2

        1e-1 ==   0.10 == 1×10^-1

        1e-0 ==   1.00 == 1×10⁰

        1e+0 ==   1.00 == 1×10⁰

        1e+1 ==  10.00 == 1×10¹

        1e+2 == 100.00 == 1×10²

28. Normalized Scientific Notation

Normalized scientific notationexpects absolute partA^(*)of the numberA×10^bto be in the range
- 1 <=A< 10

Try the following program to convert numbers from scientific notation to ordinary decimal notation:


    #include <iostream>
    #include <iomanip>
    using namespace std;

    int main() {
        for (;;) {
            double dbl;
            cin >> dbl;
            cout << setw( 14 ) << showpoint << dbl << '\n';
        }
        return 0;
    }

________________

(*) the absolute partAis also known asmantissa.

29. More Manipulator Examples


#include <iostream>
#include <iomanip>
using namespace std;
int main() {
/*         5600 */ cout << setw( 14 )               << 56e2 << '\n';
/*      5600.00 */ cout << setw( 14 ) << showpoint  << 56e+2 << '\n';
/*2.345678e+002 */ cout << setw( 14 ) << scientific << 234.5678 << '\n';
/*          255 */ cout << setw( 14 )               << 255 << '\n';
/*           ff */ cout << setw( 14 ) << hex        << 255 << '\n'; 
/*          377 */ cout << setw( 14 ) << oct        << 255 << '\n';
/*            1 */ cout << setw( 14 )               << true << '\n';
/*         true */ cout << setw( 14 ) << boolalpha  << true << '\n';
/*  1234.567890 */ cout << setw( 14 ) << fixed      << 1234.56789 << '\n';
/*     1234.568 */ cout << setw( 14 ) << fixed << setprecision(3) << 1234.56789 << '\n';
    return 0;
}
/*
Output:
          5600
       5600.00
 2.345678e+002
           255
            ff
           377
             1
          true
   1234.567890
      1234.568
*/

30. Manipulators for Integer Data Types

The following areinteger output manipulators:
- boolalpha: use symbolic representation oftrueandfalsewhen inserting or extractingboolvalues. By default,boolvalues inserted and extracted as numeric values1and0.
- dec: insert or extract integer values in decimal (base 10) format.
- hex: insert or extract integer values in hexadecimal (base 16) format, such as "0xFF" or simply "FF".
- oct: insert or extract integer values in octal format, e.g. "077"
- showbase: insert a prefix that reveals the base of an integer value.
- noshowbase: reverse back to baseless integer output format.
Note: the above manipulators aresticky: they persist until another manipulator is applied.
The data type manipulators can be applied to bothinputandoutputstreams.

31. cin interpretation of 0 and 0x prefixes


    cin.unsetf( ios::dec ); // Interpret 0 and 0x as hexadecimal and octal prefixes
    cin.unsetf( ios::oct ); // Ignore octal prefix, interpret 077 as decimal 77

    cin.unsetf( ios::dec );
    cin.setf( ios::oct );   // All integers now expected to be octal base

    cin.unsetf( ios::dec );
    cin.setf( ios::hex );   // All integers now expected to be base-16:

Sample programcin_setf.cpp(download) illustrates integer base/prefix manipulation and rudimentary format-related error recovery.
See also<noindex><a href="http://www.cplusplus.com/reference/iostream/ios_base/setf.html" target="_blank"><tt>cin.setf()</tt></a></noindex>and<noindex><a href="http://www.cplusplus.com/reference/iostream/ios_base/unsetf.html" target="_blank"><tt>cin.unsetf()</tt></a></noindex>documentation.

32. Manipulators for Floating-point Data Types

showpoint: insert a decimal point unconditionally in a generated floating-point field.
fixed: insert floating-point values in fixed-point format. For example,
- default format for1234.56789is1234.57,
- fixed makes it1234.56789.
scientific: insert floating-point values in scientific format with an exponent field. For example,
- default format for1234.56789is1234.567,
- scientificmakes it1.234568e+03.

Note: the above manipulators aresticky: they persist until another manipulator is applied.

33. C++ Standard Library Objects


    typename           object name
    ------------       -----------
    std::ostream       std::cout; // predefined object
    std::istream       std::cin;  // predefined object
    std::string        text;      // text data
    std::stringstream  buffer;    // text buffer