精华内容
下载资源
问答
  • 标准输出流
    千次阅读
    2019-03-07 15:13:08

    java API,文档中给出的解释如下:

    out:

    “标准”输出流。此流已打开并准备接受输出数据。通常,此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。对于简单独立的 Java 应用程序,编写一行输出数据的典型方式是:System.out.println(data);

    err:
    “标准”错误输出流。此流已打开并准备接受输出数据。通常,此流对应于显示器输出或者由主机环境或用户指定的另一个输出目标。按照惯例,此输出流用于显示错误消息,或者显示那些即使用户输出流(变量 out 的值)已经重定向到通常不被连续监视的某一文件或其他目标,也应该立刻引起用户注意的其他信息。


    以上作者:captainCZY
    来源:CSDN
    原文:https://blog.csdn.net/captainCZY/article/details/79496959
    版权声明:本文为博主原创文章,转载请附上博文链接!

    标准输出和标准出错的一个区别是:标准输出往往是带缓存的,而标准出错没有缓存(默认设置,可以改)。

    所以如果你用标准出错打印出来的东西可以马上显示在屏幕,而标准输出打印出来的东西可能要再积累几个字符才能一起打印出来。

    所以二者在一起混合使用的时候可能会产生输出上的顺序问题。但他们自身单独使用不会产生这种问题

    在eclipse二者还有个区别是显示的颜色不同。

    更多相关内容
  • 标准输出流

    千次阅读 2018-11-03 21:00:10
    标准输出流是流向标准输出设备(显示器)的数据。ostream类定义了三个输出流对象:cout,cerr,clog。 (1)cout流对象: cout不是C++的关键字,是ostream流类的对象,在iostream中定义。用cout<<...

    标准输出流是流向标准输出设备(显示器)的数据。ostream类定义了三个输出流对象:cout,cerr,clog。

    (1)cout流对象:

    cout不是C++的关键字,是ostream流类的对象,在iostream中定义。用cout<<输出标准数据类型时,系统会根据类型调用与之匹配的运算符重载函数。cout流在内存中开辟了一个缓冲区,来存放流中的数据,当向cout流中插入一个endl时,不论缓冲区满了没,都立即输出流中的所有数据,然后插入一个换行符,并刷新流。

    (2)cerr流对象:

    cerr流被指定为与显示器关联,其作用是向标准错误设备输出有关出错信息。与cout不同的是cout可以被重定向输出到磁盘文件,而cerr流只能在显示器输出。

    #include<iostream>
    using namespace std;
    int main()
    {
    	cout<<"hello_cout"<<endl;
    	cerr<<"hello_cerr"<<endl;
    	return 0;
    }

    如上述程序cout输出到了桌面的一个test.txt的文件中,而cerr的信息输出到了cmd里面。

    (3)clog流对象:

    clog流对象也是标准错误流,它的作用和cerr相同。两者区别是cerr不经过缓冲区直接向显示器上输出相应信息,而clog中的信息存放在缓冲区中,缓冲区满后或遇endl后才向显示器输出。

    展开全文
  • 通过old标记的输出流,将system.out恢复至标准输出流 通过old标记的输出流,将system.out恢复至标准输出流 通过old标记的输出流,将system.out恢复至标准输出流
  • IO —— 标准输入流和标准输出流

    千次阅读 2016-07-24 08:26:33
    这一节讲解标准输入流和标准输出流。例1:示例了 syso 或者 sout 的深层道理,其实就是 PrintStream/** * Created by liwei on 16/7/19. */ /* * System.in 标准输入流。是从键盘获取数据的 * * 键盘录入数据的...

    说明:这里的标准不可以理解为“规范”。标准输入指键盘输入,标准输出指控制台输出。

    这一节讲解标准输入流和标准输出流。

    例1:示例了 syso 或者 sout 的深层道理,其实就是 PrintStream

    /**
     * Created by liwei on 16/7/19.
     */
    /*
     * System.in 标准输入流。是从键盘获取数据的
     *
     * 键盘录入数据的三种方法:
     *      A:main方法的args接收参数。
     *          java HelloWorld hello world java
     *      B:Scanner(JDK5以后的)
     *          Scanner sc = new Scanner(System.in);
     *          String s = sc.nextLine();
     *          int x = sc.nextInt()
     *      C:通过字符缓冲流包装标准输入流实现
     *          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
     */
    public class SystemInDemo {
    
        public static void main(String[] args) throws IOException{
    
            // //获取标准输入流
            // InputStream is = System.in;
            // //我要一次获取一行行不行呢?
            // //行。
            // //怎么实现呢?
            // //要想实现,首先你得知道一次读取一行数据的方法是哪个呢?
            // //readLine()
            // //而这个方法在哪个类中呢?
            // //BufferedReader
            // //所以,你这次应该创建BufferedReader的对象,但是底层还是的使用标准输入流
            // // BufferedReader br = new BufferedReader(is);
            // //按照我们的推想,现在应该可以了,但是却报错了
            // //原因是:字符缓冲流只能针对字符流操作,而你现在是字节流,所以不能是用?
            // //那么,我还就想使用了,请大家给我一个解决方案?
            // //把字节流转换为字符流,然后在通过字符缓冲流操作
            // InputStreamReader isr = new InputStreamReader(is);
            // BufferedReader br= new BufferedReader(isr);
            InputStream is = System.in;
            PrintStream pw = System.out;
            pw.println("今天是个好日子");
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入一个字符串:");
            // 代码执行到这一行发生阻塞
            String line = br.readLine();
            System.out.println("您输入的字符串是:" + line);
    
            System.out.println("请输入一个整数:");
            line = br.readLine();
            Integer i = Integer.parseInt(line);
            System.out.println("您输入的整数是:" + i);
    
    
        }
    
    }

    例2:标准输出流的清晰认识

    /*
     * 标准输入输出流
     * System类中的两个成员变量:
     *      public static final InputStream in “标准”输入流。
     *      public static final PrintStream out “标准”输出流。
     *
     *      InputStream is = System.in;
     *      PrintStream ps = System.out;
     */
    public class SystemOutDemo {
    
        public static void main(String[] args) {
            System.out.println("hello world");
    
            // 获取标准输出流对象
            // 有这里的讲解我们就知道了,这个输出语句其本质是IO流操作,把数据输出到控制台。
            PrintStream ps = System.out;
            ps.println("今天是你的生日中国");
            ps.println();
            ps.println("演唱:董文华");
    
            // ps.print();//这个方法不存在
    
            // System.out.println();
            // System.out.print();
        }
    }

    例3:转换流的应用

    /**
     * Created by liwei on 16/7/20.
     *
     * 转换流的应用
     */
    public class SystemOutDemo2 {
    
        public static void main(String[] args) throws IOException {
            // 获取标准输入流
            // // PrintStream ps = System.out;
            // // OutputStream os = ps;
            // OutputStream os = System.out; // 多态
            // // 我能不能按照刚才使用标准输入流的方式一样把数据输出到控制台呢?
            // OutputStreamWriter osw = new OutputStreamWriter(os);
            // BufferedWriter bw = new BufferedWriter(osw);
    
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
            bw.write("hello world");
            bw.newLine();
    
            bw.write("liwei");
            bw.newLine();
    
            bw.write("haha");
            bw.newLine();
    
            bw.flush();
            bw.close();
        }
    }
    
    展开全文
  • C++的输入和输出与标准输出流

    万次阅读 2016-09-20 11:23:35
    一、 C++ 输入输出的含义  以前所用到的输入和输出,都是以终端为对象的,即从键盘输入数据,运行结果输出到显示器屏幕上。从操作系统的角度看,每一个与主机... 1、对系统指定的标准设备的输入和输出。简称标准I/
    一、 C++ 输入输出的含义

       以前所用到的输入和输出,都是以终端为对象的,即从键盘输入数据,运行结果输出到显示器屏幕上。从操作系统的角度看,每一个与主机相连的输入输出设备都被看作一个文件。程序的输入指的是从输入文件将数据传送给程序,程序的输出指的是从程序将数据传送给输出文件。C++的输入与输出包括以下3方面的内容:
       1、对系统指定的标准设备的输入和输出。简称标准I/O。(设备)
       2、以外存磁盘(或光盘)文件为对象进行输入和输出。简称文件I/0。(文件)
       3、对内存中指定的空间进行输入和输出。简称串I/O。(内存)

       C++采取不同的方法来实现以上3种输人输出。 为了实现数据的有效流动,C++系统提供了庞大的I/O类库,调用不同的类去实现不同的功能。

    二、 C++的I/O对C的发展—类型安全和可扩展性

    C语言中I/O存在问题:
       1、在C语言中,用prinff和scanf进行输入输出,往往不能保证所输入输出的数据是可靠的、安全的。学过C语言的读者可以分析下面的用法:想用格式符%d输出一个整数,但不小心错用了它输出单精度变量和字符串,会出现什么情况?假定所用的系统int型占两个字节。
    printf("%d",i);   //i为整型变量,正确,输出i的值
    printf("%d",f);   //f为单精度变量,输出变量中前两个字节的内容
    printf("%d","C++");//输出字符串"C++”的起始地址

       编译系统认为以上语句都是合法的,而不对数据类型的合法性进行检查,显然所得到的结果不是人们所期望的。

       2、在用scanf输入时,有时出现的问题是很隐蔽的。如
    scanf("%d",&i); //正确,输入一个整数,赋给整型变量i
    scanf("%d",i);   //漏写&
       假如已有声明语句"int i=1",定义i为整型变量,其初值为1。编译系统不认为上面的scanf语句出错,而是将输入的值存放到地址为000001的内存单元中,这个错误可能产生严重的后果。

    注意:C++为了与C兼容,保留了用printf和scanf进行输出和输入的方法,以便使过去所编写的大量的C程序仍然可以在C++的环境下运行,但是希望读者在编写新的C++程序时不要用C的输入输出机制,而要用C++自己特有的输入输出方法。在C++的输入输出中,编译系统对数据类型进行严格的检查,凡是类型不正确的数据都不可能通过编译。因此C++的I/0操作是类型安全(typesafe)的。

       3、用printf和scanf可以输出和输入标准类型(如:int,float,double,char)的数据,但无法输出用户自己声明的类型(如数组、结构体、类)的数据。在C++中,会经常遇到对类对象的输入输出,显然无法使用printf和scanf来处理。C++的I/O操作是可扩展的,不仅可以用来输入输出标准类型的数据,也可以用于用户自定义类型的数据。C++对标准类型的数据和对用户声明类型数据的输入输出,采用同样的方法处理。显然,在用户声明了一个新类后,是无法用printf和scanf函数直接输出和输入这个类的对象的。

    解决办法:
       可扩展性是C++输入输出的重要特点之一,它能提高软件的重用性,加快软件的开发过程。
       C++通过I/O类库来实现丰富的I/0功能。这样使C++的输入输出明显地优于C语言中的pfintf和scanf,但是也为之付出了代价,C++的I/O系统变得比较复杂,要掌握许多细节。在本章中只能介绍其基本的概念和基本的操作,有些具体的细节可在日后实际深入应用时再进一步掌握。

    三、 C++的输入输出流

       输入和输出是数据传送的过程,数据如流水一样从一处流向另一处。C++形象地将此过程称为流(stream)。C++的输入输出流是指由若干字节组成的字节序列,这些字节中的数据按顺序从一个对象传送到另一对象。流表示了信息从源到目的端的流动。在输入操作时,字节流从输入设备(如键盘、磁盘)流向内存,在输出操作时,字节流从内存流向输出设备(如屏幕、打印机、磁盘等)。流中的内容可以是ASCII字符、二进制形式的数据、图形图像、数字音频视频或其他形式的信息。

       实际上,在内存中为每一个数据流开辟一个内存缓冲区,用来存放流中的数据。当用cout和插入运算符“<<”向显示器输出数据时,先将这些数据送到程序中的输出缓冲区保存,直到缓冲区满了或遇到endl,就将缓冲区中的全部数据送到显示器显示出来。在输入时,从键盘输入的数据先放在键盘缓冲区中,当按回车键时,键盘缓冲区中的数据输入到程序中的输入缓冲区,形成cin流,然后用提取运算符“>>”从输入缓冲区中提取数据送给程序中的有关变量。总之,流是与内存缓冲区相对应的,或者说,缓冲区中的数据就是流。

       在C++中,输入输出流被定义为类。C++的I/0库中的类称为流类(streamclass)。用流类定义的对象称为流对象。

       前面曾多次说明,cout和cin并不是C++语言中提供的语句,它们是iostream类的对象,在未学习类和对象时,在不致引起误解的前提下,为叙述方便,把它们称为cout语句和cin语句。正如C++并未提供赋值语句,只提供赋值表达式,在赋值表达式后面加分号就成了C++的语句,为方便起见,我们习惯称之为赋值语句。又如,在C语言中常用printf和scanf进行输出和输入,printf和scanf是C语言库函数中的输入输出函数,一般也习惯地将由printf和scanf函数构成的语句称为printf语句和scanf语句。在使用它们时,对其本来的概念要有准确的理解。

    1.iostream类库中有关的类
       C++编译系统提供了用于输人输出的iostream类库。iostream这个单词是由3个部分组成的,即i-o-stream,意为输入输出流。在iostream类库中包含许多用于输入输出的类。

       ios是抽象基类,由它派生出istream类和ostream类,两个类名中第1个字母i和。分 别代表输入(mput)和输出(output)。istream类支持输入操作,ostream类支持输出操作, iostream类支持输入输出操作。iostream类是从istream类和ostream类通过多重继承而派生的类。

       C++对文件的输人输出需要用ifstream和ofstream类,两个类名中第1个字母i和o分别代表输入和输出,第2个字母f代表文件(file)。ifstream支持对文件的输入操作,ofstream支持对文件的输出操作。类ifstream继承了类istream,类ofstream继承了类ostream,类fstream继承了类iostream。

       由图3可以看到:由抽象基类ios直接派生出4个派生类,即istream,ostream,fstreambase和strstreambase。其中fstreambase是文件流类基类,由它再派生出ifstream,ofstream和fstream。strstreambase是字符串流类基类,由它再派生出lstrstream,ostrsCeam和swsWeam类。
       I/0类库中还有其他一些类,但是对于一般用户来说,以上这些已能满足需要了。如果想深入了解类库的内容和使用,可参阅所用的C++系统的类库手册。在本章将陆续介绍有关的类。

    2、与iostream类库有关的头文件
       iostream类库中不同的类的声明被放在不同的头文件中,用户在自己的程序中用 #include命令包含了有关的头文件就相当于在本程序中声明了所需要用到的类。可以换一种说法:头文件是程序与类库的接口,iostream类库的接口分别由不同的头文件来实现。常用的有
    1. iostream 包含了对(标准)输入输出流进行操作所需的基本信息。
    2. fstream 用于用户管理的文件的I/0操作。
    3. sbsbeam 用于字符串流I/0。
    4. stdiostream 用于混合使用C和C++的I/0机制时,例如想将C程序转变为C++程序。
    5. iomamp 在使用格式化I/0时应包含此头文件。

    3、在iostream头文件中定义的流对象
       在iostream头文件中定义的类有:ios,istream,ostream,iostream,istream_withassign,stream_withassign,iostream_withassign等。
       iostream包含了对输入输出流进行操作所需的基本信息。因此大多数C++程序都包括iostream。在iostream头文件中不仅定义了有关的类,还定义了4种流对象,

       cin是istream的派生类istream_withassign的对象,它是从标准输入设备(键盘)输入到内存的数据流,称为cin流或标准输入流。cout是ostream的派生类ostream_withassign的对象,它是从内存输入到标准输出设备(显示器)的数据流,称为cout流或标准输出流。cerr和clog作用相似,均为向输出设备(显示器)输出出错信息。因此用键盘输入时用cin流,向显示器输出时用cout流。向显示器输出出错信息时用cerr和clog流。

       在iostream头文件中定义以上4个流对象用以下的形式(以cout为例):
    ostream cout(stdout);
    //在定义cout为ostream流类对象时,把标准输出设备stdout作为参数,这样它就与标准输出设备(显示器)联系起来
    cout<<3;//所以,就会在显示器的屏幕上输出3。
     
    4.在iostream头文件中重载运算符 
    

       “<<”和“>>”本来在C++中是被定义为左位移运算符和右位移运算符的,由于在iostream头文件中对它们进行了重载,使它们能用作标准类型数据的输入和输出运算符。所以,在用它们的程序中必须用#include命令把ostream包含到程序中。

    #include<iostream>

       在istream和ostream类(这两个类都是在头文件iostream中声明的)中分别有一组成员函数对位移运算符“<<”和“>>”进行重载,以便能用它输入或输出各种标准数据类型的数据。对于不同的标准数据类型要分别进行重载,如
    ostream operator<<(int); //用于向输出流插入一个int数据
    ostream operator<<(float);//用于向输出流插入一个float数据
    ostream operator<<(char); //用于向输出流插入一个char数据
    ostream operator<<(char *) //用于向输出流插入一个字符串数据
       等。如果在程序中有下面的表达式:         cout<<"C++";
       根据第5章所介绍的知识,上面的表达式相当于 cout.operator<<("C++")
       ”C++”的值是其首字节地址,是字符型指针(char *)类型,因此选择调用上面最后一个运算符重载函数,通过重载函数的函数体,将字符串插入到cout流中,函数返回流对象cout。
       在istream类中已将运算符“>>”重载为对以下标准类型的提取运算符:char,signed char,unsigned char,short,unsigned short,int,unsigned int,long,unsigned long,float, double,longdouble,char*,signedchar*,unsignedchar*等。
       在ostream类中将“<<”重载为插入运算符,其适用类型除了以上的标准类型外,还增加了一个void。类型。
       如果想将“<<”和“>>”用于自己声明的类型的数据,就不能简单地采用包含iostream头文件来解决,必须自己用第5章介绍的方法对“<<”和“>>”进行重载。
       怎样理解运算符“<<”和“>>”的作用呢?有一个简单而形象的方法:它们指出了数据移动的方向,例如:    >>a    // 箭头方向表示把数据放入a中。
    而:    <<a    // 箭头方向表示从a中拿出数据。

    标准输出流:标准输出流是流向标准输出设备(显示器)的数据。


    四、cout,cerr和clog流


    ostream类定义了3个输出流对象,即cout,cerr,clog。分述如下。

    1、cout流对象
       cout是console output的缩写,意为在控制台(终端显示器)的输出。

       1、cout不是C++预定义的关键字,它是ostream流类的对象,在iostream中定义。顾名思义,流是流动的数据,cout流是流向显示器的数据。cout流是容纳数据的载体,它并不是一个运算符。人们关心的是cout流中的内容,也就是向显示器输出什么。

       2、用"cout<<”输出基本类型的数据时,可以不必考虑数据是什么类型,系统会判断数据的类型,并根据其类型选择调用与之匹配的运算符重载函数。
       这个过程都是自动的,用户不必干预。如果在C语言中用prinf函数输出不同类型的数据,必须分别指定相应的输出格式符,十分麻烦,而且容易出错。C++的I/0机制对用户来说,显然是方便而安全的。
       3、cout流在内存中对应开辟了一个缓冲区,用来存放流中的数据。当向cout流插人一个endl时,不论缓冲区是否已满,都支即输出流中所有数据,然后插入一个换行符,并刷新流(清空缓冲区)。注意如果插入一个换行符,'\n'(如coot<<a<<'\n';),则只输出a和换行,而不刷新cout流(但并不是所有编译系统都体现出这一区别)。
       4、在iostream中只对“<<”和“>>”运算符用于标准类型数据的输入输出进行了重载,但未对用户声明的类型数据的输入输出进行重载。如果用户声明了新的类型,并希望用“<<”和“>>”运算符对其进行输入输出,应该按照第5章介绍的方法,对“<<”和“>>”运算符另作重载。

    2、cerr流对象
       cerr流对象是标准出错流。cerr流已被指定为与显示器关联。cerr的作用是向标准出错设备(standard error device)输出有关出错信息。cerr是console error的缩写,意为“在控制台(显示器)显示出错信息”。cerr与标准输出流cout的作用和用法差不多。但有一点不同:cout流通常是传送到显示器输出,但也可以被重定向输出到磁盘文件,而cerr流中的信息只能在显示器输出。当调试程序时,往往不希望程序运行时的出错信息被送到其他文件,而要求在显示器上及时输出,这时应该用cerr。cerr流中的信息是用户根据需要指定的。

    例1 有一元二次方程ax2+bx+c=0,其一般解为 x、1、2= ……但若a=0,或b^2-4ac<0时,用此公式出错。
       编程序,从键盘输入a,b,c的值,求x1和x2。如果a=0或b^2-4ac<0,输出出错信息。可写出以下程序:
    #include <iostream>
    #include <math.h>
    using namespace std;
    int main()
    {  
       float a,b,c,disc;
       cout<<"please input a,b,c:";
       cin>>a>>b>>c;
       if (a==0)
            cerr<<"a is equal to zero,error!"<<endl;//将出错信息插入cerr,屏幕输出
       else if ((disc=b*b-4*a*c)<0)
            cerr<<"disc=b*b-4*a*c<0"<<endl; //将出错信息插入cerr流,屏幕输出
       else
       {
            cout<<"x1="<<(-b+sqrt(disc))/(2*a)<<endl;
            cout<<"x2="<<(-b-sqrt(disc))/(2*a)<<endl;
        }
            return 0; 
    }

    3.clog流对象
       clog流对象也是标准出错流,它是console log的缩写。它的作用和cerr相同,都是在终端显示器上显示出错信息。它们之间只有一个微小的区别:ccrr是不经过缓冲区,直接向显示器上输出有关信息,而clog中的信息存放在缓冲区中,缓冲区满后或遇endl时向显示器输出。


    五、格式输出

       在输出数据时,为简便起见,往往不指定输出的格式,由系统根据数据的类型采取默认的格式,但有时希望数据按指定的格式输出,如要求以下六进制或八进制形式输出一个整数,对输出的小数只保留两位小数等;有两种方法可以达到此目的。一种是使用控制符;另一种是使用流对象的有关成员函数。分别叙述如下:

    1、 用控制符控制输出格式

    应当注意:这些控制符是在头文件iomanip中定义的,因而程序中应当包含头文件iomanip。通过下面的例子可以了解使用它们的方法,


    例2 用控制符控制输出格式,
    #include <iostream>
    #include<string>
    #include <iomanip> //不要忘记包含此头文件
    using namespace std;
    int main()
     { 
       int a;
       cout<<"input a:";
       cin>>a;
       cout<<"dec:"<<dec<<a<<endl; //以上进制形式输出整数
       cout<<"hex:"<<hex<<a<<endl; //以十六进制形式输出整数a
       cout<<"oct:"<<setbase(8)<<a<<endl;//以八进制形式输出整数a
       string pt= "China";         //pt指向字符串”China”
       cout<<setw(10)<<pt<<endl; //指定域宽为10,输出字符串
       cout<<setfill('*')<<setw(10)<<pt<<endl;//指定域宽10,输出字符串,空白处以“*”填充
       double pi=22.0/7.0; //计算pi值
       cout<<setiosflags(ios::scientific)<<setprecision(8);//按指数形式输出,8位小数
       cout<<"pi="<<pi<<endl; //输出pi值
       cout<<"pi="<<setprecision(4)<<pi<<endl;//改为4位小数
       cout<<"pi="<<setiosflags(ios::fixed)<<pi<<endl;//改为小数形式输出,精度为4 
       cout<<"pi="<<fixed<<pi<<endl;//fixed确定小数点后精度为4 
       return 0; 
    }
     
    运行结果如下:   inputa:34 (输入a的值)   dec:34 (十进制形式)   hex:22 (十六进制形)   oct:42 (八进制形式)   China (域宽为10)   ***** China (域宽为10,空白处以'*'填充)   pi=3.14285714e+00 (指数形式输出,8位小数)   pi=3.1429e+00) (指数形式输小,4位小数)   pi=3.143 (小数形式输出,精度仍为4)   pi=3.1429(fixed确定小数点后精度为4 ) 
    

    2.用流对象的成员函数控制输出格式   除了可以用控制符来控制输出格式外,还可以通过调用流对象cout中用于控制输出格式的成员函数来控制输出格式。  流成员函数setf和控制符setiosflags括号中的参数表示格式状态,它是通过格式标志来指定的。格式标志在类ios中被定义为枚举值。因此在引用这些格式标志时要在前面加上类名ios和域运算符“::”。例3 用流控制成员函数输出数据。
    #include <iostream>
    using namespace std;
    int main()
     { 
       int a=21;
       cout.setf(ios::showbase); //设置输出时的基数符号
       cout<<"dec:"<<a<<endl; //默认以十进制形式输出a
       cout.unsetf(ios::dec); //终止十进制的格式设置
       cout.setf(ios::hex); //设置以十六进制输出的状态
       cout<<"hex:"<<a<<endl; //以十六进制形式输出a
       cout.unsetf(ios::hex); //终止十六进制的格式设置
       cout.setf(ios::oct); //设置以八进制输出的状态
       cout<<"oct:"<<a<<endl; //以八进制形式输出a
       cout.unsetf(ios::oct); //终止以八进制的输出格式设置
       char *pt="China"; //pt指向字符串”china”
       cout.width(10); //指定域宽为10
       cout<<pt<<endl; //输出字符串
       cout.width(10); //指定域宽为10
       cout.fill('*'); //指定空白处以'*'填充
       cout<<pt<<endl; //输出字符串
       double pi=22.0/7.0; //计算pi值
       cout.setf(ios::scientific);//指定用科学记数法输出
       cout<<"pi="; //输出"pi="
       cout.width(14); //指定域宽为14
       cout<<pi<<endl; //输出"pi值
       cout.unsetf(ios::scientific); //终止科学记数法状态
       cout.setf(ios::fixed); //指定用定点形式输出
       cout.width(12); //指定域宽为12
       cout.setf(ios::showpos); //在输出正数时显示“+”号
       cout.setf(ios::internal); //数符出现在左侧
       cout.precision(6); //保留6位小数
       cout<<pi<<endl; //输出pi,注意数符“+”的位置
       return 0;
    }
    运行情况如下:
        dec:21 (十进制形式)
        hex:Oxl5 (十六进制形式,以0x开头)
        oct:025 (八进制形式,以O开头)
        China (域宽为10)
        *****china (域宽为10,空白处以'*'填充)
        pi=**3.142857e+00 (指数形式输出,域宽14,默认6位小数)
        ****3.142857 (小数形式输㈩,精度为6,最左侧输出数符“+”)

    说明:

       1、成员函数width(n)和控制符setw(n)只对其后的第一个输出项有效。如果要求在输出数据时都按指定的同一域宽n输出,不能只调用一次width(n),而必须在输出每一项前都调用一次width(n)。

       2、在表5中的输出格式状态分为5组,每一组中同时只能选用一种(例如,dec,hex和oct中只能选一,它们是互相排斥的),在用成员函数serf和控制符setiosflags设置输出格式状态后,如果想改设置为同组的另一状态,应当调用成员函数unsetf(对应于成员函数serf)或resetiosflags(对应于控制符sefiosflags),先终止原来设置的状态。然后再设置其他状态。
       同理,程序倒数第8行的unsetf函数的调用也是不可缺少的。读者不妨上机试一试。

       3、用serf函数设置格式状态时,可以包含两个或多个格式标志,由于这些格式标志在lOS类中被定义为枚举值,每一个格式标志以一个二进位代表,因此可以用“位或”运算符“I”组合多个格式标志

       4、可以看到:对输出格式的控制,既可以用控制符(如例2),也可以用cout流的有关成员函数(如例3),二者的作用是相同的。控制符是在头文件mmamp中定义的,因此用控制符时,必须包含iomanip头文件。cout流的成员函数是在头文件iostream中定义的,因此只需包含头文件iostream,不必包含iomanip。许多程序人员感到使用控制符方便简单,可以在一个cout输出语句中连续使用多种控制符。

       5、关于输山格式的控制,在使用中还会遇到一些细节问题,不可能在这里全部涉及。在遇到问题时,请查阅专门手册或上机试验一下即可解决。

    六、用流成员函数put输出字符

       在程序中一般用cout和插入运算符“<<”实现输出,cout流在内存中有相应的缓冲区。有时用户还有特殊的输出要求,例如只输出一个字符。ostream类除了提供上面介绍过的用于格式控制的成员函数外,还提供了专用于输出单个字符的成员函数put。如: cout.put('a');
       调用该函数的结果是在屏幕上显示一个字符a。put函数的参数可以是字符或字符的ASCII代码(也可以是一个整型表达式)。如: cout.put(65+32);
    也显示字符a,因为97是字符a的ASCII代码。

    可以在一个语句中连续调用put函数。如
          cout.put(71),put(79).put(79).put(68).put('\n');
    在屏幕上显示GOOD。

    例4 有一个字符串"BASIC",要求把它们按相反的顺序输出。
    程序如下:
    #include <iostream>
    using namespace std;
    int main()
     { 
       char *a="BASIC"; //字符指引指向'B'
       for(int i=4;i>=0;i--)
       cout.put(*(a+i)); //从最后一个字符开始输出
       cout.put('\n');
       return 0; 
    }
    运行时在屏幕上输出:
      CISAB

     例4也可以改用putchar函数实现。程序如下:
    #include<iostream> //也可以用#include<stdio.h>,同时不要下一行
    usmg namespace std;
    int main()
    { 
       char *a="BASIC";
       for(int i=4;i>=0;i--)
       putchar(*(a+i));
       putchar('\n');
    }

       运行结果与前相同,成员函数put不仅可以用COUT流对象来调用,而且也可以用ostream类的其他流对象调用。

    七、cin流

       在头文件iostream.h中定义了cin,cout,cerr,clog4个流对象,cin输人流,cout,cerr,clog是输出流。关于coutl,cerr,clog的使用方法已在上一讲中介绍。
       cin是istream类的对象,它从标准输入设备(键盘)获取数据,程序中的变量通过流提取符“>>”从流中提取数据。流提取符“>>”从流中提取数据时通常跳过输人流中的空格、tab键、换行符等空白字符。注意:只有在输入完数据再按回车键后,改行数据才被送人键盘缓冲区,形成输入流,提取运算符“>>”才能从中提取数据。需要注意保证从流中读取数据能雁常进行。
    例如:    int a,b;
        cin>>a>>b; // 若从键盘上输入 21 abc出错
    说明:
       只有在正常状态时,才能从输入流中提取数据。
       当遇到无效字符或遇到文件结束符(不是换行符,是文件中的数据已读完)时,输人流cin就处于出错状态,即无法正常提取数据。此时对cin流的所有提取操作都将终止。在IBMPC及其兼容机中,以Ctrl+Z表示文件结束符。在UNIX和Macintosh系统中,以Ctrl+D表示文件结束符。当输人流cin处于出错状态时,如果测试cin的值,可以发现它的值为false(假),即cia为O值。如果输入流在正常状态,cin的值为true(真),即cin为一个非0值。可以通过测试cin的值,判断流对象是否处于正常状态和提取操作是否成功。


    如:   if(!cin) //流cin处于出错状态,无法正常提取数据
    cout<<"error”;

    例5 通过测试cin的真值,判断流对象是否处于正常状态。
    #include <iostream>
    using namespace std;
    int main()
    { 
       float grade;
       cout<<"enter grade:";
       while(cin>>grade) //如果能从cin流读取数据cin的值为真,执行循环体
       { 
         if(grade>=85) cout<<grade<<" GOOD!"<<endl;
         if(grade<60) cout<<grade<<" fail!"<<endl;
         cout<<"enter grade:";
       }
       cout<<"The end."<<endl;
       return 0;
    }

       流提取符“>>”不断地从输人流中提取数据(每次提取一个浮点数),如果成功,就赋给变量grade,此时cin为真,若不成功则cin为假。如果输入文件结束符,表示数据已完。

    运行情况如下:
       enter grade:67
       enter grade:89/
       89 GOOD!
       enter grade:56s/
       56 fail!
       entergrade:100
       100 GOOD!
       enter grade:^Z //输入文件结束符
       The end.

    在遇到文件结束符时,程序结束。如果某次输入的数据为: enter grade:100/2 (回车)
    流提取符“>>”提取100,赋给grade,进行if语句的处理。然后再遇到“/”,认为是无效字符,cin返回o。循环结束,输出"Theend.”。
    在不同的C++系统下运行此程序,在最后的处理上有些不同。以上是在GCC环境下运行程序的结果,如果在VC++环境下运行此程序,在键人Ctrl+z时,程序运行马上结束,不输出”Theend.”。

    八、 用于字符输入的流成员函数

    除了可以用CIB输入标准类型的数据外,还可以用istream类流对象的一些成员函数,实现字符的输入。

    1、用get函数读入一个字符
    流成员函数get有3种形式:无参数的,有一个参数的,有3个参数的。

    (1)不带参数的get函数

    其调用形式为: cin.get() //用来从指定的输人流中提取一个字符(包括空白字符)函数的返回值就是读入的字符。

       若遇到输入流中的文件结束符,则函数值返回文件结束标志EOF(End Of File),一般以-1代表EOF,用-1而不用0或正值,是考虑到不与字符的ASCII代码混淆,但不同的C++系统所用的EOF值有可能不同。

    例6 用get函数读人字符。
       从键盘输入一行字符,用cin.get()逐个读人字符,将读入字符赋给字符变量c。如果c的值不等于EOF(EOF是在lostream头文件中定义的符号常量,代表-1),表示已成功地读入一个有效字符,然后通过put函数输出该字符。
    #include <iostream>
    using namespace std;
    int main()
    { 
       char c;
       cout<<"enter a sentence:"<<endl;
       while((c=cin.get())!=EOF)
       cout.put(c);
       return 0; 
    }

    运行情况如下:
       enter a sentence:
       I study C++ very hard. (输入一行字符)
       I study C++ very hard. (输出该行字符)
       ^Z/(程序结束)

       C语言中的getchar函数与流成员函数cin.get()的功能相同,C++保留厂C的这种用法,可以用getchar(c)从键盘读取一个字符赋给变量c。

    (2)有一个参数的get函数

    其调用形式为:
       cin.get(ch)// 其作用是从输人流中读取一个字符,赋给字符变量ch。

       如果读取成功则函数返回非。值(真),如失败(遇文件结束符)则函数返回。值(假)。例6可以改写如下:
    #include<iostream>
    int main()
    { 
       char c;
       cout<<"enter a sentence:"<<endl;
       while(cin.get(c)) //读取—个字符赋给字符变量c,如果读取成功,cin.get(c)为真
       { 
            cout.put(c);
        }
       cout<<"end"<<endl:
       return 0;
    }

    (3)有3个参数的get函数

    其调用形式为
         cin.get(字符数组,字符个数n,终止字符)
       或
         cin.get(字符指针,字符个数n,终止字符)

       其作用是从输入流中读取n-1个字符,赋给指定的字符数组(或字符指针指向的数组),如果在读取n-1个字符之前遇到指定的终止字符,则提前结束读取。如果读取成功则函数返回非0值(真),如失败(遇文件结束符)则函数返回0值(假)。再将例6改写如下:
    #include<iostream>
    using namespace std;
    int main()
    { 
       char ch[20];
       cout<<"enter a sentence:”<<endl;
       cin.get(ch,10,'\n'); //指定换行符为终止字符
       cout<<ch<<endl;
       return(); 
    }
    运行情况如下:
       enter a sentence:
       I study C++ very hard.
       I study C

        在输人流中有22个字符,但由于在get函数中指定的n为10,读取n-1个(即9个)字符并赋给字符数组ch中前9个元素。有人可能要问:指定n=10,为什么只读取9个字符呢?因为存放的是一个字符串,因此在9个字符之后要加入一个字符中结束标志 '\0',实际上存放到数组中的是10个字符。请读者思考:如果不加入字符串结束标志,会出现什么情况?结果是:在用"cout<<ch”;输出数组中的字符时,不是输出读人的字符串,而是数组中的全部元素。读者可以上机检查一下ch[9](即数组中第10个元素)的值是什么?
    如果输入: abcde/

    2.用成员函数getline函数读入一行字符
       getline函数的作用是从输人流中读取一行字符,其用法与带3个参数的get函数类 似。

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

    例7 用getline函数读入一行字符。
    #include <iostream>
    using namespace std;
    int main()
    { 
       char ch[20];
       cout<<"enter a sentence:"<<endl;
       cin>>ch;
       cout<<"The string read with cin is:"<<ch<<endl;
       cin.getline(ch,20,'/');//读19个字符或遇'/'结束
       cout<<"The second part is:"<<ch<<endl;
       cin.getline(ch,20); //读l9个字符或遇'/n',结束
       cout<<"The third part is:"<<ch<<endl;
       return 0; 
    }
    程序运行情况如下:
    enter a sentence:I like C++./I study C++./I am happy.(回车)
    The stung read with cin is:I
    The second part is:like C++.
    The third part is:I study C++./I am h

    有几点说明并请思考:
       1、如果第2个cin.getline函数也写成cin.getline(ch,20,'/'),输出结果会如何?
    此时最后一行的输出为:
    The third part is:I study C++

       2、如果在用cin.getline(ch,20,'/')从输入流读取数据时,遇到回车键('\n'),是否结束读取?结论是此时'/n'不是结束标志。'/n'被作为一个字符被读人。

       3、用gefiine函数从输入流读字符时,遇到终止标志字符时结束,指针移到该终止标志字符之后,下一个getline函数将从该终止标志的下一个字符开始接着读人,如本程序运行结果所示那样。如果用cln.get函数从输人流读字符时,遇终止标志字符时停止读取,指针不向后移动,仍然停留在原位置。下一次读取时仍从该终止标志字符开始。这是getline函数和get函数不同之处。   
       因此用get函数时要特别注意,必要时用其他方法跳过该终止标志字符(如用下面介绍的ignore函数。但一般来说还是用getline函数更方便。

       4、请比较用"cin<<”和用成员函数cin.getline()读数据的区别。用"cin<<”读数据时以空白字符(包括空格、tab键、回车键)作为终止标志,而用cln.gefline()读数据时连续读取一系列字符,可以包括空格。用"cin<<”可以读取C++的标准类型的各类型数据(如果经过重载,还可以用于输入自定义类型的数据),而用cin.getline()只用于输入字符型数据。

    九、istrearn类的其他成员函数

       除了以上介绍的用于读取数据的成员函数外,lstream类还有其他在输入数据时用得着的一些成员函数。常用的有以下几种:

    1.eof函数
       eof是end of file的缩写,表示“文件结束”。从输人流读取数据,如果到达文件末尾(遇文件结束符),eof函数值为非零值(表示真),否则为o(假)。这个函数是很有用的,经常会用到。

    例8 逐个读入一行字符,将其中的非空格字符输出。
    #include <iostream>
    using namespace std;
    int main()
    { 
       char c;
       while(!cin.eof())    //eof()为假表示未遇到文件结束符
       if((c=cin.get())!=' ')//检查读入的字符是否为空格字符
          cout.put(c);
       return 0; 
    }
    运行情况如下:
       C++ is very interesting.
       C++ is veryinteresting.
       ^z(结束)

    2.peek函数
       peek是“观察”的意思,peek函数的作用是观测下一个字符。其调用形式为
          c=cin.peek();
       cin.peek函数的返回值是指针指向的当前字符,但它只是观测,指针仍停留在当前位置,并不后移。如果要访问的字符是文件结束符,则函数值是EOF(-1)。

    3.putback函数
       其调用形式为
          cin.putback(ch);
       其作用是将前面用get或getline函数从输人流中读取的字符ch返回到输人流,插入到当前指针位置,以供后面读取。

    例9 peek函数和putback函数的用法。
    #include <iostream>
    using namespace std;
    int main()
    { 
       char c[20];
       int ch;
       cout<<"please enter a sentence."<<endl;
       cin.getline(c,15,'/');
       cout<<"The first part is:"<<c<<endl;
       ch=cin.peek(); //观看当前字符
       cout<<"The next character(ASCII code) is:"<<ch<<endl;
       cin.putback(c[0]);//将'I'插入到指针所指处
       cin.getline(c,15,'/');
       cout<<"The second part is:"<<c<<endl;
       return 0; 
    }
    运行情况如下:
       please enter a sentence:
       I am a boy./I am astudent./ (回车)
       The first part is:I am a boy.
       The next chamcter(ASCII code) is:32 (下一个字符是空格)
       The second part is:I an a student

    4.ignore函数

       其调用形式为: cin.ignore(n,终止字符) // 函数作用是跳过输人流中n个字符,或在遇到指定的终止字符时提前结束(此时跳过包括终止字符在内的若干字符)。
    如:
          ighore(5,A,) //跳过输入流中5个字符,遇A后就不再跳了
       也可以不带参数或只带一个参数。如
          ignore() (n默认值为1,终止字符默认为EOF)
       相当于:  ignore(1,EOF)

    例10 用ignore函数跳过输入流中的字符。
    先看不用ignore函数的情况:
    #include <iostream>
    using namespace std;
    int main()
    { 
       char ch[20];
       cin.get(ch,20,'/');
       cout<<"The first part is:"<<ch<<endl;
       cin.get(ch,20,'/');
       cout<<"The second part is:"<<ch<<endl;
       return 0;
    }
    运行结果如下:
       I like C++./I study C++./I am happy.
       The first part is: I like C++
       The second part is (字符数组ch中没有从输人流中读取有效字符)

       前面已对此作过说明。如果希望第二个tin.get函数能读取”I study C++.”,就应该设法跳过输人流中第一个'/'可以用ignore函数来实现此日的,将程序改为:
    #include <iostream>
    using namespace std;
    int main()
    { 
       char ch[20];
       cin.get(ch,20,'/');
       cout<<"The first part is:"<<ch<<endl;
       cin.ignore(); //跳过输入流中一个字符
       cin.get(ch,20,'/');
       cout<<"The second part is:"<<ch<<endl;
       return 0; 
    }
    运行结果如下:
       I like C++./I study C++./I am happy.
       The first part is:I like C++.
       The second part is: I study C++.

    以上介绍的各个成员函数,不仅可以用cin流对象来调用,而且也可以用istream类的其他流对象调用。


    展开全文
  • 标准输入输出流以及标准错误输出流的基本使用: System.out是一个特殊的 PrintStream "标准"输出流==》 输出结果到控制台System.err是一个特殊的 PrintStream "标准"错误输出流==》输出到控制台System.in是一个...
  • 先看一段代码 Exception e = new Exception("i is exception"); e.printStackTrace();...System.out打印的内容在e.printStackTrace()之前输出!太不可思议了。 查看e.printStackTrace()源代码发现,...
  • C++标准输出流换向(cout打印到文件)

    千次阅读 2022-03-26 21:50:38
    C++标准输出流换向(cout打印到文件)
  • //保存原输出流 PrintStream out=System.out; //保存原错误输出流 PrintStream err=System.err; //建立新的输出流 PrintStream ps=new PrintStream("./log.txt"); System.out....
  • IO流相关知识(File,字节流,字符流,特殊操作流(标准输入流,标准输出流,对象序列化与反序列化,properties与IO流结合))相关知识总结 文章目录IO流相关知识(File,字节流,字符流,特殊操作流(标准输入流,...
  • 在命令行可使用的命令,可以使用C#代码启动,并可以重定向该命令执行所得的标准输出流、標準輸入流和标准錯誤流。 具體類似代碼如下: private List GetP4CommandLineStandardOutput(string strArgs, IP4...
  • python 标准输入输出流

    千次阅读 2016-11-13 23:58:06
    python 中有三种标准输入输出流:sys.stdin、sys.stdout、sys.error>>> f = open("1.txt", "r") # fileno方法可返回整数的底层...#一般打开的第一个文件是第三个,前3个(从0开始)为三个标准输出流 >>> sys.stdin.fil
  • 第二十讲: C++的输入和输出与标准输出流 本讲基本要求  * 掌握:输入输出的含意;文件流以及输入/输出的格式控制;标准输出在C++程序中的应用。  * 理解:C++类库中的常用流类。  * ...
  • Java中标准的输入输出流

    万次阅读 2018-05-24 16:41:04
    标准的输入输出流 InputStream in = System.in PrintStream out = Syste.out程序示例InputStream in = System.in public static void main(String[] args) throws IOException { //标准输入流 ...
  • 标准输入输出流 概述 System.in:标准的输入流,默认从键盘输入 System.out:标准输出流,默认从控制台输出 可以使用System类的setIn(InputStream is)改变其输入对象 可以使用System类的setOut(PrintStream ps)...
  • c++中的标准输入/输出流对象

    千次阅读 2019-09-11 14:58:10
    一、标准输入对象cin cin必须与运算符>>配套使用例如: cin>>x; 当用户从键盘输入的数值时,输入的数值会自动转换为变量x的类型,并存入变量x内。 注意:x必须是基本数据类型,而不能是void...
  • 详解Python的标准输入输出

    千次阅读 2020-12-29 09:42:37
    本篇文章给大家分享的是详解Python的标准输入输出,内容挺不错...这个函数传递表达式转换为一个字符串,如下结果写到标准输出 -print ("Python is really a great language,", "isn't it?")这将产生以下结果标准屏幕...
  • 在lunix中,有三种标准流:标准输入流、标准输出流、标准错误流。为了区分这三种流,linux分别为他们编号0, 1,2 进行区分。也就是说标准输入流的编号为0、标准输出流 为1 、标准错误流编号为2。在默认的情况下,l....
  • public static final PrintStream out:标准输出流。通常该流对应于显示输出或者由主机环境或用户指定的另一个输出目标 我们先看标准输入流 package com.testIO; import java.io.IOException; import java...
  • java的标准输入/输出流

    千次阅读 2017-04-19 20:22:10
    大体了解了一些java中标准流变量和...Java通过系统类System实现标准输入/输出的功能,定义了3个变量:in,out,和err.这3个在Java中都定义为静态变量,可以直接通过System类进行调用。System.in表示标准输入
  • Java输入输出流

    千次阅读 2021-02-12 21:28:28
    Java的I/O提供了读写数据的标准方法。任何Java中表示数据源的对象都会提供以数据的方式读写它的数据的方法。Java.io是大多数面向数据的输入/输出类的主要软件包。此外,Java也对块传输提供支持,在核心库 java...
  • 标题限制,完整问题为------dialog工具中,对于...而不是“标准输出流”? 看Neil Matthew著的《Linux程序设计》65页中关于dialog访问用户输入结果的一点思考,想知道其中的一些机制。小白求助亲们解答一些,谢谢。
  • C++ 输入输出流和文件输入输出流

    千次阅读 2017-09-06 11:41:13
    输出到文件#include #include using namespace std; int i = 100; ofstream file("1.txt"); //文件输出对象,文件名绑定int main() { cout ; //输出到屏幕 file ; //输出
  • c++输入输出流

    千次阅读 2022-03-23 10:15:11
    输出操作中,字节从内存流向设备(例如,显示屏、打印机、磁盘驱动器、网络连接等)。 应用程序通过字节传达信息。字节可以组成字符、原始数据、图形图像、数字语音、数字视频或者任何应用程序所需要的其他信息。...
  • 在电脑某盘根目录下放一个文本文件....1.使用标准输出流(system.out)来做。 2.使用打印流; (PrintWriter)来做。 import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReade
  • Java中标准输入输出流的重定向

    千次阅读 2014-12-10 23:57:37
    一、问题的引入: 一般情况下,System.in代表的是键盘、System.out是代表的控制台(显示器)。当程序通过System.in来获取输入的时候,默认情况下,是从...输出的时候,不是输出到显示器上显示,而是输出到文件或其他
  • fuction:解析shell输出流获取包含IP,mask信息的json包。*/ #include #include #include #include #include "json/json.h" using namespace std; Json::Value value; unsigned int read_shell_output(string ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 444,227
精华内容 177,690
关键字:

标准输出流