zoukankan      html  css  js  c++  java
  • C++:流类库与输入输出

    7.2.1 C++的输入输出流
    ios:流基类(抽象类)
    istream:通用输入流类和其他输入流的基类
    ostream:通用输出流类和其他输出类的基类
    iostream:通用输入输出流类和其他输入输出流类的基类(以下的派生类对象有cin、cout、cerr、clog)
    ifstream:输入文件流类
    ofstream:输出文件流类
    fstream:输入输出文件流
    istrstream:输入字符串流类
    ostrstream:输出字符串流类
    strstream:输入输出字符串类
    iostream_withassign: 通用输入输出流类和其他输入输出流类iostream的的派生类

    7.2.2 预定义的流对象
    C++中包含几个预定义的流对象,它们是标准输入流对象cin、标准输出流对象cout
    、非缓冲型的标准出错流对象ceer、缓冲型的标准出错流对象clog

    cin是istream的派生类istream_withassign的对象,它与标准输入设备(通常是键盘)相联系。
    cout是ostream的派生类ostream_withassign的对象,它与标准输出设备(通常是显示器)相联系。
    ceer是ostream的派生类ostream_withassign的对象,它与标准错误输入设备(通常是显示器)相联系。
    clog是ostream的派生类ostream_withassign的对象,它与标准错误输入设备(通常是显示器)相联系。


    由于istream和ostream类都在头文件iostream中声明的,因此只要在程序中包含头文件iostream.h,C++程序开始时这四个标准流对象的构造函数都被自动调用。


    7.2.3 输入输出流的成员函数
    (1)put函数
    put函数用于输出一个字符格式:cout.put(char ch)
    例如:cout.put('A')===cout.put(65)===cout.put(25+40)

    (2)get函数
    get函数的功能与提取运算符>>类似,主要不同之处是get函数在读入数据时可以包括空白字符,而后者不可以。
    get函数的用于读入一个字符,调用形式:cin.get()

    (3)getline函数
    getline函数用于从输入流读取n-1个字符,赋给指定的字符数组(或字符指针指向的数组),然后插入一个字符串结束志" "。(" "可以用其他字符代替)

    getline函数格式:
    cin.getline(字符数组,字符个数n,终止标志字符)

    cin.getline(字符指针,字符个数n,终止标志字符)

    (4)ignore函数
    ignore函数的功能是跳过输入流的n个字符(默认的个数为1),或在遇到指定的终止符时 提前结束。
    调用格式:cin.ignore(n,终止字符)或cin.ignore()===cin.ignore(1,EOF)
    */

    //例子1:put和get函数

    #include<iostream>
    using namespace std;
    int main()
    {
     char ch;
     cout<<"Input:";
     while(cin.get(ch))   //读取输入的字符,直到结束为止 
      {
       cout.put(ch);      //输出字符 
      } 
      return 0;
    }
    /*
    程序运行结果是:
     input:123 abc xyz
     123 abc xyz 
    */

     //例子2:getline函数

    #include<iostream>
    using namespace std;
    int main()
    {
     char ch[20];
     cout<<"输入一行字符:"<<endl;
     cin.getline(ch,21,'t');
     cout<<ch<<endl;;
     return 0;
    }
    /*
    程序运行结果是:
    输入一行字符:
    shdfjsfefrsdfjt
    shdfjsfefrsdfj 
    */
     

    7.3.3 输入输出的格式控制

    1.用流成员函数进行输入输出格式控制。
    cppreference.com -> C++ I/O

    C++ I/O
    <iostream>库自动定义了一些标准对象:

    cout, ostream类的一个对象,可以将数据显示在标准输出设备上.
    cerr, ostream类的另一个对象,它无缓冲地向标准错误输出设备输出数据.
    clog, 类似cerr,但是它使用缓冲输出.
    cin, istream类的一个对象,它用于从标准输入设备读取数据.
    <fstream>库允许编程人员利用ifstream和ofstream类进行文件输入和输出.

    一些C++ I/O流(精度,判断等)的行为可以通过操作不同的标志来修改。

    Constructors 构造器
    bad() 如果出现错误则返回true
    clear() 清除状态标志
    close() 关闭一个流
    eof() 如果处于文件结尾处则返回true
    fail() 如果出现错误则返回true
    fill(char ch) 控制默认填充字符 //格式:char ios::fill(char ch) 调用格式:流对象.fill(ch)
    flags() 操作flags
    flush() 清空缓冲区
    gcount() 返回读取的最后一次输入的字符数
    get(char ch) 读取字符
    getline() 读取一行字符
    good() 如果没有出现过错误则返回true
    ignore() 读取字符并忽略指定字符
    open() 创建一个输入流
    peek() 检查下一个输入的字符
    precision(int n) 设置精度 //格式:int ios::percision(int n) 调用格式:流对象.precision(n)
    put(char ch) 写字符
    putback() 返回字符给一个流
    rdstate() 返回流的状态
    read() 读取字条符
    seekg() 在一个输入流中进行随机访问
    seekp() 在一个输出流中进行随机访问
    setf() 设置格式标志 //格式:long ios::setf(long flags) 调用格式:流对象.setf(ios::状态标志)
    sync_with_stdio() 同标准I/O同步
    tellg() 使用输入流读取流指针
    tellp() 使用输出流读取流指针
    unsetf() 清除格式标志 //格式:long ios::unsetf(long flags) 调用格式:流对象.unsetf(ios::状态标志)
    width(int n) 操作域宽度 //格式:int ios::width(int n) 调用格式:流对象.width(n)
    write() 写字符

    //流成员函数使用方法举例

    #include<iostream>
    using namespace std;
    int main()
    {
     cout<<"------------1----------
    ";
     cout.width(10);                     //设置域宽为10
     cout<<123<<endl;                    //输出整数123,占10位,默认为右对齐
     cout<<"------------2----------
    "; 
     cout<<123<<endl;                    //输出整数123,上面的width(10)已经不起作用,此时按系统默认的域宽输出
                                         //按数据实际长度输出 
     cout<<"------------3----------
    ";
     cout.fill('&');                     //设置填充字符为'&'
     cout.width(10);                     //设置域宽为10
     cout<<123<<endl;                    //输出整数123,占10位,默认为右对齐,填充字符为'&'
     cout<<"------------4----------
    "; 
     cout.setf(ios::left);               //设置左对齐
     cout<<123<<endl;                    //输出整数123,上面的width(10)已经不起作用,此时按系统默认的域宽输出
                                         //按数据实际长度输出
     cout<<"------------5----------
    "; 
     cout.precision(4);                  //设置实际的精度为4
     cout<<123.45678<<endl;              //以一般10进制形式输出,有效数字为4
     cout<<"------------6----------
    "; 
     cout.setf(ios::fixed);              //用固定点格式(固定小数位数)显示浮点数
     cout<<123.45678<<endl;              //以fixed形式输出,小数位数为4
     cout<<"------------7----------
    "; 
     cout.width(15);                     //设置域宽是15
     cout.unsetf(ios::fixed);            //消除固定点格式(固定小数位数)显示浮点数
     cout.setf(ios::scientific);         //用科学表示法格式(指数)显示浮点数
     cout<<123.45678<<endl;              //用科学表示法格式(指数)显示浮点数,小数点占4位
     cout<<"------------8----------
    ";
     int a=21;
     cout.setf(ios::showbase);           //输出整数时显示基数符号
     cout.unsetf(ios::dec);              //终止10进制的格式设置
     cout.setf(ios::hex);                //设置以16进制输出格式
     cout<<a<<endl;                      //以16进制输出a 
     return 0;                                      
    }
    /*
    程序运行结果是:
    ------------1----------                 
           123                               (域宽为10,默认为右对齐)
    ------------2----------
    123                                      (按照数据实际长度输出) 
    ------------3----------
    &&&&&&&123                               (域宽为10,默认为右对齐,空白处用'&'填充) 
    ------------4----------
    123                                      (按照数据实际长度输出,左对齐) 
    ------------5----------
    123.5                                    (以一般十进制形式输出时,有效数字为4) 
    ------------6----------
    123.4568                                 (以fixed形式输出时,小数点占4位) 
    ------------7----------
    1.2346e+02&&&&&                          (用指数格式输出,域宽位10,小数占4位,用‘&’填充) 
    ------------8----------
    0x15                                     (十六进制形式,以0x开头) 
    */ 

    2.使用预定义的操纵符进行输入输出格式控制

    使用ios类中的成员函数进行输入输出格式控制时,每个函数的调用需要写一条语句,而且
    不能将它们直接嵌入到输入输出语句中去,显然使用起来不方便。C++提供了一种进行输入
    输出格式控制的方法,这一方法使用了一种称之为操纵符(也称之为操作和控制符)的特殊函
    数。在很多情况下,使用操纵符进行格式化控制比用ios状态标志和成员函数更方便。

    所有不带形参的操纵符都定义在头文件iostream.h中,而带形参的操纵符则定义在头文件
    iomanip.h,因而使用相应的操作符就必须包含相应的头文件。

    表7.4 C++预定义的操作符
    //在头文件iostream中:
    dec 设置整数的基数为10 用于输入/输出
    hex 设置整数的基数为16 用于输入/输出
    oct 设置整数的基数为8 用于输入/输出
    ws 跳过开头的空白部分 用于输入
    endl 输出一个换行符并刷新输出流 用于输出
    ends 插入一个空字符null,通常结束字符串 用于输出
    flush 刷新一个输出流 用于输出

    //在头文件iomanip中:
    setbase(n) 设置整数的基数(0、8、10、16(0默认为十进制)) 用于输入/输出
    setfill(c) 设置c为填充字节,默认为空格 用于输出
    setprecision(n) 设置精度(一般十进制时,n为有效数字;有fixed时,n为小数位数) 用于输出
    setw(n) 设置域宽为n 用于输出
    setiosflags(f)设置由参数f指定的状态标志 用于输入/输出
    resetiosflags(f) 终止由参数f指定的状态标志 用于输入/输出

    操纵符setiosflags和resetiosflags要带上状态标志才能用。

    表7.5 部分带有状态标志的操纵符setiosflags和resetiosflags
    setiosflags(ios::left) 数据按域宽左对齐输出
    setiosflags(ios::right) 数据按域宽有对齐输出
    setiosflags(ios::fixed) 固定的小数点位数显示
    setiosflags(ios::scientific) 设置浮点数以科学表示法(即指数形式)显示
    setiosflags(ios::showbase) 在整数前加一个"+"号输出
    setiosflags(ios::uppercase) 在以科学表示法格式E和十六进制输出字母时以大写字母显示
    resetiosflags(f) 终止已经设置的状态标志,在括号应指定f的内容。
    //例7.5 预定义的操纵符的使用方法举例

    #include<iostream>
    #include<iomanip>
    using namespace std;
    int main()
    {
     cout<<setw(10)<<123<<567<<endl;
     cout<<123<<setiosflags(ios::scientific)<<setiosflags(ios::uppercase)<<setw(20)<<123.456789<<endl;
     cout<<123<<setw(10)<<hex<<123<<endl;
     cout<<123<<setw(10)<<oct<<123<<endl;
     cout<<123<<setw(10)<<hex<<123<<endl;
     cout<<resetiosflags(ios::scientific)<<setprecision(4)<<123.456789<<endl;
     cout<<setiosflags(ios::left)<<setfill('#')<<setw(8)<<123<<endl;
     cout<<resetiosflags(ios::left)<<setfill('$')<<setw(8)<<456<<endl;
     return 0;
    }
    /*
    程序运行结果是:
           123567
    123        1.234568E+02
    123        7B
    7B       173
    173        7B
    123.5
    7B######
    $$$$$1C8 
    */ 

    3. 使用用户自定义的操纵符进行输入输出格式控制

    若为输出流定义操纵符函数,则定义格式如下:
    ostream &操纵符名(ostream &stream)
    {
          自定义代码
          return stream;
    }

    若为输入流定义操纵符函数,则定义格式如下:
    istream &操纵符名(istream &stream)
    {
          自定义代码
          return stream;
    }
    stream可以用其它的标识符。

    //例7.6 用户自定义操纵符的使用办法1

    #include<iostream>
    #include<iomanip>
    using namespace std;
    ostream &output(ostream &stream)
    {
      stream.setf(ios::left);
      stream<<setw(10)<<hex<<setfill('&');
      return stream;
    }
    int main()
    {
     cout<<123<<endl;
     cout<<output<<123<<endl;
     return 0;
    }
    /*
    程序运行结果是:
    123
    7b&&&&&&&& 
    */

    //例7.7 用户自定义操纵符的使用办法2 

    #include<iostream>
    #include<iomanip>
    using namespace std;
    istream &input(istream &in)
    {
     in>>hex;
     cout<<"Enter number using hex formar:";
     return in;
    }
    int main()
    {
     int i;
     cin>>input>>i;
     cout<<"hex:"<<hex<<i<<"------dec:"<<dec<<i<<endl;
     return 0;
    }
    /*
    程序运行结果是:
    Enter number using hex formar:23ae
    hex:23ae------dec:9134
    */

    7.3.1 插入运算符和提取运算符

    cin>>变量; //输入
    cout<<常量或变量; //输出

    其实,在头文件iostream中有两组运算符函数分别对运算符">>"、"<<" 进行函数的重载。

    也即: istream& operator>>(istream &类型名);
           ostream& operator>>(ostream &类型名);
           
           例如:
                当系统执行 cout<<"this a oby" 的操作时,就调用了插入运算符重载函数
                 ostream& operator<<(ostream char*)
                 cout.operator<<("this a oby") 

    7.3.2 用户自定义类的输入输出
    1、重载(输出运算符)插入运算符 <<

    格式: ostream& operator<<(ostream &out, user_name &obj)
                 {
                  out<<obj.item1;  
                  out<<obj.item2;
                  out<<obj.item3;
                  ......
                  out<<obj.itemn; 
                  return out;
                 }
                 
                 user_name:用户自定义的类名;
                 out:ostream类对象的引用,即out是输出流对象,out可以改变 
                 item:用户自定义类型中的数据成员。

    2、重载(输出运算符)插入运算符 >> 

     格式: istream& operator<<(istream &cin, user_name &obj)
                 {
                  cin<<obj.item1;
                  cin<<obj.item2;
                  cin<<obj.item3;
                  ......
                  cin<<obj.itemn; 
                  return cin;
                 }
                 
                 user_name:用户自定义的类名;
                 cin:ostream类对象的引用,即cin是输出流对象,cin可以改变 
                 item:用户自定义类型中的数据成员。

    //举例

    #include<iostream>
    using namespace std;
    class Coord{
      public:
        Coord(int i=0,int j=0)
        {
         x = i;
         y = j;
        }
        friend istream& operator>>(istream &input,Coord &ob);   //声明提取运算符">>"的友元重载函数 
        friend ostream& operator<<(ostream &ouput,Coord &ob);   //声明插入运算符"<<"的友元重载函数 
      private:
        int x,y;    
    }; 
    istream& operator>>(istream &input,Coord &ob)
    {
      cout<<"输入x、y的值:";
      input>>ob.x;
      input>>ob.y;
      return input;
    }
    ostream& operator<<(ostream &ouput,Coord &ob)
    {
      cout<<"输出x、y的值:";
      ouput<<ob.x<<","<<ob.y<<endl;
      return ouput;
    }
    int main()
    {
     Coord a(55,66);
     cout<<a<<endl; //operator<<(cout,a) 
     
     cin>>a;        //operator>>(cin,a)
     cout<<a<<endl; 
     
     return 0; 
    }
  • 相关阅读:
    leetcode 190 Reverse Bits
    vs2010 单文档MFC 通过加载位图文件作为客户区背景
    leetcode 198 House Robber
    记忆化搜索(DP+DFS) URAL 1183 Brackets Sequence
    逆序数2 HDOJ 1394 Minimum Inversion Number
    矩阵连乘积 ZOJ 1276 Optimal Array Multiplication Sequence
    递推DP URAL 1586 Threeprime Numbers
    递推DP URAL 1167 Bicolored Horses
    递推DP URAL 1017 Staircases
    01背包 URAL 1073 Square Country
  • 原文地址:https://www.cnblogs.com/XYQ-208910/p/4912822.html
Copyright © 2011-2022 走看看